← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/xvidcap/jaunty-proposed

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/ac3enc.c

  • Committer: Bazaar Package Importer
  • Author(s): Lionel Le Folgoc, Andrew Starr-Bochicchio, Lionel Le Folgoc
  • Date: 2008-12-26 00:10:06 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20081226001006-2040ls9680bd1blt
Tags: 1.1.7-0.2ubuntu1
https://launchpad.net/bugs/298547
https://launchpad.net/bugs/311412
[ Andrew Starr-Bochicchio ]
* Merge from debian-multimedia (LP: #298547), Ubuntu Changes:
 - For ffmpeg-related build-deps, fix versionized dependencies
   as the ubuntu versioning is different than debian-multimedia's.

[ Lionel Le Folgoc ]
* LP: #311412 is fixed since the 1.1.7~rc1-0.1 revision.
* debian/patches/03_ffmpeg.diff: updated to fix FTBFS due to libswscale API
  change (cherry-pick from Gentoo #234383).

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/ac3enc.c
37
37
    int lfe_channel;
38
38
    int bit_rate;
39
39
    unsigned int sample_rate;
40
 
    unsigned int bsid;
 
40
    unsigned int bitstream_id;
41
41
    unsigned int frame_size_min; /* minimum frame size in case rounding is necessary */
42
42
    unsigned int frame_size; /* current frame size in words */
43
43
    unsigned int bits_written;
44
44
    unsigned int samples_written;
45
 
    int halfratecod;
46
 
    unsigned int frmsizecod;
47
 
    unsigned int fscod; /* frequency */
48
 
    unsigned int acmod;
 
45
    int sr_shift;
 
46
    unsigned int frame_size_code;
 
47
    unsigned int sr_code; /* frequency */
 
48
    unsigned int channel_mode;
49
49
    int lfe;
50
 
    unsigned int bsmod;
 
50
    unsigned int bitstream_mode;
51
51
    short last_samples[AC3_MAX_CHANNELS][256];
52
52
    unsigned int chbwcod[AC3_MAX_CHANNELS];
53
53
    int nb_coefs[AC3_MAX_CHANNELS];
54
54
 
55
55
    /* bitrate allocation control */
56
 
    int sgaincod, sdecaycod, fdecaycod, dbkneecod, floorcod;
 
56
    int slow_gain_code, slow_decay_code, fast_decay_code, db_per_bit_code, floor_code;
57
57
    AC3BitAllocParameters bit_alloc;
58
 
    int csnroffst;
59
 
    int fgaincod[AC3_MAX_CHANNELS];
60
 
    int fsnroffst[AC3_MAX_CHANNELS];
 
58
    int coarse_snr_offset;
 
59
    int fast_gain_code[AC3_MAX_CHANNELS];
 
60
    int fine_snr_offset[AC3_MAX_CHANNELS];
61
61
    /* mantissa encoding */
62
62
    int mant1_cnt, mant2_cnt, mant4_cnt;
63
63
} AC3EncodeContext;
64
64
 
65
 
#include "ac3tab.h"
 
65
static int16_t costab[64];
 
66
static int16_t sintab[64];
 
67
static int16_t xcos1[128];
 
68
static int16_t xsin1[128];
66
69
 
67
70
#define MDCT_NBITS 9
68
71
#define N         (1 << MDCT_NBITS)
70
73
/* new exponents are sent if their Norm 1 exceed this number */
71
74
#define EXP_DIFF_THRESHOLD 1000
72
75
 
73
 
static void fft_init(int ln);
74
 
 
75
76
static inline int16_t fix15(float a)
76
77
{
77
78
    int v;
83
84
    return v;
84
85
}
85
86
 
86
 
static inline int calc_lowcomp1(int a, int b0, int b1)
87
 
{
88
 
    if ((b0 + 256) == b1) {
89
 
        a = 384 ;
90
 
    } else if (b0 > b1) {
91
 
        a = a - 64;
92
 
        if (a < 0) a=0;
93
 
    }
94
 
    return a;
95
 
}
96
 
 
97
 
static inline int calc_lowcomp(int a, int b0, int b1, int bin)
98
 
{
99
 
    if (bin < 7) {
100
 
        if ((b0 + 256) == b1) {
101
 
            a = 384 ;
102
 
        } else if (b0 > b1) {
103
 
            a = a - 64;
104
 
            if (a < 0) a=0;
105
 
        }
106
 
    } else if (bin < 20) {
107
 
        if ((b0 + 256) == b1) {
108
 
            a = 320 ;
109
 
        } else if (b0 > b1) {
110
 
            a= a - 64;
111
 
            if (a < 0) a=0;
112
 
        }
113
 
    } else {
114
 
        a = a - 128;
115
 
        if (a < 0) a=0;
116
 
    }
117
 
    return a;
118
 
}
119
 
 
120
 
/* AC3 bit allocation. The algorithm is the one described in the AC3
121
 
   spec. */
122
 
void ac3_parametric_bit_allocation(AC3BitAllocParameters *s, uint8_t *bap,
123
 
                                   int8_t *exp, int start, int end,
124
 
                                   int snroffset, int fgain, int is_lfe,
125
 
                                   int deltbae,int deltnseg,
126
 
                                   uint8_t *deltoffst, uint8_t *deltlen, uint8_t *deltba)
127
 
{
128
 
    int bin,i,j,k,end1,v,v1,bndstrt,bndend,lowcomp,begin;
129
 
    int fastleak,slowleak,address,tmp;
130
 
    int16_t psd[256]; /* scaled exponents */
131
 
    int16_t bndpsd[50]; /* interpolated exponents */
132
 
    int16_t excite[50]; /* excitation */
133
 
    int16_t mask[50];   /* masking value */
134
 
 
135
 
    /* exponent mapping to PSD */
136
 
    for(bin=start;bin<end;bin++) {
137
 
        psd[bin]=(3072 - (exp[bin] << 7));
138
 
    }
139
 
 
140
 
    /* PSD integration */
141
 
    j=start;
142
 
    k=masktab[start];
143
 
    do {
144
 
        v=psd[j];
145
 
        j++;
146
 
        end1=bndtab[k+1];
147
 
        if (end1 > end) end1=end;
148
 
        for(i=j;i<end1;i++) {
149
 
            int c,adr;
150
 
            /* logadd */
151
 
            v1=psd[j];
152
 
            c=v-v1;
153
 
            if (c >= 0) {
154
 
                adr=c >> 1;
155
 
                if (adr > 255) adr=255;
156
 
                v=v + latab[adr];
157
 
            } else {
158
 
                adr=(-c) >> 1;
159
 
                if (adr > 255) adr=255;
160
 
                v=v1 + latab[adr];
161
 
            }
162
 
            j++;
163
 
        }
164
 
        bndpsd[k]=v;
165
 
        k++;
166
 
    } while (end > bndtab[k]);
167
 
 
168
 
    /* excitation function */
169
 
    bndstrt = masktab[start];
170
 
    bndend = masktab[end-1] + 1;
171
 
 
172
 
    if (bndstrt == 0) {
173
 
        lowcomp = 0;
174
 
        lowcomp = calc_lowcomp1(lowcomp, bndpsd[0], bndpsd[1]) ;
175
 
        excite[0] = bndpsd[0] - fgain - lowcomp ;
176
 
        lowcomp = calc_lowcomp1(lowcomp, bndpsd[1], bndpsd[2]) ;
177
 
        excite[1] = bndpsd[1] - fgain - lowcomp ;
178
 
        begin = 7 ;
179
 
        for (bin = 2; bin < 7; bin++) {
180
 
            if (!(is_lfe && bin == 6))
181
 
                lowcomp = calc_lowcomp1(lowcomp, bndpsd[bin], bndpsd[bin+1]) ;
182
 
            fastleak = bndpsd[bin] - fgain ;
183
 
            slowleak = bndpsd[bin] - s->sgain ;
184
 
            excite[bin] = fastleak - lowcomp ;
185
 
            if (!(is_lfe && bin == 6)) {
186
 
                if (bndpsd[bin] <= bndpsd[bin+1]) {
187
 
                    begin = bin + 1 ;
188
 
                    break ;
189
 
                }
190
 
            }
191
 
        }
192
 
 
193
 
        end1=bndend;
194
 
        if (end1 > 22) end1=22;
195
 
 
196
 
        for (bin = begin; bin < end1; bin++) {
197
 
            if (!(is_lfe && bin == 6))
198
 
                lowcomp = calc_lowcomp(lowcomp, bndpsd[bin], bndpsd[bin+1], bin) ;
199
 
 
200
 
            fastleak -= s->fdecay ;
201
 
            v = bndpsd[bin] - fgain;
202
 
            if (fastleak < v) fastleak = v;
203
 
 
204
 
            slowleak -= s->sdecay ;
205
 
            v = bndpsd[bin] - s->sgain;
206
 
            if (slowleak < v) slowleak = v;
207
 
 
208
 
            v=fastleak - lowcomp;
209
 
            if (slowleak > v) v=slowleak;
210
 
 
211
 
            excite[bin] = v;
212
 
        }
213
 
        begin = 22;
214
 
    } else {
215
 
        /* coupling channel */
216
 
        begin = bndstrt;
217
 
 
218
 
        fastleak = (s->cplfleak << 8) + 768;
219
 
        slowleak = (s->cplsleak << 8) + 768;
220
 
    }
221
 
 
222
 
    for (bin = begin; bin < bndend; bin++) {
223
 
        fastleak -= s->fdecay ;
224
 
        v = bndpsd[bin] - fgain;
225
 
        if (fastleak < v) fastleak = v;
226
 
        slowleak -= s->sdecay ;
227
 
        v = bndpsd[bin] - s->sgain;
228
 
        if (slowleak < v) slowleak = v;
229
 
 
230
 
        v=fastleak;
231
 
        if (slowleak > v) v = slowleak;
232
 
        excite[bin] = v;
233
 
    }
234
 
 
235
 
    /* compute masking curve */
236
 
 
237
 
    for (bin = bndstrt; bin < bndend; bin++) {
238
 
        v1 = excite[bin];
239
 
        tmp = s->dbknee - bndpsd[bin];
240
 
        if (tmp > 0) {
241
 
            v1 += tmp >> 2;
242
 
        }
243
 
        v=hth[bin >> s->halfratecod][s->fscod];
244
 
        if (v1 > v) v=v1;
245
 
        mask[bin] = v;
246
 
    }
247
 
 
248
 
    /* delta bit allocation */
249
 
 
250
 
    if (deltbae == 0 || deltbae == 1) {
251
 
        int band, seg, delta;
252
 
        band = 0 ;
253
 
        for (seg = 0; seg < deltnseg; seg++) {
254
 
            band += deltoffst[seg] ;
255
 
            if (deltba[seg] >= 4) {
256
 
                delta = (deltba[seg] - 3) << 7;
257
 
            } else {
258
 
                delta = (deltba[seg] - 4) << 7;
259
 
            }
260
 
            for (k = 0; k < deltlen[seg]; k++) {
261
 
                mask[band] += delta ;
262
 
                band++ ;
263
 
            }
264
 
        }
265
 
    }
266
 
 
267
 
    /* compute bit allocation */
268
 
 
269
 
    i = start ;
270
 
    j = masktab[start] ;
271
 
    do {
272
 
        v=mask[j];
273
 
        v -= snroffset ;
274
 
        v -= s->floor ;
275
 
        if (v < 0) v = 0;
276
 
        v &= 0x1fe0 ;
277
 
        v += s->floor ;
278
 
 
279
 
        end1=bndtab[j] + bndsz[j];
280
 
        if (end1 > end) end1=end;
281
 
 
282
 
        for (k = i; k < end1; k++) {
283
 
            address = (psd[i] - v) >> 5 ;
284
 
            if (address < 0) address=0;
285
 
            else if (address > 63) address=63;
286
 
            bap[i] = baptab[address];
287
 
            i++;
288
 
        }
289
 
    } while (end > bndtab[j++]) ;
290
 
}
291
 
 
292
87
typedef struct IComplex {
293
88
    short re,im;
294
89
} IComplex;
295
90
 
296
91
static void fft_init(int ln)
297
92
{
298
 
    int i, j, m, n;
 
93
    int i, n;
299
94
    float alpha;
300
95
 
301
96
    n = 1 << ln;
305
100
        costab[i] = fix15(cos(alpha));
306
101
        sintab[i] = fix15(sin(alpha));
307
102
    }
308
 
 
309
 
    for(i=0;i<n;i++) {
310
 
        m=0;
311
 
        for(j=0;j<ln;j++) {
312
 
            m |= ((i >> j) & 1) << (ln-j-1);
313
 
        }
314
 
        fft_rev[i]=m;
315
 
    }
316
103
}
317
104
 
