2 * The simplest AC-3 encoder
3 * Copyright (c) 2000 Fabrice Bellard
5 * This file is part of FFmpeg.
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.
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.
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
23 * @file libavcodec/ac3enc.c
24 * The simplest AC-3 encoder.
27 //#define DEBUG_BITALLOC
28 #include "libavutil/crc.h"
30 #include "get_bits.h" // for ff_reverse
34 typedef struct AC3EncodeContext
{
39 const uint8_t *channel_map
;
41 unsigned int sample_rate
;
42 unsigned int bitstream_id
;
43 unsigned int frame_size_min
; /* minimum frame size in case rounding is necessary */
44 unsigned int frame_size
; /* current frame size in words */
45 unsigned int bits_written
;
46 unsigned int samples_written
;
48 unsigned int frame_size_code
;
49 unsigned int sr_code
; /* frequency */
50 unsigned int channel_mode
;
52 unsigned int bitstream_mode
;
53 short last_samples
[AC3_MAX_CHANNELS
][256];
54 unsigned int chbwcod
[AC3_MAX_CHANNELS
];
55 int nb_coefs
[AC3_MAX_CHANNELS
];
57 /* bitrate allocation control */
58 int slow_gain_code
, slow_decay_code
, fast_decay_code
, db_per_bit_code
, floor_code
;
59 AC3BitAllocParameters bit_alloc
;
60 int coarse_snr_offset
;
61 int fast_gain_code
[AC3_MAX_CHANNELS
];
62 int fine_snr_offset
[AC3_MAX_CHANNELS
];
63 /* mantissa encoding */
64 int mant1_cnt
, mant2_cnt
, mant4_cnt
;
67 static int16_t costab
[64];
68 static int16_t sintab
[64];
69 static int16_t xcos1
[128];
70 static int16_t xsin1
[128];
73 #define N (1 << MDCT_NBITS)
75 /* new exponents are sent if their Norm 1 exceed this number */
76 #define EXP_DIFF_THRESHOLD 1000
78 static inline int16_t fix15(float a
)
81 v
= (int)(a
* (float)(1 << 15));
89 typedef struct IComplex
{
93 static av_cold
void fft_init(int ln
)
100 for(i
=0;i
<(n
/2);i
++) {
101 alpha
= 2 * M_PI
* (float)i
/ (float)n
;
102 costab
[i
] = fix15(cos(alpha
));
103 sintab
[i
] = fix15(sin(alpha
));
108 #define BF(pre, pim, qre, qim, pre1, pim1, qre1, qim1) \
115 pre = (bx + ax) >> 1;\
116 pim = (by + ay) >> 1;\
117 qre = (bx - ax) >> 1;\
118 qim = (by - ay) >> 1;\
121 #define CMUL(pre, pim, are, aim, bre, bim) \
123 pre = (MUL16(are, bre) - MUL16(aim, bim)) >> 15;\
124 pim = (MUL16(are, bim) + MUL16(bre, aim)) >> 15;\
128 /* do a 2^n point complex fft on 2^ln points. */
129 static void fft(IComplex
*z
, int ln
)
133 register IComplex
*p
,*q
;
140 int k
= ff_reverse
[j
] >> (8 - ln
);
142 FFSWAP(IComplex
, z
[k
], z
[j
]);
150 BF(p
[0].re
, p
[0].im
, p
[1].re
, p
[1].im
,
151 p
[0].re
, p
[0].im
, p
[1].re
, p
[1].im
);
160 BF(p
[0].re
, p
[0].im
, p
[2].re
, p
[2].im
,
161 p
[0].re
, p
[0].im
, p
[2].re
, p
[2].im
);
162 BF(p
[1].re
, p
[1].im
, p
[3].re
, p
[3].im
,
163 p
[1].re
, p
[1].im
, p
[3].im
, -p
[3].re
);
175 for (j
= 0; j
< nblocks
; ++j
) {
177 BF(p
->re
, p
->im
, q
->re
, q
->im
,
178 p
->re
, p
->im
, q
->re
, q
->im
);
182 for(l
= nblocks
; l
< np2
; l
+= nblocks
) {
183 CMUL(tmp_re
, tmp_im
, costab
[l
], -sintab
[l
], q
->re
, q
->im
);
184 BF(p
->re
, p
->im
, q
->re
, q
->im
,
185 p
->re
, p
->im
, tmp_re
, tmp_im
);
192 nblocks
= nblocks
>> 1;
193 nloops
= nloops
<< 1;
194 } while (nblocks
!= 0);
197 /* do a 512 point mdct */
198 static void mdct512(int32_t *out
, int16_t *in
)
200 int i
, re
, im
, re1
, im1
;
204 /* shift to simplify computations */
206 rot
[i
] = -in
[i
+ 3*N
/4];
208 rot
[i
] = in
[i
- N
/4];
212 re
= ((int)rot
[2*i
] - (int)rot
[N
-1-2*i
]) >> 1;
213 im
= -((int)rot
[N
/2+2*i
] - (int)rot
[N
/2-1-2*i
]) >> 1;
214 CMUL(x
[i
].re
, x
[i
].im
, re
, im
, -xcos1
[i
], xsin1
[i
]);
217 fft(x
, MDCT_NBITS
- 2);
223 CMUL(re1
, im1
, re
, im
, xsin1
[i
], xcos1
[i
]);
225 out
[N
/2-1-2*i
] = re1
;
229 /* XXX: use another norm ? */
230 static int calc_exp_diff(uint8_t *exp1
, uint8_t *exp2
, int n
)
235 sum
+= abs(exp1
[i
] - exp2
[i
]);
240 static void compute_exp_strategy(uint8_t exp_strategy
[NB_BLOCKS
][AC3_MAX_CHANNELS
],
241 uint8_t exp
[NB_BLOCKS
][AC3_MAX_CHANNELS
][N
/2],
247 /* estimate if the exponent variation & decide if they should be
248 reused in the next frame */
249 exp_strategy
[0][ch
] = EXP_NEW
;
250 for(i
=1;i
<NB_BLOCKS
;i
++) {
251 exp_diff
= calc_exp_diff(exp
[i
][ch
], exp
[i
-1][ch
], N
/2);
253 av_log(NULL
, AV_LOG_DEBUG
, "exp_diff=%d\n", exp_diff
);
255 if (exp_diff
> EXP_DIFF_THRESHOLD
)
256 exp_strategy
[i
][ch
] = EXP_NEW
;
258 exp_strategy
[i
][ch
] = EXP_REUSE
;
263 /* now select the encoding strategy type : if exponents are often
264 recoded, we use a coarse encoding */
266 while (i
< NB_BLOCKS
) {
268 while (j
< NB_BLOCKS
&& exp_strategy
[j
][ch
] == EXP_REUSE
)
272 exp_strategy
[i
][ch
] = EXP_D45
;
276 exp_strategy
[i
][ch
] = EXP_D25
;
279 exp_strategy
[i
][ch
] = EXP_D15
;
286 /* set exp[i] to min(exp[i], exp1[i]) */
287 static void exponent_min(uint8_t exp
[N
/2], uint8_t exp1
[N
/2], int n
)
292 if (exp1
[i
] < exp
[i
])
297 /* update the exponents so that they are the ones the decoder will
298 decode. Return the number of bits used to code the exponents */
299 static int encode_exp(uint8_t encoded_exp
[N
/2],
304 int group_size
, nb_groups
, i
, j
, k
, exp_min
;
307 switch(exp_strategy
) {
319 nb_groups
= ((nb_exps
+ (group_size
* 3) - 4) / (3 * group_size
)) * 3;
321 /* for each group, compute the minimum exponent */
322 exp1
[0] = exp
[0]; /* DC exponent is handled separately */
324 for(i
=1;i
<=nb_groups
;i
++) {
326 assert(exp_min
>= 0 && exp_min
<= 24);
327 for(j
=1;j
<group_size
;j
++) {
328 if (exp
[k
+j
] < exp_min
)
335 /* constraint for DC exponent */
339 /* Decrease the delta between each groups to within 2
340 * so that they can be differentially encoded */
341 for (i
=1;i
<=nb_groups
;i
++)
342 exp1
[i
] = FFMIN(exp1
[i
], exp1
[i
-1] + 2);
343 for (i
=nb_groups
-1;i
>=0;i
--)
344 exp1
[i
] = FFMIN(exp1
[i
], exp1
[i
+1] + 2);
346 /* now we have the exponent values the decoder will see */
347 encoded_exp
[0] = exp1
[0];
349 for(i
=1;i
<=nb_groups
;i
++) {
350 for(j
=0;j
<group_size
;j
++) {
351 encoded_exp
[k
+j
] = exp1
[i
];
357 av_log(NULL
, AV_LOG_DEBUG
, "exponents: strategy=%d\n", exp_strategy
);
358 for(i
=0;i
<=nb_groups
* group_size
;i
++) {
359 av_log(NULL
, AV_LOG_DEBUG
, "%d ", encoded_exp
[i
]);
361 av_log(NULL
, AV_LOG_DEBUG
, "\n");
364 return 4 + (nb_groups
/ 3) * 7;
367 /* return the size in bits taken by the mantissa */
368 static int compute_mantissa_size(AC3EncodeContext
*s
, uint8_t *m
, int nb_coefs
)
373 for(i
=0;i
<nb_coefs
;i
++) {
380 /* 3 mantissa in 5 bits */
381 if (s
->mant1_cnt
== 0)
383 if (++s
->mant1_cnt
== 3)
387 /* 3 mantissa in 7 bits */
388 if (s
->mant2_cnt
== 0)
390 if (++s
->mant2_cnt
== 3)
397 /* 2 mantissa in 7 bits */
398 if (s
->mant4_cnt
== 0)
400 if (++s
->mant4_cnt
== 2)
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])
425 int16_t band_psd
[NB_BLOCKS
][AC3_MAX_CHANNELS
][50];
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));
433 ff_ac3_bit_alloc_calc_psd(encoded_exp
[blk
][ch
], 0,
435 psd
[blk
][ch
], band_psd
[blk
][ch
]);
436 ff_ac3_bit_alloc_calc_mask(&s
->bit_alloc
, band_psd
[blk
][ch
],
438 ff_ac3_fast_gain_tab
[s
->fast_gain_code
[ch
]],
439 ch
== s
->lfe_channel
,
440 DBA_NONE
, 0, NULL
, NULL
, NULL
,
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],
450 uint8_t bap
[NB_BLOCKS
][AC3_MAX_CHANNELS
][N
/2],
451 int frame_bits
, int coarse_snr_offset
, int fine_snr_offset
)
456 snr_offset
= (((coarse_snr_offset
- 15) << 4) + fine_snr_offset
) << 2;
459 for(i
=0;i
<NB_BLOCKS
;i
++) {
463 for(ch
=0;ch
<s
->nb_all_channels
;ch
++) {
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
, ff_ac3_bap_tab
,
468 frame_bits
+= compute_mantissa_size(s
, bap
[i
][ch
],
473 printf("csnr=%d fsnr=%d frame_bits=%d diff=%d\n",
474 coarse_snr_offset
, fine_snr_offset
, frame_bits
,
475 16 * s
->frame_size
- ((frame_bits
+ 7) & ~7));
477 return 16 * s
->frame_size
- frame_bits
;
482 static int compute_bit_allocation(AC3EncodeContext
*s
,
483 uint8_t bap
[NB_BLOCKS
][AC3_MAX_CHANNELS
][N
/2],
484 uint8_t encoded_exp
[NB_BLOCKS
][AC3_MAX_CHANNELS
][N
/2],
485 uint8_t exp_strategy
[NB_BLOCKS
][AC3_MAX_CHANNELS
],
489 int coarse_snr_offset
, fine_snr_offset
;
490 uint8_t bap1
[NB_BLOCKS
][AC3_MAX_CHANNELS
][N
/2];
491 int16_t psd
[NB_BLOCKS
][AC3_MAX_CHANNELS
][N
/2];
492 int16_t mask
[NB_BLOCKS
][AC3_MAX_CHANNELS
][50];
493 static const int frame_bits_inc
[8] = { 0, 0, 2, 2, 2, 4, 2, 4 };
495 /* init default parameters */
496 s
->slow_decay_code
= 2;
497 s
->fast_decay_code
= 1;
498 s
->slow_gain_code
= 1;
499 s
->db_per_bit_code
= 2;
501 for(ch
=0;ch
<s
->nb_all_channels
;ch
++)
502 s
->fast_gain_code
[ch
] = 4;
504 /* compute real values */
505 s
->bit_alloc
.sr_code
= s
->sr_code
;
506 s
->bit_alloc
.sr_shift
= s
->sr_shift
;
507 s
->bit_alloc
.slow_decay
= ff_ac3_slow_decay_tab
[s
->slow_decay_code
] >> s
->sr_shift
;
508 s
->bit_alloc
.fast_decay
= ff_ac3_fast_decay_tab
[s
->fast_decay_code
] >> s
->sr_shift
;
509 s
->bit_alloc
.slow_gain
= ff_ac3_slow_gain_tab
[s
->slow_gain_code
];
510 s
->bit_alloc
.db_per_bit
= ff_ac3_db_per_bit_tab
[s
->db_per_bit_code
];
511 s
->bit_alloc
.floor
= ff_ac3_floor_tab
[s
->floor_code
];
515 // if (s->channel_mode == 2)
517 frame_bits
+= frame_bits_inc
[s
->channel_mode
];
520 for(i
=0;i
<NB_BLOCKS
;i
++) {
521 frame_bits
+= s
->nb_channels
* 2 + 2; /* blksw * c, dithflag * c, dynrnge, cplstre */
522 if (s
->channel_mode
== AC3_CHMODE_STEREO
) {
523 frame_bits
++; /* rematstr */
524 if(i
==0) frame_bits
+= 4;
526 frame_bits
+= 2 * s
->nb_channels
; /* chexpstr[2] * c */
528 frame_bits
++; /* lfeexpstr */
529 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
530 if (exp_strategy
[i
][ch
] != EXP_REUSE
)
531 frame_bits
+= 6 + 2; /* chbwcod[6], gainrng[2] */
533 frame_bits
++; /* baie */
534 frame_bits
++; /* snr */
535 frame_bits
+= 2; /* delta / skip */
537 frame_bits
++; /* cplinu for block 0 */
539 /* sdcycod[2], fdcycod[2], sgaincod[2], dbpbcod[2], floorcod[3] */
541 /* (fsnoffset[4] + fgaincod[4]) * c */
542 frame_bits
+= 2*4 + 3 + 6 + s
->nb_all_channels
* (4 + 3);
544 /* auxdatae, crcrsv */
550 /* calculate psd and masking curve before doing bit allocation */
551 bit_alloc_masking(s
, encoded_exp
, exp_strategy
, psd
, mask
);
553 /* now the big work begins : do the bit allocation. Modify the snr
554 offset until we can pack everything in the requested frame size */
556 coarse_snr_offset
= s
->coarse_snr_offset
;
557 while (coarse_snr_offset
>= 0 &&
558 bit_alloc(s
, mask
, psd
, bap
, frame_bits
, coarse_snr_offset
, 0) < 0)
559 coarse_snr_offset
-= SNR_INC1
;
560 if (coarse_snr_offset
< 0) {
561 av_log(NULL
, AV_LOG_ERROR
, "Bit allocation failed. Try increasing the bitrate.\n");
564 while ((coarse_snr_offset
+ SNR_INC1
) <= 63 &&
565 bit_alloc(s
, mask
, psd
, bap1
, frame_bits
,
566 coarse_snr_offset
+ SNR_INC1
, 0) >= 0) {
567 coarse_snr_offset
+= SNR_INC1
;
568 memcpy(bap
, bap1
, sizeof(bap1
));
570 while ((coarse_snr_offset
+ 1) <= 63 &&
571 bit_alloc(s
, mask
, psd
, bap1
, frame_bits
, coarse_snr_offset
+ 1, 0) >= 0) {
573 memcpy(bap
, bap1
, sizeof(bap1
));
577 while ((fine_snr_offset
+ SNR_INC1
) <= 15 &&
578 bit_alloc(s
, mask
, psd
, bap1
, frame_bits
,
579 coarse_snr_offset
, fine_snr_offset
+ SNR_INC1
) >= 0) {
580 fine_snr_offset
+= SNR_INC1
;
581 memcpy(bap
, bap1
, sizeof(bap1
));
583 while ((fine_snr_offset
+ 1) <= 15 &&
584 bit_alloc(s
, mask
, psd
, bap1
, frame_bits
,
585 coarse_snr_offset
, fine_snr_offset
+ 1) >= 0) {
587 memcpy(bap
, bap1
, sizeof(bap1
));
590 s
->coarse_snr_offset
= coarse_snr_offset
;
591 for(ch
=0;ch
<s
->nb_all_channels
;ch
++)
592 s
->fine_snr_offset
[ch
] = fine_snr_offset
;
593 #if defined(DEBUG_BITALLOC)
598 for(ch
=0;ch
<s
->nb_all_channels
;ch
++) {
599 printf("Block #%d Ch%d:\n", i
, ch
);
601 for(j
=0;j
<s
->nb_coefs
[ch
];j
++) {
602 printf("%d ",bap
[i
][ch
][j
]);
612 static av_cold
int AC3_encode_init(AVCodecContext
*avctx
)
614 int freq
= avctx
->sample_rate
;
615 int bitrate
= avctx
->bit_rate
;
616 int channels
= avctx
->channels
;
617 AC3EncodeContext
*s
= avctx
->priv_data
;
621 static const uint8_t channel_mode_defs
[6] = {
625 0x06, /* L R SL SR */
626 0x07, /* L C R SL SR */
627 0x07, /* L C R SL SR (+LFE) */
630 avctx
->frame_size
= AC3_FRAME_SIZE
;
634 /* number of channels */
635 if (channels
< 1 || channels
> 6)
637 s
->channel_mode
= channel_mode_defs
[channels
- 1];
638 s
->lfe
= (channels
== 6) ? 1 : 0;
639 s
->nb_all_channels
= channels
;
640 s
->nb_channels
= channels
> 5 ? 5 : channels
;
641 s
->lfe_channel
= s
->lfe
? 5 : -1;
642 s
->channel_map
= ff_ac3_enc_channel_map
[s
->channel_mode
][s
->lfe
];
647 if ((ff_ac3_sample_rate_tab
[j
] >> i
) == freq
)
652 s
->sample_rate
= freq
;
655 s
->bitstream_id
= 8 + s
->sr_shift
;
656 s
->bitstream_mode
= 0; /* complete main audio service */
658 /* bitrate & frame size */
660 if ((ff_ac3_bitrate_tab
[i
] >> s
->sr_shift
)*1000 == bitrate
)
665 s
->bit_rate
= bitrate
;
666 s
->frame_size_code
= i
<< 1;
667 s
->frame_size_min
= ff_ac3_frame_size_tab
[s
->frame_size_code
][s
->sr_code
];
669 s
->samples_written
= 0;
670 s
->frame_size
= s
->frame_size_min
;
672 /* bit allocation init */
674 /* calculate bandwidth based on user-specified cutoff frequency */
675 int cutoff
= av_clip(avctx
->cutoff
, 1, s
->sample_rate
>> 1);
676 int fbw_coeffs
= cutoff
* 512 / s
->sample_rate
;
677 bw_code
= av_clip((fbw_coeffs
- 73) / 3, 0, 60);
679 /* use default bandwidth setting */
680 /* XXX: should compute the bandwidth according to the frame
681 size, so that we avoid annoying high frequency artifacts */
684 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
685 /* bandwidth for each channel */
686 s
->chbwcod
[ch
] = bw_code
;
687 s
->nb_coefs
[ch
] = bw_code
* 3 + 73;
690 s
->nb_coefs
[s
->lfe_channel
] = 7; /* fixed */
692 /* initial snr offset */
693 s
->coarse_snr_offset
= 40;
696 fft_init(MDCT_NBITS
- 2);
698 alpha
= 2 * M_PI
* (i
+ 1.0 / 8.0) / (float)N
;
699 xcos1
[i
] = fix15(-cos(alpha
));
700 xsin1
[i
] = fix15(-sin(alpha
));
703 avctx
->coded_frame
= avcodec_alloc_frame();
704 avctx
->coded_frame
->key_frame
= 1;
709 /* output the AC-3 frame header */
710 static void output_frame_header(AC3EncodeContext
*s
, unsigned char *frame
)
712 init_put_bits(&s
->pb
, frame
, AC3_MAX_CODED_FRAME_SIZE
);
714 put_bits(&s
->pb
, 16, 0x0b77); /* frame header */
715 put_bits(&s
->pb
, 16, 0); /* crc1: will be filled later */
716 put_bits(&s
->pb
, 2, s
->sr_code
);
717 put_bits(&s
->pb
, 6, s
->frame_size_code
+ (s
->frame_size
- s
->frame_size_min
));
718 put_bits(&s
->pb
, 5, s
->bitstream_id
);
719 put_bits(&s
->pb
, 3, s
->bitstream_mode
);
720 put_bits(&s
->pb
, 3, s
->channel_mode
);
721 if ((s
->channel_mode
& 0x01) && s
->channel_mode
!= AC3_CHMODE_MONO
)
722 put_bits(&s
->pb
, 2, 1); /* XXX -4.5 dB */
723 if (s
->channel_mode
& 0x04)
724 put_bits(&s
->pb
, 2, 1); /* XXX -6 dB */
725 if (s
->channel_mode
== AC3_CHMODE_STEREO
)
726 put_bits(&s
->pb
, 2, 0); /* surround not indicated */
727 put_bits(&s
->pb
, 1, s
->lfe
); /* LFE */
728 put_bits(&s
->pb
, 5, 31); /* dialog norm: -31 db */
729 put_bits(&s
->pb
, 1, 0); /* no compression control word */
730 put_bits(&s
->pb
, 1, 0); /* no lang code */
731 put_bits(&s
->pb
, 1, 0); /* no audio production info */
732 put_bits(&s
->pb
, 1, 0); /* no copyright */
733 put_bits(&s
->pb
, 1, 1); /* original bitstream */
734 put_bits(&s
->pb
, 1, 0); /* no time code 1 */
735 put_bits(&s
->pb
, 1, 0); /* no time code 2 */
736 put_bits(&s
->pb
, 1, 0); /* no additional bit stream info */
739 /* symetric quantization on 'levels' levels */
740 static inline int sym_quant(int c
, int e
, int levels
)
745 v
= (levels
* (c
<< e
)) >> 24;
747 v
= (levels
>> 1) + v
;
749 v
= (levels
* ((-c
) << e
)) >> 24;
751 v
= (levels
>> 1) - v
;
753 assert (v
>= 0 && v
< levels
);
757 /* asymetric quantization on 2^qbits levels */
758 static inline int asym_quant(int c
, int e
, int qbits
)
762 lshift
= e
+ qbits
- 24;
769 m
= (1 << (qbits
-1));
773 return v
& ((1 << qbits
)-1);
776 /* Output one audio block. There are NB_BLOCKS audio blocks in one AC-3
778 static void output_audio_block(AC3EncodeContext
*s
,
779 uint8_t exp_strategy
[AC3_MAX_CHANNELS
],
780 uint8_t encoded_exp
[AC3_MAX_CHANNELS
][N
/2],
781 uint8_t bap
[AC3_MAX_CHANNELS
][N
/2],
782 int32_t mdct_coefs
[AC3_MAX_CHANNELS
][N
/2],
783 int8_t global_exp
[AC3_MAX_CHANNELS
],
786 int ch
, nb_groups
, group_size
, i
, baie
, rbnd
;
788 uint16_t qmant
[AC3_MAX_CHANNELS
][N
/2];
790 int mant1_cnt
, mant2_cnt
, mant4_cnt
;
791 uint16_t *qmant1_ptr
, *qmant2_ptr
, *qmant4_ptr
;
792 int delta0
, delta1
, delta2
;
794 for(ch
=0;ch
<s
->nb_channels
;ch
++)
795 put_bits(&s
->pb
, 1, 0); /* 512 point MDCT */
796 for(ch
=0;ch
<s
->nb_channels
;ch
++)
797 put_bits(&s
->pb
, 1, 1); /* no dither */
798 put_bits(&s
->pb
, 1, 0); /* no dynamic range */
799 if (block_num
== 0) {
800 /* for block 0, even if no coupling, we must say it. This is a
802 put_bits(&s
->pb
, 1, 1); /* coupling strategy present */
803 put_bits(&s
->pb
, 1, 0); /* no coupling strategy */
805 put_bits(&s
->pb
, 1, 0); /* no new coupling strategy */
808 if (s
->channel_mode
== AC3_CHMODE_STEREO
)
812 /* first block must define rematrixing (rematstr) */
813 put_bits(&s
->pb
, 1, 1);
815 /* dummy rematrixing rematflg(1:4)=0 */
816 for (rbnd
=0;rbnd
<4;rbnd
++)
817 put_bits(&s
->pb
, 1, 0);
821 /* no matrixing (but should be used in the future) */
822 put_bits(&s
->pb
, 1, 0);
828 static int count
= 0;
829 av_log(NULL
, AV_LOG_DEBUG
, "Block #%d (%d)\n", block_num
, count
++);
832 /* exponent strategy */
833 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
834 put_bits(&s
->pb
, 2, exp_strategy
[ch
]);
838 put_bits(&s
->pb
, 1, exp_strategy
[s
->lfe_channel
]);
841 for(ch
=0;ch
<s
->nb_channels
;ch
++) {
842 if (exp_strategy
[ch
] != EXP_REUSE
)
843 put_bits(&s
->pb
, 6, s
->chbwcod
[ch
]);
847 for (ch
= 0; ch
< s
->nb_all_channels
; ch
++) {
848 switch(exp_strategy
[ch
]) {
862 nb_groups
= (s
->nb_coefs
[ch
] + (group_size
* 3) - 4) / (3 * group_size
);
867 put_bits(&s
->pb
, 4, exp1
);
869 /* next ones are delta encoded */
870 for(i
=0;i
<nb_groups
;i
++) {
871 /* merge three delta in one code */
875 delta0
= exp1
- exp0
+ 2;
880 delta1
= exp1
- exp0
+ 2;
885 delta2
= exp1
- exp0
+ 2;
887 put_bits(&s
->pb
, 7, ((delta0
* 5 + delta1
) * 5) + delta2
);
890 if (ch
!= s
->lfe_channel
)
891 put_bits(&s
->pb
, 2, 0); /* no gain range info */
894 /* bit allocation info */
895 baie
= (block_num
== 0);
896 put_bits(&s
->pb
, 1, baie
);
898 put_bits(&s
->pb
, 2, s
->slow_decay_code
);
899 put_bits(&s
->pb
, 2, s
->fast_decay_code
);
900 put_bits(&s
->pb
, 2, s
->slow_gain_code
);
901 put_bits(&s
->pb
, 2, s
->db_per_bit_code
);
902 put_bits(&s
->pb
, 3, s
->floor_code
);
906 put_bits(&s
->pb
, 1, baie
); /* always present with bai */
908 put_bits(&s
->pb
, 6, s
->coarse_snr_offset
);
909 for(ch
=0;ch
<s
->nb_all_channels
;ch
++) {
910 put_bits(&s
->pb
, 4, s
->fine_snr_offset
[ch
]);
911 put_bits(&s
->pb
, 3, s
->fast_gain_code
[ch
]);
915 put_bits(&s
->pb
, 1, 0); /* no delta bit allocation */
916 put_bits(&s
->pb
, 1, 0); /* no data to skip */
918 /* mantissa encoding : we use two passes to handle the grouping. A
919 one pass method may be faster, but it would necessitate to
920 modify the output stream. */
922 /* first pass: quantize */
923 mant1_cnt
= mant2_cnt
= mant4_cnt
= 0;
924 qmant1_ptr
= qmant2_ptr
= qmant4_ptr
= NULL
;
926 for (ch
= 0; ch
< s
->nb_all_channels
; ch
++) {
929 for(i
=0;i
<s
->nb_coefs
[ch
];i
++) {
930 c
= mdct_coefs
[ch
][i
];
931 e
= encoded_exp
[ch
][i
] - global_exp
[ch
];
938 v
= sym_quant(c
, e
, 3);
941 qmant1_ptr
= &qmant
[ch
][i
];
946 *qmant1_ptr
+= 3 * v
;
958 v
= sym_quant(c
, e
, 5);
961 qmant2_ptr
= &qmant
[ch
][i
];
966 *qmant2_ptr
+= 5 * v
;
978 v
= sym_quant(c
, e
, 7);
981 v
= sym_quant(c
, e
, 11);
984 qmant4_ptr
= &qmant
[ch
][i
];
996 v
= sym_quant(c
, e
, 15);
999 v
= asym_quant(c
, e
, 14);
1002 v
= asym_quant(c
, e
, 16);
1005 v
= asym_quant(c
, e
, b
- 1);
1012 /* second pass : output the values */
1013 for (ch
= 0; ch
< s
->nb_all_channels
; ch
++) {
1016 for(i
=0;i
<s
->nb_coefs
[ch
];i
++) {
1024 put_bits(&s
->pb
, 5, q
);
1028 put_bits(&s
->pb
, 7, q
);
1031 put_bits(&s
->pb
, 3, q
);
1035 put_bits(&s
->pb
, 7, q
);
1038 put_bits(&s
->pb
, 14, q
);
1041 put_bits(&s
->pb
, 16, q
);
1044 put_bits(&s
->pb
, b
- 1, q
);
1051 #define CRC16_POLY ((1 << 0) | (1 << 2) | (1 << 15) | (1 << 16))
1053 static unsigned int mul_poly(unsigned int a
, unsigned int b
, unsigned int poly
)
1069 static unsigned int pow_poly(unsigned int a
, unsigned int n
, unsigned int poly
)
1075 r
= mul_poly(r
, a
, poly
);
1076 a
= mul_poly(a
, a
, poly
);
1083 /* compute log2(max(abs(tab[]))) */
1084 static int log2_tab(int16_t *tab
, int n
)
1095 static void lshift_tab(int16_t *tab
, int n
, int lshift
)
1103 } else if (lshift
< 0) {
1111 /* fill the end of the frame and compute the two crcs */
1112 static int output_frame_end(AC3EncodeContext
*s
)
1114 int frame_size
, frame_size_58
, n
, crc1
, crc2
, crc_inv
;
1117 frame_size
= s
->frame_size
; /* frame size in words */
1118 /* align to 8 bits */
1119 flush_put_bits(&s
->pb
);
1120 /* add zero bytes to reach the frame size */
1122 n
= 2 * s
->frame_size
- (put_bits_ptr(&s
->pb
) - frame
) - 2;
1125 memset(put_bits_ptr(&s
->pb
), 0, n
);
1127 /* Now we must compute both crcs : this is not so easy for crc1
1128 because it is at the beginning of the data... */
1129 frame_size_58
= (frame_size
>> 1) + (frame_size
>> 3);
1130 crc1
= bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI
), 0,
1131 frame
+ 4, 2 * frame_size_58
- 4));
1132 /* XXX: could precompute crc_inv */
1133 crc_inv
= pow_poly((CRC16_POLY
>> 1), (16 * frame_size_58
) - 16, CRC16_POLY
);
1134 crc1
= mul_poly(crc_inv
, crc1
, CRC16_POLY
);
1135 AV_WB16(frame
+2,crc1
);
1137 crc2
= bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI
), 0,
1138 frame
+ 2 * frame_size_58
,
1139 (frame_size
- frame_size_58
) * 2 - 2));
1140 AV_WB16(frame
+2*frame_size
-2,crc2
);
1142 // printf("n=%d frame_size=%d\n", n, frame_size);
1143 return frame_size
* 2;
1146 static int AC3_encode_frame(AVCodecContext
*avctx
,
1147 unsigned char *frame
, int buf_size
, void *data
)
1149 AC3EncodeContext
*s
= avctx
->priv_data
;
1150 int16_t *samples
= data
;
1152 int16_t input_samples
[N
];
1153 int32_t mdct_coef
[NB_BLOCKS
][AC3_MAX_CHANNELS
][N
/2];
1154 uint8_t exp
[NB_BLOCKS
][AC3_MAX_CHANNELS
][N
/2];
1155 uint8_t exp_strategy
[NB_BLOCKS
][AC3_MAX_CHANNELS
];
1156 uint8_t encoded_exp
[NB_BLOCKS
][AC3_MAX_CHANNELS
][N
/2];
1157 uint8_t bap
[NB_BLOCKS
][AC3_MAX_CHANNELS
][N
/2];
1158 int8_t exp_samples
[NB_BLOCKS
][AC3_MAX_CHANNELS
];
1162 for(ch
=0;ch
<s
->nb_all_channels
;ch
++) {
1163 int ich
= s
->channel_map
[ch
];
1164 /* fixed mdct to the six sub blocks & exponent computation */
1165 for(i
=0;i
<NB_BLOCKS
;i
++) {
1169 /* compute input samples */
1170 memcpy(input_samples
, s
->last_samples
[ich
], N
/2 * sizeof(int16_t));
1171 sinc
= s
->nb_all_channels
;
1172 sptr
= samples
+ (sinc
* (N
/2) * i
) + ich
;
1173 for(j
=0;j
<N
/2;j
++) {
1175 input_samples
[j
+ N
/2] = v
;
1176 s
->last_samples
[ich
][j
] = v
;
1180 /* apply the MDCT window */
1181 for(j
=0;j
<N
/2;j
++) {
1182 input_samples
[j
] = MUL16(input_samples
[j
],
1183 ff_ac3_window
[j
]) >> 15;
1184 input_samples
[N
-j
-1] = MUL16(input_samples
[N
-j
-1],
1185 ff_ac3_window
[j
]) >> 15;
1188 /* Normalize the samples to use the maximum available
1190 v
= 14 - log2_tab(input_samples
, N
);
1193 exp_samples
[i
][ch
] = v
- 9;
1194 lshift_tab(input_samples
, N
, v
);
1197 mdct512(mdct_coef
[i
][ch
], input_samples
);
1199 /* compute "exponents". We take into account the
1200 normalization there */
1201 for(j
=0;j
<N
/2;j
++) {
1203 v
= abs(mdct_coef
[i
][ch
][j
]);
1207 e
= 23 - av_log2(v
) + exp_samples
[i
][ch
];
1210 mdct_coef
[i
][ch
][j
] = 0;
1217 compute_exp_strategy(exp_strategy
, exp
, ch
, ch
== s
->lfe_channel
);
1219 /* compute the exponents as the decoder will see them. The
1220 EXP_REUSE case must be handled carefully : we select the
1221 min of the exponents */
1223 while (i
< NB_BLOCKS
) {
1225 while (j
< NB_BLOCKS
&& exp_strategy
[j
][ch
] == EXP_REUSE
) {
1226 exponent_min(exp
[i
][ch
], exp
[j
][ch
], s
->nb_coefs
[ch
]);
1229 frame_bits
+= encode_exp(encoded_exp
[i
][ch
],
1230 exp
[i
][ch
], s
->nb_coefs
[ch
],
1231 exp_strategy
[i
][ch
]);
1232 /* copy encoded exponents for reuse case */
1233 for(k
=i
+1;k
<j
;k
++) {
1234 memcpy(encoded_exp
[k
][ch
], encoded_exp
[i
][ch
],
1235 s
->nb_coefs
[ch
] * sizeof(uint8_t));
1241 /* adjust for fractional frame sizes */
1242 while(s
->bits_written
>= s
->bit_rate
&& s
->samples_written
>= s
->sample_rate
) {
1243 s
->bits_written
-= s
->bit_rate
;
1244 s
->samples_written
-= s
->sample_rate
;
1246 s
->frame_size
= s
->frame_size_min
+ (s
->bits_written
* s
->sample_rate
< s
->samples_written
* s
->bit_rate
);
1247 s
->bits_written
+= s
->frame_size
* 16;
1248 s
->samples_written
+= AC3_FRAME_SIZE
;
1250 compute_bit_allocation(s
, bap
, encoded_exp
, exp_strategy
, frame_bits
);
1251 /* everything is known... let's output the frame */
1252 output_frame_header(s
, frame
);
1254 for(i
=0;i
<NB_BLOCKS
;i
++) {
1255 output_audio_block(s
, exp_strategy
[i
], encoded_exp
[i
],
1256 bap
[i
], mdct_coef
[i
], exp_samples
[i
], i
);
1258 return output_frame_end(s
);
1261 static av_cold
int AC3_encode_close(AVCodecContext
*avctx
)
1263 av_freep(&avctx
->coded_frame
);
1268 /*************************************************************************/
1276 IComplex in
[FN
], in1
[FN
];
1278 float sum_re
, sum_im
, a
;
1283 in
[i
].re
= random() % 65535 - 32767;
1284 in
[i
].im
= random() % 65535 - 32767;
1294 a
= -2 * M_PI
* (n
* k
) / FN
;
1295 sum_re
+= in1
[n
].re
* cos(a
) - in1
[n
].im
* sin(a
);
1296 sum_im
+= in1
[n
].re
* sin(a
) + in1
[n
].im
* cos(a
);
1298 printf("%3d: %6d,%6d %6.0f,%6.0f\n",
1299 k
, in
[k
].re
, in
[k
].im
, sum_re
/ FN
, sum_im
/ FN
);
1303 void mdct_test(void)
1306 int32_t output
[N
/2];
1309 float s
, a
, err
, e
, emax
;
1313 input
[i
] = (random() % 65535 - 32767) * 9 / 10;
1314 input1
[i
] = input
[i
];
1317 mdct512(output
, input
);
1320 for(k
=0;k
<N
/2;k
++) {
1323 a
= (2*M_PI
*(2*n
+1+N
/2)*(2*k
+1) / (4 * N
));
1324 s
+= input1
[n
] * cos(a
);
1326 output1
[k
] = -2 * s
/ N
;
1331 for(i
=0;i
<N
/2;i
++) {
1332 printf("%3d: %7d %7.0f\n", i
, output
[i
], output1
[i
]);
1333 e
= output
[i
] - output1
[i
];
1338 printf("err2=%f emax=%f\n", err
/ (N
/2), emax
);
1343 AC3EncodeContext ctx
;
1344 unsigned char frame
[AC3_MAX_CODED_FRAME_SIZE
];
1345 short samples
[AC3_FRAME_SIZE
];
1348 AC3_encode_init(&ctx
, 44100, 64000, 1);
1353 for(i
=0;i
<AC3_FRAME_SIZE
;i
++)
1354 samples
[i
] = (int)(sin(2*M_PI
*i
*1000.0/44100) * 10000);
1355 ret
= AC3_encode_frame(&ctx
, frame
, samples
);
1356 printf("ret=%d\n", ret
);
1360 AVCodec ac3_encoder
= {
1364 sizeof(AC3EncodeContext
),
1369 .sample_fmts
= (enum SampleFormat
[]){SAMPLE_FMT_S16
,SAMPLE_FMT_NONE
},
1370 .long_name
= NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),