/libavcodec/ac3enc.c
C | 2495 lines | 1792 code | 307 blank | 396 comment | 517 complexity | 691dd5f7fb64670d0ef49c8127af5a86 MD5 | raw file
Large files files are truncated, but you can click here to view the full file
1/* 2 * The simplest AC-3 encoder 3 * Copyright (c) 2000 Fabrice Bellard 4 * Copyright (c) 2006-2010 Justin Ruggles <justin.ruggles@gmail.com> 5 * Copyright (c) 2006-2010 Prakash Punnoor <prakash@punnoor.de> 6 * 7 * This file is part of FFmpeg. 8 * 9 * FFmpeg is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU Lesser General Public 11 * License as published by the Free Software Foundation; either 12 * version 2.1 of the License, or (at your option) any later version. 13 * 14 * FFmpeg is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * Lesser General Public License for more details. 18 * 19 * You should have received a copy of the GNU Lesser General Public 20 * License along with FFmpeg; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 22 */ 23 24/** 25 * @file 26 * The simplest AC-3 encoder. 27 */ 28 29#include <stdint.h> 30 31#include "libavutil/attributes.h" 32#include "libavutil/avassert.h" 33#include "libavutil/avstring.h" 34#include "libavutil/channel_layout.h" 35#include "libavutil/crc.h" 36#include "libavutil/internal.h" 37#include "libavutil/opt.h" 38#include "avcodec.h" 39#include "internal.h" 40#include "me_cmp.h" 41#include "put_bits.h" 42#include "audiodsp.h" 43#include "ac3dsp.h" 44#include "ac3.h" 45#include "fft.h" 46#include "ac3enc.h" 47#include "eac3enc.h" 48 49typedef struct AC3Mant { 50 int16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr; ///< mantissa pointers for bap=1,2,4 51 int mant1_cnt, mant2_cnt, mant4_cnt; ///< mantissa counts for bap=1,2,4 52} AC3Mant; 53 54#define CMIXLEV_NUM_OPTIONS 3 55static const float cmixlev_options[CMIXLEV_NUM_OPTIONS] = { 56 LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB, LEVEL_MINUS_6DB 57}; 58 59#define SURMIXLEV_NUM_OPTIONS 3 60static const float surmixlev_options[SURMIXLEV_NUM_OPTIONS] = { 61 LEVEL_MINUS_3DB, LEVEL_MINUS_6DB, LEVEL_ZERO 62}; 63 64#define EXTMIXLEV_NUM_OPTIONS 8 65static const float extmixlev_options[EXTMIXLEV_NUM_OPTIONS] = { 66 LEVEL_PLUS_3DB, LEVEL_PLUS_1POINT5DB, LEVEL_ONE, LEVEL_MINUS_1POINT5DB, 67 LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB, LEVEL_MINUS_6DB, LEVEL_ZERO 68}; 69 70 71/** 72 * LUT for number of exponent groups. 73 * exponent_group_tab[coupling][exponent strategy-1][number of coefficients] 74 */ 75static uint8_t exponent_group_tab[2][3][256]; 76 77 78/** 79 * List of supported channel layouts. 80 */ 81const uint64_t ff_ac3_channel_layouts[19] = { 82 AV_CH_LAYOUT_MONO, 83 AV_CH_LAYOUT_STEREO, 84 AV_CH_LAYOUT_2_1, 85 AV_CH_LAYOUT_SURROUND, 86 AV_CH_LAYOUT_2_2, 87 AV_CH_LAYOUT_QUAD, 88 AV_CH_LAYOUT_4POINT0, 89 AV_CH_LAYOUT_5POINT0, 90 AV_CH_LAYOUT_5POINT0_BACK, 91 (AV_CH_LAYOUT_MONO | AV_CH_LOW_FREQUENCY), 92 (AV_CH_LAYOUT_STEREO | AV_CH_LOW_FREQUENCY), 93 (AV_CH_LAYOUT_2_1 | AV_CH_LOW_FREQUENCY), 94 (AV_CH_LAYOUT_SURROUND | AV_CH_LOW_FREQUENCY), 95 (AV_CH_LAYOUT_2_2 | AV_CH_LOW_FREQUENCY), 96 (AV_CH_LAYOUT_QUAD | AV_CH_LOW_FREQUENCY), 97 (AV_CH_LAYOUT_4POINT0 | AV_CH_LOW_FREQUENCY), 98 AV_CH_LAYOUT_5POINT1, 99 AV_CH_LAYOUT_5POINT1_BACK, 100 0 101}; 102 103 104/** 105 * LUT to select the bandwidth code based on the bit rate, sample rate, and 106 * number of full-bandwidth channels. 107 * bandwidth_tab[fbw_channels-1][sample rate code][bit rate code] 108 */ 109static const uint8_t ac3_bandwidth_tab[5][3][19] = { 110// 32 40 48 56 64 80 96 112 128 160 192 224 256 320 384 448 512 576 640 111 112 { { 0, 0, 0, 12, 16, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48 }, 113 { 0, 0, 0, 16, 20, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56 }, 114 { 0, 0, 0, 32, 40, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } }, 115 116 { { 0, 0, 0, 0, 0, 0, 0, 20, 24, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48 }, 117 { 0, 0, 0, 0, 0, 0, 4, 24, 28, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56 }, 118 { 0, 0, 0, 0, 0, 0, 20, 44, 52, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } }, 119 120 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 24, 32, 40, 48, 48, 48, 48, 48, 48 }, 121 { 0, 0, 0, 0, 0, 0, 0, 0, 4, 20, 28, 36, 44, 56, 56, 56, 56, 56, 56 }, 122 { 0, 0, 0, 0, 0, 0, 0, 0, 20, 40, 48, 60, 60, 60, 60, 60, 60, 60, 60 } }, 123 124 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 24, 32, 48, 48, 48, 48, 48, 48 }, 125 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 28, 36, 56, 56, 56, 56, 56, 56 }, 126 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 48, 60, 60, 60, 60, 60, 60, 60 } }, 127 128 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 20, 32, 40, 48, 48, 48, 48 }, 129 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 24, 36, 44, 56, 56, 56, 56 }, 130 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 44, 60, 60, 60, 60, 60, 60 } } 131}; 132 133 134/** 135 * LUT to select the coupling start band based on the bit rate, sample rate, and 136 * number of full-bandwidth channels. -1 = coupling off 137 * ac3_coupling_start_tab[channel_mode-2][sample rate code][bit rate code] 138 * 139 * TODO: more testing for optimal parameters. 140 * multi-channel tests at 44.1kHz and 32kHz. 141 */ 142static const int8_t ac3_coupling_start_tab[6][3][19] = { 143// 32 40 48 56 64 80 96 112 128 160 192 224 256 320 384 448 512 576 640 144 145 // 2/0 146 { { 0, 0, 0, 0, 0, 0, 0, 1, 1, 7, 8, 11, 12, -1, -1, -1, -1, -1, -1 }, 147 { 0, 0, 0, 0, 0, 0, 1, 3, 5, 7, 10, 12, 13, -1, -1, -1, -1, -1, -1 }, 148 { 0, 0, 0, 0, 1, 2, 2, 9, 13, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1 } }, 149 150 // 3/0 151 { { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 }, 152 { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 }, 153 { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } }, 154 155 // 2/1 - untested 156 { { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 }, 157 { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 }, 158 { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } }, 159 160 // 3/1 161 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 }, 162 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 }, 163 { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } }, 164 165 // 2/2 - untested 166 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 }, 167 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 }, 168 { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } }, 169 170 // 3/2 171 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 8, 11, 12, 12, -1, -1 }, 172 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 8, 11, 12, 12, -1, -1 }, 173 { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } }, 174}; 175 176 177/** 178 * Adjust the frame size to make the average bit rate match the target bit rate. 179 * This is only needed for 11025, 22050, and 44100 sample rates or any E-AC-3. 180 * 181 * @param s AC-3 encoder private context 182 */ 183void ff_ac3_adjust_frame_size(AC3EncodeContext *s) 184{ 185 while (s->bits_written >= s->bit_rate && s->samples_written >= s->sample_rate) { 186 s->bits_written -= s->bit_rate; 187 s->samples_written -= s->sample_rate; 188 } 189 s->frame_size = s->frame_size_min + 190 2 * (s->bits_written * s->sample_rate < s->samples_written * s->bit_rate); 191 s->bits_written += s->frame_size * 8; 192 s->samples_written += AC3_BLOCK_SIZE * s->num_blocks; 193} 194 195 196/** 197 * Set the initial coupling strategy parameters prior to coupling analysis. 198 * 199 * @param s AC-3 encoder private context 200 */ 201void ff_ac3_compute_coupling_strategy(AC3EncodeContext *s) 202{ 203 int blk, ch; 204 int got_cpl_snr; 205 int num_cpl_blocks; 206 207 /* set coupling use flags for each block/channel */ 208 /* TODO: turn coupling on/off and adjust start band based on bit usage */ 209 for (blk = 0; blk < s->num_blocks; blk++) { 210 AC3Block *block = &s->blocks[blk]; 211 for (ch = 1; ch <= s->fbw_channels; ch++) 212 block->channel_in_cpl[ch] = s->cpl_on; 213 } 214 215 /* enable coupling for each block if at least 2 channels have coupling 216 enabled for that block */ 217 got_cpl_snr = 0; 218 num_cpl_blocks = 0; 219 for (blk = 0; blk < s->num_blocks; blk++) { 220 AC3Block *block = &s->blocks[blk]; 221 block->num_cpl_channels = 0; 222 for (ch = 1; ch <= s->fbw_channels; ch++) 223 block->num_cpl_channels += block->channel_in_cpl[ch]; 224 block->cpl_in_use = block->num_cpl_channels > 1; 225 num_cpl_blocks += block->cpl_in_use; 226 if (!block->cpl_in_use) { 227 block->num_cpl_channels = 0; 228 for (ch = 1; ch <= s->fbw_channels; ch++) 229 block->channel_in_cpl[ch] = 0; 230 } 231 232 block->new_cpl_strategy = !blk; 233 if (blk) { 234 for (ch = 1; ch <= s->fbw_channels; ch++) { 235 if (block->channel_in_cpl[ch] != s->blocks[blk-1].channel_in_cpl[ch]) { 236 block->new_cpl_strategy = 1; 237 break; 238 } 239 } 240 } 241 block->new_cpl_leak = block->new_cpl_strategy; 242 243 if (!blk || (block->cpl_in_use && !got_cpl_snr)) { 244 block->new_snr_offsets = 1; 245 if (block->cpl_in_use) 246 got_cpl_snr = 1; 247 } else { 248 block->new_snr_offsets = 0; 249 } 250 } 251 if (!num_cpl_blocks) 252 s->cpl_on = 0; 253 254 /* set bandwidth for each channel */ 255 for (blk = 0; blk < s->num_blocks; blk++) { 256 AC3Block *block = &s->blocks[blk]; 257 for (ch = 1; ch <= s->fbw_channels; ch++) { 258 if (block->channel_in_cpl[ch]) 259 block->end_freq[ch] = s->start_freq[CPL_CH]; 260 else 261 block->end_freq[ch] = s->bandwidth_code * 3 + 73; 262 } 263 } 264} 265 266 267/** 268 * Apply stereo rematrixing to coefficients based on rematrixing flags. 269 * 270 * @param s AC-3 encoder private context 271 */ 272void ff_ac3_apply_rematrixing(AC3EncodeContext *s) 273{ 274 int nb_coefs; 275 int blk, bnd, i; 276 int start, end; 277 uint8_t *flags = NULL; 278 279 if (!s->rematrixing_enabled) 280 return; 281 282 for (blk = 0; blk < s->num_blocks; blk++) { 283 AC3Block *block = &s->blocks[blk]; 284 if (block->new_rematrixing_strategy) 285 flags = block->rematrixing_flags; 286 nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]); 287 for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) { 288 if (flags[bnd]) { 289 start = ff_ac3_rematrix_band_tab[bnd]; 290 end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]); 291 for (i = start; i < end; i++) { 292 int32_t lt = block->fixed_coef[1][i]; 293 int32_t rt = block->fixed_coef[2][i]; 294 block->fixed_coef[1][i] = (lt + rt) >> 1; 295 block->fixed_coef[2][i] = (lt - rt) >> 1; 296 } 297 } 298 } 299 } 300} 301 302 303/* 304 * Initialize exponent tables. 305 */ 306static av_cold void exponent_init(AC3EncodeContext *s) 307{ 308 int expstr, i, grpsize; 309 310 for (expstr = EXP_D15-1; expstr <= EXP_D45-1; expstr++) { 311 grpsize = 3 << expstr; 312 for (i = 12; i < 256; i++) { 313 exponent_group_tab[0][expstr][i] = (i + grpsize - 4) / grpsize; 314 exponent_group_tab[1][expstr][i] = (i ) / grpsize; 315 } 316 } 317 /* LFE */ 318 exponent_group_tab[0][0][7] = 2; 319 320 if (CONFIG_EAC3_ENCODER && s->eac3) 321 ff_eac3_exponent_init(); 322} 323 324 325/* 326 * Extract exponents from the MDCT coefficients. 327 */ 328static void extract_exponents(AC3EncodeContext *s) 329{ 330 int ch = !s->cpl_on; 331 int chan_size = AC3_MAX_COEFS * s->num_blocks * (s->channels - ch + 1); 332 AC3Block *block = &s->blocks[0]; 333 334 s->ac3dsp.extract_exponents(block->exp[ch], block->fixed_coef[ch], chan_size); 335} 336 337 338/** 339 * Exponent Difference Threshold. 340 * New exponents are sent if their SAD exceed this number. 341 */ 342#define EXP_DIFF_THRESHOLD 500 343 344/** 345 * Table used to select exponent strategy based on exponent reuse block interval. 346 */ 347static const uint8_t exp_strategy_reuse_tab[4][6] = { 348 { EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15 }, 349 { EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15 }, 350 { EXP_D25, EXP_D25, EXP_D15, EXP_D15, EXP_D15, EXP_D15 }, 351 { EXP_D45, EXP_D25, EXP_D25, EXP_D15, EXP_D15, EXP_D15 } 352}; 353 354/* 355 * Calculate exponent strategies for all channels. 356 * Array arrangement is reversed to simplify the per-channel calculation. 357 */ 358static void compute_exp_strategy(AC3EncodeContext *s) 359{ 360 int ch, blk, blk1; 361 362 for (ch = !s->cpl_on; ch <= s->fbw_channels; ch++) { 363 uint8_t *exp_strategy = s->exp_strategy[ch]; 364 uint8_t *exp = s->blocks[0].exp[ch]; 365 int exp_diff; 366 367 /* estimate if the exponent variation & decide if they should be 368 reused in the next frame */ 369 exp_strategy[0] = EXP_NEW; 370 exp += AC3_MAX_COEFS; 371 for (blk = 1; blk < s->num_blocks; blk++, exp += AC3_MAX_COEFS) { 372 if (ch == CPL_CH) { 373 if (!s->blocks[blk-1].cpl_in_use) { 374 exp_strategy[blk] = EXP_NEW; 375 continue; 376 } else if (!s->blocks[blk].cpl_in_use) { 377 exp_strategy[blk] = EXP_REUSE; 378 continue; 379 } 380 } else if (s->blocks[blk].channel_in_cpl[ch] != s->blocks[blk-1].channel_in_cpl[ch]) { 381 exp_strategy[blk] = EXP_NEW; 382 continue; 383 } 384 exp_diff = s->mecc.sad[0](NULL, exp, exp - AC3_MAX_COEFS, 16, 16); 385 exp_strategy[blk] = EXP_REUSE; 386 if (ch == CPL_CH && exp_diff > (EXP_DIFF_THRESHOLD * (s->blocks[blk].end_freq[ch] - s->start_freq[ch]) / AC3_MAX_COEFS)) 387 exp_strategy[blk] = EXP_NEW; 388 else if (ch > CPL_CH && exp_diff > EXP_DIFF_THRESHOLD) 389 exp_strategy[blk] = EXP_NEW; 390 } 391 392 /* now select the encoding strategy type : if exponents are often 393 recoded, we use a coarse encoding */ 394 blk = 0; 395 while (blk < s->num_blocks) { 396 blk1 = blk + 1; 397 while (blk1 < s->num_blocks && exp_strategy[blk1] == EXP_REUSE) 398 blk1++; 399 exp_strategy[blk] = exp_strategy_reuse_tab[s->num_blks_code][blk1-blk-1]; 400 blk = blk1; 401 } 402 } 403 if (s->lfe_on) { 404 ch = s->lfe_channel; 405 s->exp_strategy[ch][0] = EXP_D15; 406 for (blk = 1; blk < s->num_blocks; blk++) 407 s->exp_strategy[ch][blk] = EXP_REUSE; 408 } 409 410 /* for E-AC-3, determine frame exponent strategy */ 411 if (CONFIG_EAC3_ENCODER && s->eac3) 412 ff_eac3_get_frame_exp_strategy(s); 413} 414 415 416/** 417 * Update the exponents so that they are the ones the decoder will decode. 418 * 419 * @param[in,out] exp array of exponents for 1 block in 1 channel 420 * @param nb_exps number of exponents in active bandwidth 421 * @param exp_strategy exponent strategy for the block 422 * @param cpl indicates if the block is in the coupling channel 423 */ 424static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy, 425 int cpl) 426{ 427 int nb_groups, i, k; 428 429 nb_groups = exponent_group_tab[cpl][exp_strategy-1][nb_exps] * 3; 430 431 /* for each group, compute the minimum exponent */ 432 switch(exp_strategy) { 433 case EXP_D25: 434 for (i = 1, k = 1-cpl; i <= nb_groups; i++) { 435 uint8_t exp_min = exp[k]; 436 if (exp[k+1] < exp_min) 437 exp_min = exp[k+1]; 438 exp[i-cpl] = exp_min; 439 k += 2; 440 } 441 break; 442 case EXP_D45: 443 for (i = 1, k = 1-cpl; i <= nb_groups; i++) { 444 uint8_t exp_min = exp[k]; 445 if (exp[k+1] < exp_min) 446 exp_min = exp[k+1]; 447 if (exp[k+2] < exp_min) 448 exp_min = exp[k+2]; 449 if (exp[k+3] < exp_min) 450 exp_min = exp[k+3]; 451 exp[i-cpl] = exp_min; 452 k += 4; 453 } 454 break; 455 } 456 457 /* constraint for DC exponent */ 458 if (!cpl && exp[0] > 15) 459 exp[0] = 15; 460 461 /* decrease the delta between each groups to within 2 so that they can be 462 differentially encoded */ 463 for (i = 1; i <= nb_groups; i++) 464 exp[i] = FFMIN(exp[i], exp[i-1] + 2); 465 i--; 466 while (--i >= 0) 467 exp[i] = FFMIN(exp[i], exp[i+1] + 2); 468 469 if (cpl) 470 exp[-1] = exp[0] & ~1; 471 472 /* now we have the exponent values the decoder will see */ 473 switch (exp_strategy) { 474 case EXP_D25: 475 for (i = nb_groups, k = (nb_groups * 2)-cpl; i > 0; i--) { 476 uint8_t exp1 = exp[i-cpl]; 477 exp[k--] = exp1; 478 exp[k--] = exp1; 479 } 480 break; 481 case EXP_D45: 482 for (i = nb_groups, k = (nb_groups * 4)-cpl; i > 0; i--) { 483 exp[k] = exp[k-1] = exp[k-2] = exp[k-3] = exp[i-cpl]; 484 k -= 4; 485 } 486 break; 487 } 488} 489 490 491/* 492 * Encode exponents from original extracted form to what the decoder will see. 493 * This copies and groups exponents based on exponent strategy and reduces 494 * deltas between adjacent exponent groups so that they can be differentially 495 * encoded. 496 */ 497static void encode_exponents(AC3EncodeContext *s) 498{ 499 int blk, blk1, ch, cpl; 500 uint8_t *exp, *exp_strategy; 501 int nb_coefs, num_reuse_blocks; 502 503 for (ch = !s->cpl_on; ch <= s->channels; ch++) { 504 exp = s->blocks[0].exp[ch] + s->start_freq[ch]; 505 exp_strategy = s->exp_strategy[ch]; 506 507 cpl = (ch == CPL_CH); 508 blk = 0; 509 while (blk < s->num_blocks) { 510 AC3Block *block = &s->blocks[blk]; 511 if (cpl && !block->cpl_in_use) { 512 exp += AC3_MAX_COEFS; 513 blk++; 514 continue; 515 } 516 nb_coefs = block->end_freq[ch] - s->start_freq[ch]; 517 blk1 = blk + 1; 518 519 /* count the number of EXP_REUSE blocks after the current block 520 and set exponent reference block numbers */ 521 s->exp_ref_block[ch][blk] = blk; 522 while (blk1 < s->num_blocks && exp_strategy[blk1] == EXP_REUSE) { 523 s->exp_ref_block[ch][blk1] = blk; 524 blk1++; 525 } 526 num_reuse_blocks = blk1 - blk - 1; 527 528 /* for the EXP_REUSE case we select the min of the exponents */ 529 s->ac3dsp.ac3_exponent_min(exp-s->start_freq[ch], num_reuse_blocks, 530 AC3_MAX_COEFS); 531 532 encode_exponents_blk_ch(exp, nb_coefs, exp_strategy[blk], cpl); 533 534 exp += AC3_MAX_COEFS * (num_reuse_blocks + 1); 535 blk = blk1; 536 } 537 } 538 539 /* reference block numbers have been changed, so reset ref_bap_set */ 540 s->ref_bap_set = 0; 541} 542 543 544/* 545 * Count exponent bits based on bandwidth, coupling, and exponent strategies. 546 */ 547static int count_exponent_bits(AC3EncodeContext *s) 548{ 549 int blk, ch; 550 int nb_groups, bit_count; 551 552 bit_count = 0; 553 for (blk = 0; blk < s->num_blocks; blk++) { 554 AC3Block *block = &s->blocks[blk]; 555 for (ch = !block->cpl_in_use; ch <= s->channels; ch++) { 556 int exp_strategy = s->exp_strategy[ch][blk]; 557 int cpl = (ch == CPL_CH); 558 int nb_coefs = block->end_freq[ch] - s->start_freq[ch]; 559 560 if (exp_strategy == EXP_REUSE) 561 continue; 562 563 nb_groups = exponent_group_tab[cpl][exp_strategy-1][nb_coefs]; 564 bit_count += 4 + (nb_groups * 7); 565 } 566 } 567 568 return bit_count; 569} 570 571 572/** 573 * Group exponents. 574 * 3 delta-encoded exponents are in each 7-bit group. The number of groups 575 * varies depending on exponent strategy and bandwidth. 576 * 577 * @param s AC-3 encoder private context 578 */ 579void ff_ac3_group_exponents(AC3EncodeContext *s) 580{ 581 int blk, ch, i, cpl; 582 int group_size, nb_groups; 583 uint8_t *p; 584 int delta0, delta1, delta2; 585 int exp0, exp1; 586 587 for (blk = 0; blk < s->num_blocks; blk++) { 588 AC3Block *block = &s->blocks[blk]; 589 for (ch = !block->cpl_in_use; ch <= s->channels; ch++) { 590 int exp_strategy = s->exp_strategy[ch][blk]; 591 if (exp_strategy == EXP_REUSE) 592 continue; 593 cpl = (ch == CPL_CH); 594 group_size = exp_strategy + (exp_strategy == EXP_D45); 595 nb_groups = exponent_group_tab[cpl][exp_strategy-1][block->end_freq[ch]-s->start_freq[ch]]; 596 p = block->exp[ch] + s->start_freq[ch] - cpl; 597 598 /* DC exponent */ 599 exp1 = *p++; 600 block->grouped_exp[ch][0] = exp1; 601 602 /* remaining exponents are delta encoded */ 603 for (i = 1; i <= nb_groups; i++) { 604 /* merge three delta in one code */ 605 exp0 = exp1; 606 exp1 = p[0]; 607 p += group_size; 608 delta0 = exp1 - exp0 + 2; 609 av_assert2(delta0 >= 0 && delta0 <= 4); 610 611 exp0 = exp1; 612 exp1 = p[0]; 613 p += group_size; 614 delta1 = exp1 - exp0 + 2; 615 av_assert2(delta1 >= 0 && delta1 <= 4); 616 617 exp0 = exp1; 618 exp1 = p[0]; 619 p += group_size; 620 delta2 = exp1 - exp0 + 2; 621 av_assert2(delta2 >= 0 && delta2 <= 4); 622 623 block->grouped_exp[ch][i] = ((delta0 * 5 + delta1) * 5) + delta2; 624 } 625 } 626 } 627} 628 629 630/** 631 * Calculate final exponents from the supplied MDCT coefficients and exponent shift. 632 * Extract exponents from MDCT coefficients, calculate exponent strategies, 633 * and encode final exponents. 634 * 635 * @param s AC-3 encoder private context 636 */ 637void ff_ac3_process_exponents(AC3EncodeContext *s) 638{ 639 extract_exponents(s); 640 641 compute_exp_strategy(s); 642 643 encode_exponents(s); 644 645 emms_c(); 646} 647 648 649/* 650 * Count frame bits that are based solely on fixed parameters. 651 * This only has to be run once when the encoder is initialized. 652 */ 653static void count_frame_bits_fixed(AC3EncodeContext *s) 654{ 655 static const uint8_t frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 }; 656 int blk; 657 int frame_bits; 658 659 /* assumptions: 660 * no dynamic range codes 661 * bit allocation parameters do not change between blocks 662 * no delta bit allocation 663 * no skipped data 664 * no auxiliary data 665 * no E-AC-3 metadata 666 */ 667 668 /* header */ 669 frame_bits = 16; /* sync info */ 670 if (s->eac3) { 671 /* bitstream info header */ 672 frame_bits += 35; 673 frame_bits += 1 + 1; 674 if (s->num_blocks != 0x6) 675 frame_bits++; 676 frame_bits++; 677 /* audio frame header */ 678 if (s->num_blocks == 6) 679 frame_bits += 2; 680 frame_bits += 10; 681 /* exponent strategy */ 682 if (s->use_frame_exp_strategy) 683 frame_bits += 5 * s->fbw_channels; 684 else 685 frame_bits += s->num_blocks * 2 * s->fbw_channels; 686 if (s->lfe_on) 687 frame_bits += s->num_blocks; 688 /* converter exponent strategy */ 689 if (s->num_blks_code != 0x3) 690 frame_bits++; 691 else 692 frame_bits += s->fbw_channels * 5; 693 /* snr offsets */ 694 frame_bits += 10; 695 /* block start info */ 696 if (s->num_blocks != 1) 697 frame_bits++; 698 } else { 699 frame_bits += 49; 700 frame_bits += frame_bits_inc[s->channel_mode]; 701 } 702 703 /* audio blocks */ 704 for (blk = 0; blk < s->num_blocks; blk++) { 705 if (!s->eac3) { 706 /* block switch flags */ 707 frame_bits += s->fbw_channels; 708 709 /* dither flags */ 710 frame_bits += s->fbw_channels; 711 } 712 713 /* dynamic range */ 714 frame_bits++; 715 716 /* spectral extension */ 717 if (s->eac3) 718 frame_bits++; 719 720 if (!s->eac3) { 721 /* exponent strategy */ 722 frame_bits += 2 * s->fbw_channels; 723 if (s->lfe_on) 724 frame_bits++; 725 726 /* bit allocation params */ 727 frame_bits++; 728 if (!blk) 729 frame_bits += 2 + 2 + 2 + 2 + 3; 730 } 731 732 /* converter snr offset */ 733 if (s->eac3) 734 frame_bits++; 735 736 if (!s->eac3) { 737 /* delta bit allocation */ 738 frame_bits++; 739 740 /* skipped data */ 741 frame_bits++; 742 } 743 } 744 745 /* auxiliary data */ 746 frame_bits++; 747 748 /* CRC */ 749 frame_bits += 1 + 16; 750 751 s->frame_bits_fixed = frame_bits; 752} 753 754 755/* 756 * Initialize bit allocation. 757 * Set default parameter codes and calculate parameter values. 758 */ 759static av_cold void bit_alloc_init(AC3EncodeContext *s) 760{ 761 int ch; 762 763 /* init default parameters */ 764 s->slow_decay_code = 2; 765 s->fast_decay_code = 1; 766 s->slow_gain_code = 1; 767 s->db_per_bit_code = s->eac3 ? 2 : 3; 768 s->floor_code = 7; 769 for (ch = 0; ch <= s->channels; ch++) 770 s->fast_gain_code[ch] = 4; 771 772 /* initial snr offset */ 773 s->coarse_snr_offset = 40; 774 775 /* compute real values */ 776 /* currently none of these values change during encoding, so we can just 777 set them once at initialization */ 778 s->bit_alloc.slow_decay = ff_ac3_slow_decay_tab[s->slow_decay_code] >> s->bit_alloc.sr_shift; 779 s->bit_alloc.fast_decay = ff_ac3_fast_decay_tab[s->fast_decay_code] >> s->bit_alloc.sr_shift; 780 s->bit_alloc.slow_gain = ff_ac3_slow_gain_tab[s->slow_gain_code]; 781 s->bit_alloc.db_per_bit = ff_ac3_db_per_bit_tab[s->db_per_bit_code]; 782 s->bit_alloc.floor = ff_ac3_floor_tab[s->floor_code]; 783 s->bit_alloc.cpl_fast_leak = 0; 784 s->bit_alloc.cpl_slow_leak = 0; 785 786 count_frame_bits_fixed(s); 787} 788 789 790/* 791 * Count the bits used to encode the frame, minus exponents and mantissas. 792 * Bits based on fixed parameters have already been counted, so now we just 793 * have to add the bits based on parameters that change during encoding. 794 */ 795static void count_frame_bits(AC3EncodeContext *s) 796{ 797 AC3EncOptions *opt = &s->options; 798 int blk, ch; 799 int frame_bits = 0; 800 801 /* header */ 802 if (s->eac3) { 803 if (opt->eac3_mixing_metadata) { 804 if (s->channel_mode > AC3_CHMODE_STEREO) 805 frame_bits += 2; 806 if (s->has_center) 807 frame_bits += 6; 808 if (s->has_surround) 809 frame_bits += 6; 810 frame_bits += s->lfe_on; 811 frame_bits += 1 + 1 + 2; 812 if (s->channel_mode < AC3_CHMODE_STEREO) 813 frame_bits++; 814 frame_bits++; 815 } 816 if (opt->eac3_info_metadata) { 817 frame_bits += 3 + 1 + 1; 818 if (s->channel_mode == AC3_CHMODE_STEREO) 819 frame_bits += 2 + 2; 820 if (s->channel_mode >= AC3_CHMODE_2F2R) 821 frame_bits += 2; 822 frame_bits++; 823 if (opt->audio_production_info) 824 frame_bits += 5 + 2 + 1; 825 frame_bits++; 826 } 827 /* coupling */ 828 if (s->channel_mode > AC3_CHMODE_MONO) { 829 frame_bits++; 830 for (blk = 1; blk < s->num_blocks; blk++) { 831 AC3Block *block = &s->blocks[blk]; 832 frame_bits++; 833 if (block->new_cpl_strategy) 834 frame_bits++; 835 } 836 } 837 /* coupling exponent strategy */ 838 if (s->cpl_on) { 839 if (s->use_frame_exp_strategy) { 840 frame_bits += 5 * s->cpl_on; 841 } else { 842 for (blk = 0; blk < s->num_blocks; blk++) 843 frame_bits += 2 * s->blocks[blk].cpl_in_use; 844 } 845 } 846 } else { 847 if (opt->audio_production_info) 848 frame_bits += 7; 849 if (s->bitstream_id == 6) { 850 if (opt->extended_bsi_1) 851 frame_bits += 14; 852 if (opt->extended_bsi_2) 853 frame_bits += 14; 854 } 855 } 856 857 /* audio blocks */ 858 for (blk = 0; blk < s->num_blocks; blk++) { 859 AC3Block *block = &s->blocks[blk]; 860 861 /* coupling strategy */ 862 if (!s->eac3) 863 frame_bits++; 864 if (block->new_cpl_strategy) { 865 if (!s->eac3) 866 frame_bits++; 867 if (block->cpl_in_use) { 868 if (s->eac3) 869 frame_bits++; 870 if (!s->eac3 || s->channel_mode != AC3_CHMODE_STEREO) 871 frame_bits += s->fbw_channels; 872 if (s->channel_mode == AC3_CHMODE_STEREO) 873 frame_bits++; 874 frame_bits += 4 + 4; 875 if (s->eac3) 876 frame_bits++; 877 else 878 frame_bits += s->num_cpl_subbands - 1; 879 } 880 } 881 882 /* coupling coordinates */ 883 if (block->cpl_in_use) { 884 for (ch = 1; ch <= s->fbw_channels; ch++) { 885 if (block->channel_in_cpl[ch]) { 886 if (!s->eac3 || block->new_cpl_coords[ch] != 2) 887 frame_bits++; 888 if (block->new_cpl_coords[ch]) { 889 frame_bits += 2; 890 frame_bits += (4 + 4) * s->num_cpl_bands; 891 } 892 } 893 } 894 } 895 896 /* stereo rematrixing */ 897 if (s->channel_mode == AC3_CHMODE_STEREO) { 898 if (!s->eac3 || blk > 0) 899 frame_bits++; 900 if (s->blocks[blk].new_rematrixing_strategy) 901 frame_bits += block->num_rematrixing_bands; 902 } 903 904 /* bandwidth codes & gain range */ 905 for (ch = 1; ch <= s->fbw_channels; ch++) { 906 if (s->exp_strategy[ch][blk] != EXP_REUSE) { 907 if (!block->channel_in_cpl[ch]) 908 frame_bits += 6; 909 frame_bits += 2; 910 } 911 } 912 913 /* coupling exponent strategy */ 914 if (!s->eac3 && block->cpl_in_use) 915 frame_bits += 2; 916 917 /* snr offsets and fast gain codes */ 918 if (!s->eac3) { 919 frame_bits++; 920 if (block->new_snr_offsets) 921 frame_bits += 6 + (s->channels + block->cpl_in_use) * (4 + 3); 922 } 923 924 /* coupling leak info */ 925 if (block->cpl_in_use) { 926 if (!s->eac3 || block->new_cpl_leak != 2) 927 frame_bits++; 928 if (block->new_cpl_leak) 929 frame_bits += 3 + 3; 930 } 931 } 932 933 s->frame_bits = s->frame_bits_fixed + frame_bits; 934} 935 936 937/* 938 * Calculate masking curve based on the final exponents. 939 * Also calculate the power spectral densities to use in future calculations. 940 */ 941static void bit_alloc_masking(AC3EncodeContext *s) 942{ 943 int blk, ch; 944 945 for (blk = 0; blk < s->num_blocks; blk++) { 946 AC3Block *block = &s->blocks[blk]; 947 for (ch = !block->cpl_in_use; ch <= s->channels; ch++) { 948 /* We only need psd and mask for calculating bap. 949 Since we currently do not calculate bap when exponent 950 strategy is EXP_REUSE we do not need to calculate psd or mask. */ 951 if (s->exp_strategy[ch][blk] != EXP_REUSE) { 952 ff_ac3_bit_alloc_calc_psd(block->exp[ch], s->start_freq[ch], 953 block->end_freq[ch], block->psd[ch], 954 block->band_psd[ch]); 955 ff_ac3_bit_alloc_calc_mask(&s->bit_alloc, block->band_psd[ch], 956 s->start_freq[ch], block->end_freq[ch], 957 ff_ac3_fast_gain_tab[s->fast_gain_code[ch]], 958 ch == s->lfe_channel, 959 DBA_NONE, 0, NULL, NULL, NULL, 960 block->mask[ch]); 961 } 962 } 963 } 964} 965 966 967/* 968 * Ensure that bap for each block and channel point to the current bap_buffer. 969 * They may have been switched during the bit allocation search. 970 */ 971static void reset_block_bap(AC3EncodeContext *s) 972{ 973 int blk, ch; 974 uint8_t *ref_bap; 975 976 if (s->ref_bap[0][0] == s->bap_buffer && s->ref_bap_set) 977 return; 978 979 ref_bap = s->bap_buffer; 980 for (ch = 0; ch <= s->channels; ch++) { 981 for (blk = 0; blk < s->num_blocks; blk++) 982 s->ref_bap[ch][blk] = ref_bap + AC3_MAX_COEFS * s->exp_ref_block[ch][blk]; 983 ref_bap += AC3_MAX_COEFS * s->num_blocks; 984 } 985 s->ref_bap_set = 1; 986} 987 988 989/** 990 * Initialize mantissa counts. 991 * These are set so that they are padded to the next whole group size when bits 992 * are counted in compute_mantissa_size. 993 * 994 * @param[in,out] mant_cnt running counts for each bap value for each block 995 */ 996static void count_mantissa_bits_init(uint16_t mant_cnt[AC3_MAX_BLOCKS][16]) 997{ 998 int blk; 999 1000 for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) { 1001 memset(mant_cnt[blk], 0, sizeof(mant_cnt[blk])); 1002 mant_cnt[blk][1] = mant_cnt[blk][2] = 2; 1003 mant_cnt[blk][4] = 1; 1004 } 1005} 1006 1007 1008/** 1009 * Update mantissa bit counts for all blocks in 1 channel in a given bandwidth 1010 * range. 1011 * 1012 * @param s AC-3 encoder private context 1013 * @param ch channel index 1014 * @param[in,out] mant_cnt running counts for each bap value for each block 1015 * @param start starting coefficient bin 1016 * @param end ending coefficient bin 1017 */ 1018static void count_mantissa_bits_update_ch(AC3EncodeContext *s, int ch, 1019 uint16_t mant_cnt[AC3_MAX_BLOCKS][16], 1020 int start, int end) 1021{ 1022 int blk; 1023 1024 for (blk = 0; blk < s->num_blocks; blk++) { 1025 AC3Block *block = &s->blocks[blk]; 1026 if (ch == CPL_CH && !block->cpl_in_use) 1027 continue; 1028 s->ac3dsp.update_bap_counts(mant_cnt[blk], 1029 s->ref_bap[ch][blk] + start, 1030 FFMIN(end, block->end_freq[ch]) - start); 1031 } 1032} 1033 1034 1035/* 1036 * Count the number of mantissa bits in the frame based on the bap values. 1037 */ 1038static int count_mantissa_bits(AC3EncodeContext *s) 1039{ 1040 int ch, max_end_freq; 1041 LOCAL_ALIGNED_16(uint16_t, mant_cnt, [AC3_MAX_BLOCKS], [16]); 1042 1043 count_mantissa_bits_init(mant_cnt); 1044 1045 max_end_freq = s->bandwidth_code * 3 + 73; 1046 for (ch = !s->cpl_enabled; ch <= s->channels; ch++) 1047 count_mantissa_bits_update_ch(s, ch, mant_cnt, s->start_freq[ch], 1048 max_end_freq); 1049 1050 return s->ac3dsp.compute_mantissa_size(mant_cnt); 1051} 1052 1053 1054/** 1055 * Run the bit allocation with a given SNR offset. 1056 * This calculates the bit allocation pointers that will be used to determine 1057 * the quantization of each mantissa. 1058 * 1059 * @param s AC-3 encoder private context 1060 * @param snr_offset SNR offset, 0 to 1023 1061 * @return the number of bits needed for mantissas if the given SNR offset is 1062 * is used. 1063 */ 1064static int bit_alloc(AC3EncodeContext *s, int snr_offset) 1065{ 1066 int blk, ch; 1067 1068 snr_offset = (snr_offset - 240) * 4; 1069 1070 reset_block_bap(s); 1071 for (blk = 0; blk < s->num_blocks; blk++) { 1072 AC3Block *block = &s->blocks[blk]; 1073 1074 for (ch = !block->cpl_in_use; ch <= s->channels; ch++) { 1075 /* Currently the only bit allocation parameters which vary across 1076 blocks within a frame are the exponent values. We can take 1077 advantage of that by reusing the bit allocation pointers 1078 whenever we reuse exponents. */ 1079 if (s->exp_strategy[ch][blk] != EXP_REUSE) { 1080 s->ac3dsp.bit_alloc_calc_bap(block->mask[ch], block->psd[ch], 1081 s->start_freq[ch], block->end_freq[ch], 1082 snr_offset, s->bit_alloc.floor, 1083 ff_ac3_bap_tab, s->ref_bap[ch][blk]); 1084 } 1085 } 1086 } 1087 return count_mantissa_bits(s); 1088} 1089 1090 1091/* 1092 * Constant bitrate bit allocation search. 1093 * Find the largest SNR offset that will allow data to fit in the frame. 1094 */ 1095static int cbr_bit_allocation(AC3EncodeContext *s) 1096{ 1097 int ch; 1098 int bits_left; 1099 int snr_offset, snr_incr; 1100 1101 bits_left = 8 * s->frame_size - (s->frame_bits + s->exponent_bits); 1102 if (bits_left < 0) 1103 return AVERROR(EINVAL); 1104 1105 snr_offset = s->coarse_snr_offset << 4; 1106 1107 /* if previous frame SNR offset was 1023, check if current frame can also 1108 use SNR offset of 1023. if so, skip the search. */ 1109 if ((snr_offset | s->fine_snr_offset[1]) == 1023) { 1110 if (bit_alloc(s, 1023) <= bits_left) 1111 return 0; 1112 } 1113 1114 while (snr_offset >= 0 && 1115 bit_alloc(s, snr_offset) > bits_left) { 1116 snr_offset -= 64; 1117 } 1118 if (snr_offset < 0) 1119 return AVERROR(EINVAL); 1120 1121 FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer); 1122 for (snr_incr = 64; snr_incr > 0; snr_incr >>= 2) { 1123 while (snr_offset + snr_incr <= 1023 && 1124 bit_alloc(s, snr_offset + snr_incr) <= bits_left) { 1125 snr_offset += snr_incr; 1126 FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer); 1127 } 1128 } 1129 FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer); 1130 reset_block_bap(s); 1131 1132 s->coarse_snr_offset = snr_offset >> 4; 1133 for (ch = !s->cpl_on; ch <= s->channels; ch++) 1134 s->fine_snr_offset[ch] = snr_offset & 0xF; 1135 1136 return 0; 1137} 1138 1139 1140/* 1141 * Perform bit allocation search. 1142 * Finds the SNR offset value that maximizes quality and fits in the specified 1143 * frame size. Output is the SNR offset and a set of bit allocation pointers 1144 * used to quantize the mantissas. 1145 */ 1146int ff_ac3_compute_bit_allocation(AC3EncodeContext *s) 1147{ 1148 count_frame_bits(s); 1149 1150 s->exponent_bits = count_exponent_bits(s); 1151 1152 bit_alloc_masking(s); 1153 1154 return cbr_bit_allocation(s); 1155} 1156 1157 1158/** 1159 * Symmetric quantization on 'levels' levels. 1160 * 1161 * @param c unquantized coefficient 1162 * @param e exponent 1163 * @param levels number of quantization levels 1164 * @return quantized coefficient 1165 */ 1166static inline int sym_quant(int c, int e, int levels) 1167{ 1168 int v = (((levels * c) >> (24 - e)) + levels) >> 1; 1169 av_assert2(v >= 0 && v < levels); 1170 return v; 1171} 1172 1173 1174/** 1175 * Asymmetric quantization on 2^qbits levels. 1176 * 1177 * @param c unquantized coefficient 1178 * @param e exponent 1179 * @param qbits number of quantization bits 1180 * @return quantized coefficient 1181 */ 1182static inline int asym_quant(int c, int e, int qbits) 1183{ 1184 int m; 1185 1186 c = (((c * (1<<e)) >> (24 - qbits)) + 1) >> 1; 1187 m = (1 << (qbits-1)); 1188 if (c >= m) 1189 c = m - 1; 1190 av_assert2(c >= -m); 1191 return c; 1192} 1193 1194 1195/** 1196 * Quantize a set of mantissas for a single channel in a single block. 1197 * 1198 * @param s Mantissa count context 1199 * @param fixed_coef unquantized fixed-point coefficients 1200 * @param exp exponents 1201 * @param bap bit allocation pointer indices 1202 * @param[out] qmant quantized coefficients 1203 * @param start_freq starting coefficient bin 1204 * @param end_freq ending coefficient bin 1205 */ 1206static void quantize_mantissas_blk_ch(AC3Mant *s, int32_t *fixed_coef, 1207 uint8_t *exp, uint8_t *bap, 1208 int16_t *qmant, int start_freq, 1209 int end_freq) 1210{ 1211 int i; 1212 1213 for (i = start_freq; i < end_freq; i++) { 1214 int c = fixed_coef[i]; 1215 int e = exp[i]; 1216 int v = bap[i]; 1217 if (v) 1218 switch (v) { 1219 case 1: 1220 v = sym_quant(c, e, 3); 1221 switch (s->mant1_cnt) { 1222 case 0: 1223 s->qmant1_ptr = &qmant[i]; 1224 v = 9 * v; 1225 s->mant1_cnt = 1; 1226 break; 1227 case 1: 1228 *s->qmant1_ptr += 3 * v; 1229 s->mant1_cnt = 2; 1230 v = 128; 1231 break; 1232 default: 1233 *s->qmant1_ptr += v; 1234 s->mant1_cnt = 0; 1235 v = 128; 1236 break; 1237 } 1238 break; 1239 case 2: 1240 v = sym_quant(c, e, 5); 1241 switch (s->mant2_cnt) { 1242 case 0: 1243 s->qmant2_ptr = &qmant[i]; 1244 v = 25 * v; 1245 s->mant2_cnt = 1; 1246 break; 1247 case 1: 1248 *s->qmant2_ptr += 5 * v; 1249 s->mant2_cnt = 2; 1250 v = 128; 1251 break; 1252 default: 1253 *s->qmant2_ptr += v; 1254 s->mant2_cnt = 0; 1255 v = 128; 1256 break; 1257 } 1258 break; 1259 case 3: 1260 v = sym_quant(c, e, 7); 1261 break; 1262 case 4: 1263 v = sym_quant(c, e, 11); 1264 switch (s->mant4_cnt) { 1265 case 0: 1266 s->qmant4_ptr = &qmant[i]; 1267 v = 11 * v; 1268 s->mant4_cnt = 1; 1269 break; 1270 default: 1271 *s->qmant4_ptr += v; 1272 s->mant4_cnt = 0; 1273 v = 128; 1274 break; 1275 } 1276 break; 1277 case 5: 1278 v = sym_quant(c, e, 15); 1279 break; 1280 case 14: 1281 v = asym_quant(c, e, 14); 1282 break; 1283 case 15: 1284 v = asym_quant(c, e, 16); 1285 break; 1286 default: 1287 v = asym_quant(c, e, v - 1); 1288 break; 1289 } 1290 qmant[i] = v; 1291 } 1292} 1293 1294 1295/** 1296 * Quantize mantissas using coefficients, exponents, and bit allocation pointers. 1297 * 1298 * @param s AC-3 encoder private context 1299 */ 1300void ff_ac3_quantize_mantissas(AC3EncodeContext *s) 1301{ 1302 int blk, ch, ch0=0, got_cpl; 1303 1304 for (blk = 0; blk < s->num_blocks; blk++) { 1305 AC3Block *block = &s->blocks[blk]; 1306 AC3Mant m = { 0 }; 1307 1308 got_cpl = !block->cpl_in_use; 1309 for (ch = 1; ch <= s->channels; ch++) { 1310 if (!got_cpl && ch > 1 && block->channel_in_cpl[ch-1]) { 1311 ch0 = ch - 1; 1312 ch = CPL_CH; 1313 got_cpl = 1; 1314 } 1315 quantize_mantissas_blk_ch(&m, block->fixed_coef[ch], 1316 s->blocks[s->exp_ref_block[ch][blk]].exp[ch], 1317 s->ref_bap[ch][blk], block->qmant[ch], 1318 s->start_freq[ch], block->end_freq[ch]); 1319 if (ch == CPL_CH) 1320 ch = ch0; 1321 } 1322 } 1323} 1324 1325 1326/* 1327 * Write the AC-3 frame header to the output bitstream. 1328 */ 1329static void ac3_output_frame_header(AC3EncodeContext *s) 1330{ 1331 AC3EncOptions *opt = &s->options; 1332 1333 put_bits(&s->pb, 16, 0x0b77); /* frame header */ 1334 put_bits(&s->pb, 16, 0); /* crc1: will be filled later */ 1335 put_bits(&s->pb, 2, s->bit_alloc.sr_code); 1336 put_bits(&s->pb, 6, s->frame_size_code + (s->frame_size - s->frame_size_min) / 2); 1337 put_bits(&s->pb, 5, s->bitstream_id); 1338 put_bits(&s->pb, 3, s->bitstream_mode); 1339 put_bits(&s->pb, 3, s->channel_mode); 1340 if ((s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO) 1341 put_bits(&s->pb, 2, s->center_mix_level); 1342 if (s->channel_mode & 0x04) 1343 put_bits(&s->pb, 2, s->surround_mix_level); 1344 if (s->channel_mode == AC3_CHMODE_STEREO) 1345 put_bits(&s->pb, 2, opt->dolby_surround_mode); 1346 put_bits(&s->pb, 1, s->lfe_on); /* LFE */ 1347 put_bits(&s->pb, 5, -opt->dialogue_level); 1348 put_bits(&s->pb, 1, 0); /* no compression control word */ 1349 put_bits(&s->pb, 1, 0); /* no lang code */ 1350 put_bits(&s->pb, 1, opt->audio_production_info); 1351 if (opt->audio_production_info) { 1352 put_bits(&s->pb, 5, opt->mixing_level - 80); 1353 put_bits(&s->pb, 2, opt->room_type); 1354 } 1355 put_bits(&s->pb, 1, opt->copyright); 1356 put_bits(&s->pb, 1, opt->original); 1357 if (s->bitstream_id == 6) { 1358 /* alternate bit stream syntax */ 1359 put_bits(&s->pb, 1, opt->extended_bsi_1); 1360 if (opt->extended_bsi_1) { 1361 put_bits(&s->pb, 2, opt->preferred_stereo_downmix); 1362 put_bits(&s->pb, 3, s->ltrt_center_mix_level); 1363 put_bits(&s->pb, 3, s->ltrt_surround_mix_level); 1364 put_bits(&s->pb, 3, s->loro_center_mix_level); 1365 put_bits(&s->pb, 3, s->loro_surround_mix_level); 1366 } 1367 put_bits(&s->pb, 1, opt->extended_bsi_2); 1368 if (opt->extended_bsi_2) { 1369 put_bits(&s->pb, 2, opt->dolby_surround_ex_mode); 1370 put_bits(&s->pb, 2, opt->dolby_headphone_mode); 1371 put_bits(&s->pb, 1, opt->ad_converter_type); 1372 put_bits(&s->pb, 9, 0); /* xbsi2 and encinfo : reserved */ 1373 } 1374 } else { 1375 put_bits(&s->pb, 1, 0); /* no time code 1 */ 1376 put_bits(&s->pb, 1, 0); /* no time code 2 */ 1377 } 1378 put_bits(&s->pb, 1, 0); /* no additional bit stream info */ 1379} 1380 1381 1382/* 1383 * Write one audio block to the output bitstream. 1384 */ 1385static void output_audio_block(AC3EncodeContext *s, int blk) 1386{ 1387 int ch, i, baie, bnd, got_cpl, av_uninit(ch0); 1388 AC3Block *block = &s->blocks[blk]; 1389 1390 /* block switching */ 1391 if (!s->eac3) { 1392 for (ch = 0; ch < s->fbw_channels; ch++) 1393 put_bits(&s->pb, 1, 0); 1394 } 1395 1396 /* dither flags */ 1397 if (!s->eac3) { 1398 for (ch = 0; ch < s->fbw_channels; ch++) 1399 put_bits(&s->pb, 1, 1); 1400 } 1401 1402 /* dynamic range codes */ 1403 put_bits(&s->pb, 1, 0); 1404 1405 /* spectral extension */ 1406 if (s->eac3) 1407 put_bits(&s->pb, 1, 0); 1408 1409 /* channel coupling */ 1410 if (!s->eac3) 1411 put_bits(&s->pb, 1, block->new_cpl_strategy); 1412 if (block->new_cpl_strategy) { 1413 if (!s->eac3) 1414 put_bits(&s->pb, 1, block->cpl_in_use); 1415 if (block->cpl_in_use) { 1416 int start_sub, end_sub; 1417 if (s->eac3) 1418 put_bits(&s->pb, 1, 0); /* enhanced coupling */ 1419 if (!s->eac3 || s->channel_mode != AC3_CHMODE_STEREO) { 1420 for (ch = 1; ch <= s->fbw_channels; ch++) 1421 put_bits(&s->pb, 1, block->channel_in_cpl[ch]); 1422 } 1423 if (s->channel_mode == AC3_CHMODE_STEREO) 1424 put_bits(&s->pb, 1, 0); /* phase flags in use */ 1425 start_sub = (s->start_freq[CPL_CH] - 37) / 12; 1426 end_sub = (s->cpl_end_freq - 37) / 12; 1427 put_bits(&s->pb, 4, start_sub); 1428 put_bits(&s->pb, 4, end_sub - 3); 1429 /* coupling band structure */ 1430 if (s->eac3) { 1431 put_bits(&s->pb, 1, 0); /* use default */ 1432 } else { 1433 for (bnd = start_sub+1; bnd < end_sub; bnd++) 1434 put_bits(&s->pb, 1, ff_eac3_default_cpl_band_struct[bnd]); 1435 } 1436 } 1437 } 1438 1439 /* coupling coordinates */ 1440 if (block->cpl_in_use) { 1441 for (ch = 1; ch <= s->fbw_channels; ch++) { 1442 if (block->channel_in_cpl[ch]) { 1443 if (!s->eac3 || block->new_cpl_coords[ch] != 2) 1444 put_bits(&s->pb, 1, block->new_cpl_coords[ch]); 1445 if (block->new_cpl_coords[ch]) { 1446 put_bits(&s->pb, 2, block->cpl_master_exp[ch]); 1447 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { 1448 put_bits(&s->pb, 4, block->cpl_coord_exp [ch][bnd]); 1449 put_bits(&s->pb, 4, block->cpl_coord_mant[ch][bnd]); 1450 } 1451 } 1452 } 1453 } 1454 } 1455 1456 /* stereo rematrixing */ 1457 if (s->channel_mode == AC3_CHMODE_STEREO) { 1458 if (!s->eac3 || blk > 0) 1459 put_bits(&s->pb, 1, block->new_rematrixing_strategy); 1460 if (block->new_rematrixing_strategy) { 1461 /* rematrixing flags */ 1462 for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) 1463 put_bits(&s->pb, 1, block->rematrixing_flags[bnd]); 1464 } 1465 } 1466 1467 /* exponent strategy */ 1468 if (!s->eac3) { 1469 for (ch = !block->cpl_in_use; ch <= s->fbw_channels; ch++) 1470 put_bits(&s->pb, 2, s->exp_strategy[ch][blk]); 1471 if (s->lfe_on) 1472 put_bits(&s->pb, 1, s->exp_strategy[s->lfe_channel][blk]); 1473 } 1474 1475 /* bandwidth */ 1476 for (ch = 1; ch <= s->fbw_channels; ch++) { 1477 if (s->exp_strategy[ch][blk] != EXP_REUSE && !block->channel_in_cpl[ch]) 1478 put_bits(&s->pb, 6, s->bandwidth_code); 1479 } 1480 1481 /* exponents */ 1482 for (ch = !block->cpl_in_use; ch <= s->channels; ch++) { 1483 int nb_groups; 1484 int cpl = (ch == CPL_CH); 1485 1486 if (s->exp_strategy[ch][blk] == EXP_REUSE) 1487 continue; 1488 1489 /* DC exponent */ 1490 put_bits(&s->pb, 4, block->grouped_exp[ch][0] >> cpl); 1491 1492 /* exponent groups */ 1493 nb_groups = exponent_group_tab[cpl][s->exp_strategy[ch][blk]-1][block->end_freq[ch]-s->start_freq[ch]]; 1494 for (i = 1; i <= nb_groups; i++) 1495 put_bits(&s->pb, 7, block->grouped_exp[ch][i]); 1496 1497 /* gain range info */ 1498 if (ch != s->lfe_channel && !cpl) 1499 put_bits(&s->pb, 2, 0); 1500 } 1501 1502 /* bit allocation info */ 1503 if (!s->eac3) { 1504 baie = (blk == 0); 1505 put_bits(&s->pb, 1, baie); 1506 if (baie) { 1507 put_bits(&s->pb, 2, s->slow_decay_code); 1508 put_bits(&s->pb, 2, s->fast_decay_code); 1509 put_bits(&s->pb, 2, s->slow_gain_code); 1510 put_bits(&s->pb, 2, s->db_per_bit_code); 1511 put_bits(&s->pb, 3, s->floor_code); 1512 } 1513 } 1514 1515 /* snr offset */ 1516 if (!s->eac3) { 1517 put_bits(&s->pb, 1, block->new_snr_offsets); 1518 if (block->new_snr_offsets) { 1519 put_bits(&s->pb, 6, s->coarse_snr_offset); 1520 for (ch = !block->cpl_in_use; ch <= s->channels; ch++) { 1521 put_bits(&s->pb, 4, s->fine_snr_offset[ch]); 1522 put_bits(&s->pb, 3, s->fast_gain_code[ch]); 1523 } 1524 } 1525 } else { 1526 put_bits(&s->pb, 1, 0); /* no converter snr offset */ 1527 } 1528 1529 /* coupling leak */ 1530 if (block->cpl_in_use) { 1531 if (!s->eac3 || block->new_cpl_leak != 2) 1532 put_bits(&s->pb, 1, block->new_cpl_leak); 1533 if (block->new_cpl_leak) { 1534 put_bits(&s->pb, 3, s->bit_alloc.cpl_fast_leak); 1535 put_bits(&s->pb, 3, s->bit_alloc.cpl_slow_leak); 1536 } 1537 } 1538 1539…
Large files files are truncated, but you can click here to view the full file