318
105
/* butter fly op */
350
137
 
351
138
    /* reverse */
352
139
    for(j=0;j<np;j++) {
353
 
        int k;
354
 
        IComplex tmp;
355
 
        k = fft_rev[j];
356
 
        if (k < j) {
357
 
            tmp = z[k];
358
 
            z[k] = z[j];
359
 
            z[j] = tmp;
360
 
        }
 
140
        int k = ff_reverse[j] >> (8 - ln);
 
141
        if (k < j)
 
142
            FFSWAP(IComplex, z[k], z[j]);
361
143
    }
362
144
 
363
145
    /* pass 0 */
633
415
}
634
416
 
635
417
 
 
418
static void bit_alloc_masking(AC3EncodeContext *s,
 
419
                              uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
 
420
                              uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS],
 
421
                              int16_t psd[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
 
422
                              int16_t mask[NB_BLOCKS][AC3_MAX_CHANNELS][50])
 
423
{
 
424
    int blk, ch;
 
425
    int16_t band_psd[NB_BLOCKS][AC3_MAX_CHANNELS][50];
 
426
 
 
427
    for(blk=0; blk<NB_BLOCKS; blk++) {
 
428
        for(ch=0;ch<s->nb_all_channels;ch++) {
 
429
            if(exp_strategy[blk][ch] == EXP_REUSE) {
 
430
                memcpy(psd[blk][ch], psd[blk-1][ch], (N/2)*sizeof(int16_t));
 
431
                memcpy(mask[blk][ch], mask[blk-1][ch], 50*sizeof(int16_t));
 
432
            } else {
 
433
                ff_ac3_bit_alloc_calc_psd(encoded_exp[blk][ch], 0,
 
434
                                          s->nb_coefs[ch],
 
435
                                          psd[blk][ch], band_psd[blk][ch]);
 
436
                ff_ac3_bit_alloc_calc_mask(&s->bit_alloc, band_psd[blk][ch],
 
437
                                           0, s->nb_coefs[ch],
 
438
                                           ff_ac3_fast_gain_tab[s->fast_gain_code[ch]],
 
439
                                           ch == s->lfe_channel,
 
440
                                           DBA_NONE, 0, NULL, NULL, NULL,
 
441
                                           mask[blk][ch]);
 
442
            }
 
443
        }
 
444
    }
 
445
}
 
