git.sesse.net Git - ffmpeg/blob - libavcodec/ac3enc_template.c

   1 /*
   2  * AC-3 encoder float/fixed template
   3  * Copyright (c) 2000 Fabrice Bellard
   4  * Copyright (c) 2006-2011 Justin Ruggles <justin.ruggles@gmail.com>
   5  * Copyright (c) 2006-2010 Prakash Punnoor <prakash@punnoor.de>
   6  *
   7  * This file is part of Libav.
   8  *
   9  * Libav 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  * Libav 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 Libav; 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  * AC-3 encoder float/fixed template
  27  */
  28
  29 #include <stdint.h>
  30
  31 #include "libavutil/internal.h"
  32
  33 /* prototypes for static functions in ac3enc_fixed.c and ac3enc_float.c */
  34
  35 static void scale_coefficients(AC3EncodeContext *s);
  36
  37 static int normalize_samples(AC3EncodeContext *s);
  38
  39 static void clip_coefficients(DSPContext *dsp, CoefType *coef, unsigned int len);
  40
  41 static CoefType calc_cpl_coord(CoefSumType energy_ch, CoefSumType energy_cpl);
  42
  43
  44 int AC3_NAME(allocate_sample_buffers)(AC3EncodeContext *s)
  45 {
  46     int ch;
  47
  48     FF_ALLOC_OR_GOTO(s->avctx, s->windowed_samples, AC3_WINDOW_SIZE *
  49                      sizeof(*s->windowed_samples), alloc_fail);
  50     FF_ALLOC_OR_GOTO(s->avctx, s->planar_samples, s->channels * sizeof(*s->planar_samples),
  51                      alloc_fail);
  52     for (ch = 0; ch < s->channels; ch++) {
  53         FF_ALLOCZ_OR_GOTO(s->avctx, s->planar_samples[ch],
  54                           (AC3_FRAME_SIZE+AC3_BLOCK_SIZE) * sizeof(**s->planar_samples),
  55                           alloc_fail);
  56     }
  57
  58     return 0;
  59 alloc_fail:
  60     return AVERROR(ENOMEM);
  61 }
  62
  63
  64 /*
  65  * Copy input samples.
  66  * Channels are reordered from Libav's default order to AC-3 order.
  67  */
  68 static void copy_input_samples(AC3EncodeContext *s, SampleType **samples)
  69 {
  70     int ch;
  71
  72     /* copy and remap input samples */
  73     for (ch = 0; ch < s->channels; ch++) {
  74         /* copy last 256 samples of previous frame to the start of the current frame */
  75         memcpy(&s->planar_samples[ch][0], &s->planar_samples[ch][AC3_BLOCK_SIZE * s->num_blocks],
  76                AC3_BLOCK_SIZE * sizeof(s->planar_samples[0][0]));
  77
  78         /* copy new samples for current frame */
  79         memcpy(&s->planar_samples[ch][AC3_BLOCK_SIZE],
  80                samples[s->channel_map[ch]],
  81                AC3_BLOCK_SIZE * s->num_blocks * sizeof(s->planar_samples[0][0]));
  82     }
  83 }
  84
  85
  86 /*
  87  * Apply the MDCT to input samples to generate frequency coefficients.
  88  * This applies the KBD window and normalizes the input to reduce precision
  89  * loss due to fixed-point calculations.
  90  */
  91 static void apply_mdct(AC3EncodeContext *s)
  92 {
  93     int blk, ch;
  94
  95     for (ch = 0; ch < s->channels; ch++) {
  96         for (blk = 0; blk < s->num_blocks; blk++) {
  97             AC3Block *block = &s->blocks[blk];
  98             const SampleType *input_samples = &s->planar_samples[ch][blk * AC3_BLOCK_SIZE];
  99
 100 #if CONFIG_AC3ENC_FLOAT
 101             s->fdsp.vector_fmul(s->windowed_samples, input_samples,
 102                                 s->mdct_window, AC3_WINDOW_SIZE);
 103 #else
 104             s->ac3dsp.apply_window_int16(s->windowed_samples, input_samples,
 105                                          s->mdct_window, AC3_WINDOW_SIZE);
 106 #endif
 107
 108             if (s->fixed_point)
 109                 block->coeff_shift[ch+1] = normalize_samples(s);
 110
 111             s->mdct.mdct_calcw(&s->mdct, block->mdct_coef[ch+1],
 112                                s->windowed_samples);
 113         }
 114     }
 115 }
 116
 117
 118 /*
 119  * Calculate coupling channel and coupling coordinates.
 120  */
 121 static void apply_channel_coupling(AC3EncodeContext *s)
 122 {
 123     LOCAL_ALIGNED_16(CoefType, cpl_coords,      [AC3_MAX_BLOCKS], [AC3_MAX_CHANNELS][16]);
 124 #if CONFIG_AC3ENC_FLOAT
 125     LOCAL_ALIGNED_16(int32_t, fixed_cpl_coords, [AC3_MAX_BLOCKS], [AC3_MAX_CHANNELS][16]);
 126 #else
 127     int32_t (*fixed_cpl_coords)[AC3_MAX_CHANNELS][16] = cpl_coords;
 128 #endif
 129     int blk, ch, bnd, i, j;
 130     CoefSumType energy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][16] = {{{0}}};
 131     int cpl_start, num_cpl_coefs;
 132
 133     memset(cpl_coords,       0, AC3_MAX_BLOCKS * sizeof(*cpl_coords));
 134 #if CONFIG_AC3ENC_FLOAT
 135     memset(fixed_cpl_coords, 0, AC3_MAX_BLOCKS * sizeof(*cpl_coords));
 136 #endif
 137
 138     /* align start to 16-byte boundary. align length to multiple of 32.
 139         note: coupling start bin % 4 will always be 1 */
 140     cpl_start     = s->start_freq[CPL_CH] - 1;
 141     num_cpl_coefs = FFALIGN(s->num_cpl_subbands * 12 + 1, 32);
 142     cpl_start     = FFMIN(256, cpl_start + num_cpl_coefs) - num_cpl_coefs;
 143
 144     /* calculate coupling channel from fbw channels */
 145     for (blk = 0; blk < s->num_blocks; blk++) {
 146         AC3Block *block = &s->blocks[blk];
 147         CoefType *cpl_coef = &block->mdct_coef[CPL_CH][cpl_start];
 148         if (!block->cpl_in_use)
 149             continue;
 150         memset(cpl_coef, 0, num_cpl_coefs * sizeof(*cpl_coef));
 151         for (ch = 1; ch <= s->fbw_channels; ch++) {
 152             CoefType *ch_coef = &block->mdct_coef[ch][cpl_start];
 153             if (!block->channel_in_cpl[ch])
 154                 continue;
 155             for (i = 0; i < num_cpl_coefs; i++)
 156                 cpl_coef[i] += ch_coef[i];
 157         }
 158
 159         /* coefficients must be clipped in order to be encoded */
 160         clip_coefficients(&s->dsp, cpl_coef, num_cpl_coefs);
 161     }
 162
 163     /* calculate energy in each band in coupling channel and each fbw channel */
 164     /* TODO: possibly use SIMD to speed up energy calculation */
 165     bnd = 0;
 166     i = s->start_freq[CPL_CH];
 167     while (i < s->cpl_end_freq) {
 168         int band_size = s->cpl_band_sizes[bnd];
 169         for (ch = CPL_CH; ch <= s->fbw_channels; ch++) {
 170             for (blk = 0; blk < s->num_blocks; blk++) {
 171                 AC3Block *block = &s->blocks[blk];
 172                 if (!block->cpl_in_use || (ch > CPL_CH && !block->channel_in_cpl[ch]))
 173                     continue;
 174                 for (j = 0; j < band_size; j++) {
 175                     CoefType v = block->mdct_coef[ch][i+j];
 176                     MAC_COEF(energy[blk][ch][bnd], v, v);
 177                 }
 178             }
 179         }
 180         i += band_size;
 181         bnd++;
 182     }
 183
 184     /* calculate coupling coordinates for all blocks for all channels */
 185     for (blk = 0; blk < s->num_blocks; blk++) {
 186         AC3Block *block  = &s->blocks[blk];
 187         if (!block->cpl_in_use)
 188             continue;
 189         for (ch = 1; ch <= s->fbw_channels; ch++) {
 190             if (!block->channel_in_cpl[ch])
 191                 continue;
 192             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
 193                 cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy[blk][ch][bnd],
 194                                                           energy[blk][CPL_CH][bnd]);
 195             }
 196         }
 197     }
 198
 199     /* determine which blocks to send new coupling coordinates for */
 200     for (blk = 0; blk < s->num_blocks; blk++) {
 201         AC3Block *block  = &s->blocks[blk];
 202         AC3Block *block0 = blk ? &s->blocks[blk-1] : NULL;
 203
 204         memset(block->new_cpl_coords, 0, sizeof(block->new_cpl_coords));
 205
 206         if (block->cpl_in_use) {
 207             /* send new coordinates if this is the first block, if previous
 208              * block did not use coupling but this block does, the channels
 209              * using coupling has changed from the previous block, or the
 210              * coordinate difference from the last block for any channel is
 211              * greater than a threshold value. */
 212             if (blk == 0 || !block0->cpl_in_use) {
 213                 for (ch = 1; ch <= s->fbw_channels; ch++)
 214                     block->new_cpl_coords[ch] = 1;
 215             } else {
 216                 for (ch = 1; ch <= s->fbw_channels; ch++) {
 217                     if (!block->channel_in_cpl[ch])
 218                         continue;
 219                     if (!block0->channel_in_cpl[ch]) {
 220                         block->new_cpl_coords[ch] = 1;
 221                     } else {
 222                         CoefSumType coord_diff = 0;
 223                         for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
 224                             coord_diff += FFABS(cpl_coords[blk-1][ch][bnd] -
 225                                                 cpl_coords[blk  ][ch][bnd]);
 226                         }
 227                         coord_diff /= s->num_cpl_bands;
 228                         if (coord_diff > NEW_CPL_COORD_THRESHOLD)
 229                             block->new_cpl_coords[ch] = 1;
 230                     }
 231                 }
 232             }
 233         }
 234     }
 235
 236     /* calculate final coupling coordinates, taking into account reusing of
 237        coordinates in successive blocks */
 238     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
 239         blk = 0;
 240         while (blk < s->num_blocks) {
 241             int av_uninit(blk1);
 242             AC3Block *block  = &s->blocks[blk];
 243
 244             if (!block->cpl_in_use) {
 245                 blk++;
 246                 continue;
 247             }
 248
 249             for (ch = 1; ch <= s->fbw_channels; ch++) {
 250                 CoefSumType energy_ch, energy_cpl;
 251                 if (!block->channel_in_cpl[ch])
 252                     continue;
 253                 energy_cpl = energy[blk][CPL_CH][bnd];
 254                 energy_ch = energy[blk][ch][bnd];
 255                 blk1 = blk+1;
 256                 while (!s->blocks[blk1].new_cpl_coords[ch] && blk1 < s->num_blocks) {
 257                     if (s->blocks[blk1].cpl_in_use) {
 258                         energy_cpl += energy[blk1][CPL_CH][bnd];
 259                         energy_ch += energy[blk1][ch][bnd];
 260                     }
 261                     blk1++;
 262                 }
 263                 cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy_ch, energy_cpl);
 264             }
 265             blk = blk1;
 266         }
 267     }
 268
 269     /* calculate exponents/mantissas for coupling coordinates */
 270     for (blk = 0; blk < s->num_blocks; blk++) {
 271         AC3Block *block = &s->blocks[blk];
 272         if (!block->cpl_in_use)
 273             continue;
 274
 275 #if CONFIG_AC3ENC_FLOAT
 276         s->ac3dsp.float_to_fixed24(fixed_cpl_coords[blk][1],
 277                                    cpl_coords[blk][1],
 278                                    s->fbw_channels * 16);
 279 #endif
 280         s->ac3dsp.extract_exponents(block->cpl_coord_exp[1],
 281                                     fixed_cpl_coords[blk][1],
 282                                     s->fbw_channels * 16);
 283
 284         for (ch = 1; ch <= s->fbw_channels; ch++) {
 285             int bnd, min_exp, max_exp, master_exp;
 286
 287             if (!block->new_cpl_coords[ch])
 288                 continue;
 289
 290             /* determine master exponent */
 291             min_exp = max_exp = block->cpl_coord_exp[ch][0];
 292             for (bnd = 1; bnd < s->num_cpl_bands; bnd++) {
 293                 int exp = block->cpl_coord_exp[ch][bnd];
 294                 min_exp = FFMIN(exp, min_exp);
 295                 max_exp = FFMAX(exp, max_exp);
 296             }
 297             master_exp = ((max_exp - 15) + 2) / 3;
 298             master_exp = FFMAX(master_exp, 0);
 299             while (min_exp < master_exp * 3)
 300                 master_exp--;
 301             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
 302                 block->cpl_coord_exp[ch][bnd] = av_clip(block->cpl_coord_exp[ch][bnd] -
 303                                                         master_exp * 3, 0, 15);
 304             }
 305             block->cpl_master_exp[ch] = master_exp;
 306
 307             /* quantize mantissas */
 308             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
 309                 int cpl_exp  = block->cpl_coord_exp[ch][bnd];
 310                 int cpl_mant = (fixed_cpl_coords[blk][ch][bnd] << (5 + cpl_exp + master_exp * 3)) >> 24;
 311                 if (cpl_exp == 15)
 312                     cpl_mant >>= 1;
 313                 else
 314                     cpl_mant -= 16;
 315
 316                 block->cpl_coord_mant[ch][bnd] = cpl_mant;
 317             }
 318         }
 319     }
 320
 321     if (CONFIG_EAC3_ENCODER && s->eac3)
 322         ff_eac3_set_cpl_states(s);
 323 }
 324
 325
 326 /*
 327  * Determine rematrixing flags for each block and band.
 328  */
 329 static void compute_rematrixing_strategy(AC3EncodeContext *s)
 330 {
 331     int nb_coefs;
 332     int blk, bnd, i;
 333     AC3Block *block, *block0;
 334
 335     if (s->channel_mode != AC3_CHMODE_STEREO)
 336         return;
 337
 338     for (blk = 0; blk < s->num_blocks; blk++) {
 339         block = &s->blocks[blk];
 340         block->new_rematrixing_strategy = !blk;
 341
 342         block->num_rematrixing_bands = 4;
 343         if (block->cpl_in_use) {
 344             block->num_rematrixing_bands -= (s->start_freq[CPL_CH] <= 61);
 345             block->num_rematrixing_bands -= (s->start_freq[CPL_CH] == 37);
 346             if (blk && block->num_rematrixing_bands != block0->num_rematrixing_bands)
 347                 block->new_rematrixing_strategy = 1;
 348         }
 349         nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]);
 350
 351         if (!s->rematrixing_enabled) {
 352             block0 = block;
 353             continue;
 354         }
 355
 356         for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) {
 357             /* calculate calculate sum of squared coeffs for one band in one block */
 358             int start = ff_ac3_rematrix_band_tab[bnd];
 359             int end   = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);
 360             CoefSumType sum[4] = {0,};
 361             for (i = start; i < end; i++) {
 362                 CoefType lt = block->mdct_coef[1][i];
 363                 CoefType rt = block->mdct_coef[2][i];
 364                 CoefType md = lt + rt;
 365                 CoefType sd = lt - rt;
 366                 MAC_COEF(sum[0], lt, lt);
 367                 MAC_COEF(sum[1], rt, rt);
 368                 MAC_COEF(sum[2], md, md);
 369                 MAC_COEF(sum[3], sd, sd);
 370             }
 371
 372             /* compare sums to determine if rematrixing will be used for this band */
 373             if (FFMIN(sum[2], sum[3]) < FFMIN(sum[0], sum[1]))
 374                 block->rematrixing_flags[bnd] = 1;
 375             else
 376                 block->rematrixing_flags[bnd] = 0;
 377
 378             /* determine if new rematrixing flags will be sent */
 379             if (blk &&
 380                 block->rematrixing_flags[bnd] != block0->rematrixing_flags[bnd]) {
 381                 block->new_rematrixing_strategy = 1;
 382             }
 383         }
 384         block0 = block;
 385     }
 386 }
 387
 388
 389 int AC3_NAME(encode_frame)(AVCodecContext *avctx, AVPacket *avpkt,
 390                            const AVFrame *frame, int *got_packet_ptr)
 391 {
 392     AC3EncodeContext *s = avctx->priv_data;
 393     int ret;
 394
 395     if (s->options.allow_per_frame_metadata) {
 396         ret = ff_ac3_validate_metadata(s);
 397         if (ret)
 398             return ret;
 399     }
 400
 401     if (s->bit_alloc.sr_code == 1 || s->eac3)
 402         ff_ac3_adjust_frame_size(s);
 403
 404     copy_input_samples(s, (SampleType **)frame->extended_data);
 405
 406     apply_mdct(s);
 407
 408     if (s->fixed_point)
 409         scale_coefficients(s);
 410
 411     clip_coefficients(&s->dsp, s->blocks[0].mdct_coef[1],
 412                       AC3_MAX_COEFS * s->num_blocks * s->channels);
 413
 414     s->cpl_on = s->cpl_enabled;
 415     ff_ac3_compute_coupling_strategy(s);
 416
 417     if (s->cpl_on)
 418         apply_channel_coupling(s);
 419
 420     compute_rematrixing_strategy(s);
 421
 422     if (!s->fixed_point)
 423         scale_coefficients(s);
 424
 425     ff_ac3_apply_rematrixing(s);
 426
 427     ff_ac3_process_exponents(s);
 428
 429     ret = ff_ac3_compute_bit_allocation(s);
 430     if (ret) {
 431         av_log(avctx, AV_LOG_ERROR, "Bit allocation failed. Try increasing the bitrate.\n");
 432         return ret;
 433     }
 434
 435     ff_ac3_group_exponents(s);
 436
 437     ff_ac3_quantize_mantissas(s);
 438
 439     if ((ret = ff_alloc_packet(avpkt, s->frame_size))) {
 440         av_log(avctx, AV_LOG_ERROR, "Error getting output packet\n");
 441         return ret;
 442     }
 443     ff_ac3_output_frame(s, avpkt->data);
 444
 445     if (frame->pts != AV_NOPTS_VALUE)
 446         avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->delay);
 447
 448     *got_packet_ptr = 1;
 449     return 0;
 450 }