446
 
636
447
static int bit_alloc(AC3EncodeContext *s,
 
448
                     int16_t mask[NB_BLOCKS][AC3_MAX_CHANNELS][50],
 
449
                     int16_t psd[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
637
450
                     uint8_t bap[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
638
 
                     uint8_t encoded_exp[NB_BLOCKS][AC3_MAX_CHANNELS][N/2],
639
 
                     uint8_t exp_strategy[NB_BLOCKS][AC3_MAX_CHANNELS],
640
 
                     int frame_bits, int csnroffst, int fsnroffst)
 
451
                     int frame_bits, int coarse_snr_offset, int fine_snr_offset)
641
452
{
642
453
    int i, ch;
 
454
    int snr_offset;
 
455
 
 
456
    snr_offset = (((coarse_snr_offset - 15) << 4) + fine_snr_offset) << 2;
643
457
 
644
458
    /* compute size */
645
459
    for(i=0;i<NB_BLOCKS;i++) {
647
461
        s->mant2_cnt = 0;
648
462
        s->mant4_cnt = 0;
649
463
        for(ch=0;ch<s->nb_all_channels;ch++) {
650
 
            ac3_parametric_bit_allocation(&s->bit_alloc,
651
 
                                          bap[i][ch], (int8_t *)encoded_exp[i][ch],
652
 
                                          0, s->nb_coefs[ch],
653
 
                                          (((csnroffst-15) << 4) +
654
 
                                           fsnroffst) << 2,
655
 
                                          fgaintab[s->fgaincod[ch]],
656
 
                                          ch == s->lfe_channel,
657
 
                                          2, 0, NULL, NULL, NULL);
 
464
            ff_ac3_bit_alloc_calc_bap(mask[i][ch], psd[i][ch], 0,
 
465
                                      s->nb_coefs[ch], snr_offset,
 
466
                                      s->bit_alloc.floor, bap[i][ch]);
658
467
            frame_bits += compute_mantissa_size(s, bap[i][ch],
659
468
                                                 s->nb_coefs[ch]);
660
469
        }
661
470
    }
662
471
#if 0
663
472
    printf("csnr=%d fsnr=%d frame_bits=%d diff=%d\n",
664
 
           csnroffst, fsnroffst, frame_bits,
 
473
           coarse_snr_offset, fine_snr_offset, frame_bits,
665
474
           16 * s->frame_size - ((frame_bits + 7) & ~7));
666
475
#endif
667
476
    return 16 * s->frame_size - frame_bits;
676
485
                                  int frame_bits)
677
486
{
678
487
    int i, ch;
679
 
    int csnroffst, fsnroffst;
 
488
    int coarse_snr_offset, fine_snr_offset;
680
489
    uint8_t bap1[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
 
490
    int16_t psd[NB_BLOCKS][AC3_MAX_CHANNELS][N/2];
 
491
    int16_t mask[NB_BLOCKS][AC3_MAX_CHANNELS][50];
681
492
    static int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 };
682
493
 
683
494
    /* init default parameters */
684
 
    s->sdecaycod = 2;
685
 
    s->fdecaycod = 1;
686
 
    s->sgaincod = 1;
687
 
    s->dbkneecod = 2;
688
 
    s->floorcod = 4;
 
495
    s->slow_decay_code = 2;
 
496
    s->fast_decay_code = 1;
 
497
    s->slow_gain_code = 1;
 
498
    s->db_per_bit_code = 2;
 
499
    s->floor_code = 4;
689
500
    for(ch=0;ch<s->nb_all_channels;ch++)
690
 
        s->fgaincod[ch] = 4;
 
501
        s->fast_gain_code[ch] = 4;
691
502
 
692
503
    /* compute real values */
693
 
    s->bit_alloc.fscod = s->fscod;
694
 
    s->bit_alloc.halfratecod = s->halfratecod;
695
 
    s->bit_alloc.sdecay = sdecaytab[s->sdecaycod] >> s->halfratecod;
696
 
    s->bit_alloc.fdecay = fdecaytab[s->fdecaycod] >> s->halfratecod;
697
 
    s->bit_alloc.sgain = sgaintab[s->sgaincod];
698
 
    s->bit_alloc.dbknee = dbkneetab[s->dbkneecod];
699
 
    s->bit_alloc.floor = floortab[s->floorcod];
 
504
    s->bit_alloc.sr_code = s->sr_code;
 
505
    s->bit_alloc.sr_shift = s->sr_shift;
 
506
    s->bit_alloc.slow_decay = ff_ac3_slow_decay_tab[s->slow_decay_code] >> s->sr_shift;
 
507
    s->bit_alloc.fast_decay = ff_ac3_fast_decay_tab[s->fast_decay_code] >> s->sr_shift;
 
508
    s->bit_alloc.slow_gain = ff_ac3_slow_gain_tab[s->slow_gain_code];
 
509
    s->bit_alloc.db_per_bit = ff_ac3_db_per_bit_tab[s->db_per_bit_code];
 
510
    s->bit_alloc.floor = ff_ac3_floor_tab[s->floor_code];
700
511
 
701
512
    /* header size */
702
513
    frame_bits += 65;
703
 
    // if (s->acmod == 2)
 
514
    // if (s->channel_mode == 2)
704
515
    //    frame_bits += 2;
705
 
    frame_bits += frame_bits_inc[s->acmod];
 
516
    frame_bits += frame_bits_inc[s->channel_mode];
706
517
 
707
518
    /* audio blocks */
708
519
    for(i=0;i<NB_BLOCKS;i++) {
709
520
        frame_bits += s->nb_channels * 2 + 2; /* blksw * c, dithflag * c, dynrnge, cplstre */
710
 
        if (s->acmod == 2) {
 
521
        if (s->channel_mode == AC3_CHMODE_STEREO) {
711
522
            frame_bits++; /* rematstr */
712
523
            if(i==0) frame_bits += 4;
713
524
        }
735
546
    /* CRC */
736
547
    frame_bits += 16;
737
548
 
 
549
    /* calculate psd and masking curve before doing bit allocation */
 
550
    bit_alloc_masking(s, encoded_exp, exp_strategy, psd, mask);
 
551
 
738
552
    /* now the big work begins : do the bit allocation. Modify the snr
739
553
       offset until we can pack everything in the requested frame size */
740
554
 
741
 
    csnroffst = s->csnroffst;
742
 
    while (csnroffst >= 0 &&
743
 
           bit_alloc(s, bap, encoded_exp, exp_strategy, frame_bits, csnroffst, 0) < 0)
744
 
        csnroffst -= SNR_INC1;
745
 
    if (csnroffst < 0) {
746
 
        av_log(NULL, AV_LOG_ERROR, "Bit allocation failed, try increasing the bitrate, -ab 384 for example!\n");
 
555
    coarse_snr_offset = s->coarse_snr_offset;
 
556
    while (coarse_snr_offset >= 0 &&
 
557
           bit_alloc(s, mask, psd, bap, frame_bits, coarse_snr_offset, 0) < 0)
 
558
        coarse_snr_offset -= SNR_INC1;
 
559
    if (coarse_snr_offset < 0) {
 
560
        av_log(NULL, AV_LOG_ERROR, "Bit allocation failed. Try increasing the bitrate.\n");
747
561
        return -1;
748
562
    }
749
 
    while ((csnroffst + SNR_INC1) <= 63 &&
750
 
           bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits,
751
 
                     csnroffst + SNR_INC1, 0) >= 0) {
752
 
        csnroffst += SNR_INC1;
753
 
        memcpy(bap, bap1, sizeof(bap1));
754
 
    }
755
 
    while ((csnroffst + 1) <= 63 &&
756
 
           bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits, csnroffst + 1, 0) >= 0) {
757
 
        csnroffst++;
758
 
        memcpy(bap, bap1, sizeof(bap1));
759
 
    }
760
 
 
761
 
    fsnroffst = 0;
762
 
    while ((fsnroffst + SNR_INC1) <= 15 &&
763
 
           bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits,
764
 
                     csnroffst, fsnroffst + SNR_INC1) >= 0) {
765
 
        fsnroffst += SNR_INC1;
766
 
        memcpy(bap, bap1, sizeof(bap1));
767
 
    }
768
 
    while ((fsnroffst + 1) <= 15 &&
769
 
           bit_alloc(s, bap1, encoded_exp, exp_strategy, frame_bits,
770
 
                     csnroffst, fsnroffst + 1) >= 0) {
771
 
        fsnroffst++;
772
 
        memcpy(bap, bap1, sizeof(bap1));
773
 
    }
774
 
 
775
 
    s->csnroffst = csnroffst;
 
563
    while ((coarse_snr_offset + SNR_INC1) <= 63 &&
 
564
           bit_alloc(s, mask, psd, bap1, frame_bits,
 
565
                     coarse_snr_offset + SNR_INC1, 0) >= 0) {
 
566
        coarse_snr_offset += SNR_INC1;
 
567
        memcpy(bap, bap1, sizeof(bap1));
 
568
    }
 
569
    while ((coarse_snr_offset + 1) <= 63 &&
 
570
           bit_alloc(s, mask, psd, bap1, frame_bits, coarse_snr_offset + 1, 0) >= 0) {
 
571
        coarse_snr_offset++;
 
572
        memcpy(bap, bap1, sizeof(bap1));
 
573
    }
 
574
 
 
575
    fine_snr_offset = 0;
 
576
    while ((fine_snr_offset + SNR_INC1) <= 15 &&
 
577
           bit_alloc(s, mask, psd, bap1, frame_bits,
 
578
                     coarse_snr_offset, fine_snr_offset + SNR_INC1) >= 0) {
 
579
        fine_snr_offset += SNR_INC1;
 
580
        memcpy(bap, bap1, sizeof(bap1));
 
581
    }
 
582
    while ((fine_snr_offset + 1) <= 15 &&
 
583
           bit_alloc(s, mask, psd, bap1, frame_bits,
 
584
                     coarse_snr_offset, fine_snr_offset + 1) >= 0) {
 
585
        fine_snr_offset++;
 
586
        memcpy(bap, bap1, sizeof(bap1));
 
587
    }
 
588
 
 
589
    s->coarse_snr_offset = coarse_snr_offset;
776
590
    for(ch=0;ch<s->nb_all_channels;ch++)
777
 
        s->fsnroffst[ch] = fsnroffst;
 
591
        s->fine_snr_offset[ch] = fine_snr_offset;
778
592
#if defined(DEBUG_BITALLOC)
779
593
    {
780
594
        int j;
794
608
    return 0;
795
609
}
796
610
 
797
 
void ac3_common_init(void)
798
 
{
799
 
    int i, j, k, l, v;
800
 
    /* compute bndtab and masktab from bandsz */
801
 
    k = 0;
802
 
    l = 0;
803
 
    for(i=0;i<50;i++) {
804
 
        bndtab[i] = l;
805
 
        v = bndsz[i];
806
 
        for(j=0;j<v;j++) masktab[k++]=i;
807
 
        l += v;
808
 
    }
809
 
    bndtab[50] = l;
810
 
}
811
 
 
812
 
 
813
 
static int AC3_encode_init(AVCodecContext *avctx)
 
611
static av_cold int AC3_encode_init(AVCodecContext *avctx)
814
612
{
815
613
    int freq = avctx->sample_rate;
816
614
    int bitrate = avctx->bit_rate;
818
616
    AC3EncodeContext *s = avctx->priv_data;
819
617
    int i, j, ch;
820
618
    float alpha;
821
 
    static const uint8_t acmod_defs[6] = {
 
619
    int bw_code;
 
620
    static const uint8_t channel_mode_defs[6] = {
822
621
        0x01, /* C */
823
622
        0x02, /* L R */
824
623
        0x03, /* L C R */
829
628
 
830
629
    avctx->frame_size = AC3_FRAME_SIZE;
831
630
 
 
631
    ac3_common_init();
 
632
 
832
633
    /* number of channels */
833
634
    if (channels < 1 || channels > 6)
834
635
        return -1;
835
 
    s->acmod = acmod_defs[channels - 1];
 
636
    s->channel_mode = channel_mode_defs[channels - 1];
836
637
    s->lfe = (channels == 6) ? 1 : 0;
837
638
    s->nb_all_channels = channels;
838
639
    s->nb_channels = channels > 5 ? 5 : channels;
841
642
    /* frequency */
842
643
    for(i=0;i<3;i++) {
843
644
        for(j=0;j<3;j++)
844
 
            if ((ac3_freqs[j] >> i) == freq)
 
645
            if ((ff_ac3_sample_rate_tab[j] >> i) == freq)
845
646
                goto found;
846
647
    }
847
648
    return -1;
848
649
 found:
849
650
    s->sample_rate = freq;
850
 
    s->halfratecod = i;
851
 
    s->fscod = j;
852
 
    s->bsid = 8 + s->halfratecod;
853
 
    s->bsmod = 0; /* complete main audio service */
 
651
    s->sr_shift = i;
 
652
    s->sr_code = j;
 
653
    s->bitstream_id = 8 + s->sr_shift;
 
654
    s->bitstream_mode = 0; /* complete main audio service */
854
655
 
855
656
    /* bitrate & frame size */
856
 
    bitrate /= 1000;
857
657
    for(i=0;i<19;i++) {
858
 
        if ((ac3_bitratetab[i] >> s->halfratecod) == bitrate)
 
658
        if ((ff_ac3_bitrate_tab[i] >> s->sr_shift)*1000 == bitrate)
859
659
            break;
860
660
    }
861
661
    if (i == 19)
862
662
        return -1;
863
663
    s->bit_rate = bitrate;
864
 
    s->frmsizecod = i << 1;
865
 
    s->frame_size_min = (bitrate * 1000 * AC3_FRAME_SIZE) / (freq * 16);
 
664
    s->frame_size_code = i << 1;
 
665
    s->frame_size_min = ff_ac3_frame_size_tab[s->frame_size_code][s->sr_code];
866
666
    s->bits_written = 0;
867
667
    s->samples_written = 0;
868
668
    s->frame_size = s->frame_size_min;
869
669
 
870
670
    /* bit allocation init */
 
671
    if(avctx->cutoff) {
 
672
        /* calculate bandwidth based on user-specified cutoff frequency */
 
673
        int cutoff = av_clip(avctx->cutoff, 1, s->sample_rate >> 1);
 
674
        int fbw_coeffs = cutoff * 512 / s->sample_rate;
 
675
        bw_code = av_clip((fbw_coeffs - 73) / 3, 0, 60);
 
676
    } else {
 
677
        /* use default bandwidth setting */
 
678
        /* XXX: should compute the bandwidth according to the frame
 
679
           size, so that we avoid annoying high frequency artifacts */
 
680
        bw_code = 50;
 
681
    }
871
682
    for(ch=0;ch<s->nb_channels;ch++) {
872
683
        /* bandwidth for each channel */
873
 
        /* XXX: should compute the bandwidth according to the frame
874
 
           size, so that we avoid anoying high freq artefacts */
875
 
        s->chbwcod[ch] = 50; /* sample bandwidth as mpeg audio layer 2 table 0 */
876
 
        s->nb_coefs[ch] = ((s->chbwcod[ch] + 12) * 3) + 37;
 
684
        s->chbwcod[ch] = bw_code;
 
685
        s->nb_coefs[ch] = bw_code * 3 + 73;
877
686
    }
878
687
    if (s->lfe) {
879
688
        s->nb_coefs[s->lfe_channel] = 7; /* fixed */
880
689
    }
881
690
    /* initial snr offset */
882
 
    s->csnroffst = 40;
883
 
 
884
 
    ac3_common_init();
 
691
    s->coarse_snr_offset = 40;
885
692
 
886
693
    /* mdct init */
887
694
    fft_init(MDCT_NBITS - 2);
904
711
 
905
712
    put_bits(&s->pb, 16, 0x0b77); /* frame header */
906
713
    put_bits(&s->pb, 16, 0); /* crc1: will be filled later */
907
 
    put_bits(&s->pb, 2, s->fscod);
908
 
    put_bits(&s->pb, 6, s->frmsizecod + (s->frame_size - s->frame_size_min));
909
 
    put_bits(&s->pb, 5, s->bsid);
910
 
    put_bits(&s->pb, 3, s->bsmod);
911
 
    put_bits(&s->pb, 3, s->acmod);
912
 
    if ((s->acmod & 0x01) && s->acmod != 0x01)
 
714
    put_bits(&s->pb, 2, s->sr_code);
 
715
    put_bits(&s->pb, 6, s->frame_size_code + (s->frame_size - s->frame_size_min));
 
716
    put_bits(&s->pb, 5, s->bitstream_id);
 
717
    put_bits(&s->pb, 3, s->bitstream_mode);
 
718
    put_bits(&s->pb, 3, s->channel_mode);
 
719
    if ((s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO)
913
720
        put_bits(&s->pb, 2, 1); /* XXX -4.5 dB */
914
 
    if (s->acmod & 0x04)
 
721
    if (s->channel_mode & 0x04)
915
722
        put_bits(&s->pb, 2, 1); /* XXX -6 dB */
916
 
    if (s->acmod == 0x02)
 
723
    if (s->channel_mode == AC3_CHMODE_STEREO)
917
724
        put_bits(&s->pb, 2, 0); /* surround not indicated */
918
725
    put_bits(&s->pb, 1, s->lfe); /* LFE */
919
726
    put_bits(&s->pb, 5, 31); /* dialog norm: -31 db */
924
731
    put_bits(&s->pb, 1, 1); /* original bitstream */
925
732
    put_bits(&s->pb, 1, 0); /* no time code 1 */
926
733
    put_bits(&s->pb, 1, 0); /* no time code 2 */
927
 
    put_bits(&s->pb, 1, 0); /* no addtional bit stream info */
 
734
    put_bits(&s->pb, 1, 0); /* no additional bit stream info */
928
735
}
929
736
 
930
737
/* symetric quantization on 'levels' levels */
996
803
        put_bits(&s->pb, 1, 0); /* no new coupling strategy */
997
804
    }
998
805
 
999
 
    if (s->acmod == 2)
 
806
    if (s->channel_mode == AC3_CHMODE_STEREO)
1000
807
      {
1001
808
        if(block_num==0)
1002
809
          {
1086
893
    baie = (block_num == 0);
1087
894
    put_bits(&s->pb, 1, baie);
1088
895
    if (baie) {
1089
 
        put_bits(&s->pb, 2, s->sdecaycod);
1090
 
        put_bits(&s->pb, 2, s->fdecaycod);
1091
 
        put_bits(&s->pb, 2, s->sgaincod);
1092
 
        put_bits(&s->pb, 2, s->dbkneecod);
1093
 
        put_bits(&s->pb, 3, s->floorcod);
 
896
        put_bits(&s->pb, 2, s->slow_decay_code);
 
897
        put_bits(&s->pb, 2, s->fast_decay_code);
 
898
        put_bits(&s->pb, 2, s->slow_gain_code);
 
899
        put_bits(&s->pb, 2, s->db_per_bit_code);
 
900
        put_bits(&s->pb, 3, s->floor_code);
1094
901
    }
1095
902
 
1096
903
    /* snr offset */
1097
904
    put_bits(&s->pb, 1, baie); /* always present with bai */
1098
905
    if (baie) {
1099
 
        put_bits(&s->pb, 6, s->csnroffst);
 
906
        put_bits(&s->pb, 6, s->coarse_snr_offset);
1100
907
        for(ch=0;ch<s->nb_all_channels;ch++) {
1101
 
            put_bits(&s->pb, 4, s->fsnroffst[ch]);
1102
 
            put_bits(&s->pb, 3, s->fgaincod[ch]);
 
908
            put_bits(&s->pb, 4, s->fine_snr_offset[ch]);
 
909
            put_bits(&s->pb, 3, s->fast_gain_code[ch]);
1103
910
        }
1104
911
    }
1105
912
 
1318
1125
    /* Now we must compute both crcs : this is not so easy for crc1
1319
1126
       because it is at the beginning of the data... */
1320
1127
    frame_size_58 = (frame_size >> 1) + (frame_size >> 3);
1321
 
    crc1 = bswap_16(av_crc(av_crc8005, 0, frame + 4, 2 * frame_size_58 - 4));
 
1128
    crc1 = bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
 
1129
                           frame + 4, 2 * frame_size_58 - 4));
1322
1130
    /* XXX: could precompute crc_inv */
1323
1131
    crc_inv = pow_poly((CRC16_POLY >> 1), (16 * frame_size_58) - 16, CRC16_POLY);
1324
1132
    crc1 = mul_poly(crc_inv, crc1, CRC16_POLY);
1325
 
    frame[2] = crc1 >> 8;
1326
 
    frame[3] = crc1;
 
1133
    AV_WB16(frame+2,crc1);
1327
1134
 
1328
 
    crc2 = bswap_16(av_crc(av_crc8005, 0, frame + 2 * frame_size_58, (frame_size - frame_size_58) * 2 - 2));
1329
 
    frame[2*frame_size - 2] = crc2 >> 8;
1330
 
    frame[2*frame_size - 1] = crc2;
 
1135
    crc2 = bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
 
1136
                           frame + 2 * frame_size_58,
 
1137
                           (frame_size - frame_size_58) * 2 - 2));
 
1138
    AV_WB16(frame+2*frame_size-2,crc2);
1331
1139
 
1332
1140
    //    printf("n=%d frame_size=%d\n", n, frame_size);
1333
1141
    return frame_size * 2;
1369
1177
            /* apply the MDCT window */
1370
1178
            for(j=0;j<N/2;j++) {
1371
1179
                input_samples[j] = MUL16(input_samples[j],
1372
 
                                         ac3_window[j]) >> 15;
 
1180
                                         ff_ac3_window[j]) >> 15;
1373
1181
                input_samples[N-j-1] = MUL16(input_samples[N-j-1],
1374
 
                                             ac3_window[j]) >> 15;
 
1182
                                             ff_ac3_window[j]) >> 15;
1375
1183
            }
1376
1184
 
1377
1185
            /* Normalize the samples to use the maximum available
1379
1187
            v = 14 - log2_tab(input_samples, N);
1380
1188
            if (v < 0)
1381
1189
                v = 0;
1382
 
            exp_samples[i][ch] = v - 10;
 
1190
            exp_samples[i][ch] = v - 9;
1383
1191
            lshift_tab(input_samples, N, v);
1384
1192
 
1385
1193
            /* do the MDCT */
1428
1236
    }
1429
1237
 
1430
1238
    /* adjust for fractional frame sizes */
1431
 
    while(s->bits_written >= s->bit_rate*1000 && s->samples_written >= s->sample_rate) {
1432
 
        s->bits_written -= s->bit_rate*1000;
 
1239
    while(s->bits_written >= s->bit_rate && s->samples_written >= s->sample_rate) {
 
1240
        s->bits_written -= s->bit_rate;
1433
1241
        s->samples_written -= s->sample_rate;
1434
1242
    }
1435
 
    s->frame_size = s->frame_size_min + (s->bits_written * s->sample_rate < s->samples_written * s->bit_rate*1000);
 
1243
    s->frame_size = s->frame_size_min + (s->bits_written * s->sample_rate < s->samples_written * s->bit_rate);
1436
1244
    s->bits_written += s->frame_size * 16;
1437
1245
    s->samples_written += AC3_FRAME_SIZE;
1438
1246
 
1447
1255
    return output_frame_end(s);
1448
1256
}
1449
1257
 
1450
 
static int AC3_encode_close(AVCodecContext *avctx)
 
1258
static av_cold int AC3_encode_close(AVCodecContext *avctx)
1451
1259
{
1452
1260
    av_freep(&avctx->coded_frame);
1453
1261
    return 0;
1457
1265
/*************************************************************************/
1458
1266
/* TEST */
1459
1267
 
 
1268
#undef random
1460
1269
#define FN (N/4)
1461
1270
 
1462
1271
void fft_test(void)
1554
1363
    AC3_encode_frame,
1555
1364
    AC3_encode_close,
1556
1365
    NULL,
 
1366
    .long_name = "ATSC A/52 / AC-3",
1557
1367
};