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

   1 /*
   2  * Copyright (C) 2016 foo86
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #define BITSTREAM_READER_LE
  22
  23 #include "libavutil/channel_layout.h"
  24 #include "libavutil/mem_internal.h"
  25
  26 #include "dcadec.h"
  27 #include "dcadata.h"
  28 #include "dcahuff.h"
  29 #include "dca_syncwords.h"
  30 #include "bytestream.h"
  31
  32 #define AMP_MAX     56
  33
  34 enum LBRFlags {
  35     LBR_FLAG_24_BIT             = 0x01,
  36     LBR_FLAG_LFE_PRESENT        = 0x02,
  37     LBR_FLAG_BAND_LIMIT_2_3     = 0x04,
  38     LBR_FLAG_BAND_LIMIT_1_2     = 0x08,
  39     LBR_FLAG_BAND_LIMIT_1_3     = 0x0c,
  40     LBR_FLAG_BAND_LIMIT_1_4     = 0x10,
  41     LBR_FLAG_BAND_LIMIT_1_8     = 0x18,
  42     LBR_FLAG_BAND_LIMIT_NONE    = 0x14,
  43     LBR_FLAG_BAND_LIMIT_MASK    = 0x1c,
  44     LBR_FLAG_DMIX_STEREO        = 0x20,
  45     LBR_FLAG_DMIX_MULTI_CH      = 0x40
  46 };
  47
  48 enum LBRChunkTypes {
  49     LBR_CHUNK_NULL              = 0x00,
  50     LBR_CHUNK_PAD               = 0x01,
  51     LBR_CHUNK_FRAME             = 0x04,
  52     LBR_CHUNK_FRAME_NO_CSUM     = 0x06,
  53     LBR_CHUNK_LFE               = 0x0a,
  54     LBR_CHUNK_ECS               = 0x0b,
  55     LBR_CHUNK_RESERVED_1        = 0x0c,
  56     LBR_CHUNK_RESERVED_2        = 0x0d,
  57     LBR_CHUNK_SCF               = 0x0e,
  58     LBR_CHUNK_TONAL             = 0x10,
  59     LBR_CHUNK_TONAL_GRP_1       = 0x11,
  60     LBR_CHUNK_TONAL_GRP_2       = 0x12,
  61     LBR_CHUNK_TONAL_GRP_3       = 0x13,
  62     LBR_CHUNK_TONAL_GRP_4       = 0x14,
  63     LBR_CHUNK_TONAL_GRP_5       = 0x15,
  64     LBR_CHUNK_TONAL_SCF         = 0x16,
  65     LBR_CHUNK_TONAL_SCF_GRP_1   = 0x17,
  66     LBR_CHUNK_TONAL_SCF_GRP_2   = 0x18,
  67     LBR_CHUNK_TONAL_SCF_GRP_3   = 0x19,
  68     LBR_CHUNK_TONAL_SCF_GRP_4   = 0x1a,
  69     LBR_CHUNK_TONAL_SCF_GRP_5   = 0x1b,
  70     LBR_CHUNK_RES_GRID_LR       = 0x30,
  71     LBR_CHUNK_RES_GRID_LR_LAST  = 0x3f,
  72     LBR_CHUNK_RES_GRID_HR       = 0x40,
  73     LBR_CHUNK_RES_GRID_HR_LAST  = 0x4f,
  74     LBR_CHUNK_RES_TS_1          = 0x50,
  75     LBR_CHUNK_RES_TS_1_LAST     = 0x5f,
  76     LBR_CHUNK_RES_TS_2          = 0x60,
  77     LBR_CHUNK_RES_TS_2_LAST     = 0x6f,
  78     LBR_CHUNK_EXTENSION         = 0x7f
  79 };
  80
  81 typedef struct LBRChunk {
  82     int id, len;
  83     const uint8_t *data;
  84 } LBRChunk;
  85
  86 static const int8_t channel_reorder_nolfe[7][5] = {
  87     { 0, -1, -1, -1, -1 },  // C
  88     { 0,  1, -1, -1, -1 },  // LR
  89     { 0,  1,  2, -1, -1 },  // LR C
  90     { 0,  1, -1, -1, -1 },  // LsRs
  91     { 1,  2,  0, -1, -1 },  // LsRs C
  92     { 0,  1,  2,  3, -1 },  // LR LsRs
  93     { 0,  1,  3,  4,  2 },  // LR LsRs C
  94 };
  95
  96 static const int8_t channel_reorder_lfe[7][5] = {
  97     { 0, -1, -1, -1, -1 },  // C
  98     { 0,  1, -1, -1, -1 },  // LR
  99     { 0,  1,  2, -1, -1 },  // LR C
 100     { 1,  2, -1, -1, -1 },  // LsRs
 101     { 2,  3,  0, -1, -1 },  // LsRs C
 102     { 0,  1,  3,  4, -1 },  // LR LsRs
 103     { 0,  1,  4,  5,  2 },  // LR LsRs C
 104 };
 105
 106 static const uint8_t lfe_index[7] = {
 107     1, 2, 3, 0, 1, 2, 3
 108 };
 109
 110 static const uint8_t channel_counts[7] = {
 111     1, 2, 3, 2, 3, 4, 5
 112 };
 113
 114 static const uint16_t channel_layouts[7] = {
 115     AV_CH_LAYOUT_MONO,
 116     AV_CH_LAYOUT_STEREO,
 117     AV_CH_LAYOUT_SURROUND,
 118     AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,
 119     AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,
 120     AV_CH_LAYOUT_2_2,
 121     AV_CH_LAYOUT_5POINT0
 122 };
 123
 124 static float    cos_tab[256];
 125 static float    lpc_tab[16];
 126
 127 static av_cold void init_tables(void)
 128 {
 129     static int initialized;
 130     int i;
 131
 132     if (initialized)
 133         return;
 134
 135     for (i = 0; i < 256; i++)
 136         cos_tab[i] = cos(M_PI * i / 128);
 137
 138     for (i = 0; i < 16; i++)
 139         lpc_tab[i] = sin((i - 8) * (M_PI / ((i < 8) ? 17 : 15)));
 140
 141     initialized = 1;
 142 }
 143
 144 static int parse_lfe_24(DCALbrDecoder *s)
 145 {
 146     int step_max = FF_ARRAY_ELEMS(ff_dca_lfe_step_size_24) - 1;
 147     int i, ps, si, code, step_i;
 148     float step, value, delta;
 149
 150     ps = get_bits(&s->gb, 24);
 151     si = ps >> 23;
 152
 153     value = (((ps & 0x7fffff) ^ -si) + si) * (1.0f / 0x7fffff);
 154
 155     step_i = get_bits(&s->gb, 8);
 156     if (step_i > step_max) {
 157         av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE step size index\n");
 158         return AVERROR_INVALIDDATA;
 159     }
 160
 161     step = ff_dca_lfe_step_size_24[step_i];
 162
 163     for (i = 0; i < 64; i++) {
 164         code = get_bits(&s->gb, 6);
 165
 166         delta = step * 0.03125f;
 167         if (code & 16)
 168             delta += step;
 169         if (code & 8)
 170             delta += step * 0.5f;
 171         if (code & 4)
 172             delta += step * 0.25f;
 173         if (code & 2)
 174             delta += step * 0.125f;
 175         if (code & 1)
 176             delta += step * 0.0625f;
 177
 178         if (code & 32) {
 179             value -= delta;
 180             if (value < -3.0f)
 181                 value = -3.0f;
 182         } else {
 183             value += delta;
 184             if (value > 3.0f)
 185                 value = 3.0f;
 186         }
 187
 188         step_i += ff_dca_lfe_delta_index_24[code & 31];
 189         step_i = av_clip(step_i, 0, step_max);
 190
 191         step = ff_dca_lfe_step_size_24[step_i];
 192         s->lfe_data[i] = value * s->lfe_scale;
 193     }
 194
 195     return 0;
 196 }
 197
 198 static int parse_lfe_16(DCALbrDecoder *s)
 199 {
 200     int step_max = FF_ARRAY_ELEMS(ff_dca_lfe_step_size_16) - 1;
 201     int i, ps, si, code, step_i;
 202     float step, value, delta;
 203
 204     ps = get_bits(&s->gb, 16);
 205     si = ps >> 15;
 206
 207     value = (((ps & 0x7fff) ^ -si) + si) * (1.0f / 0x7fff);
 208
 209     step_i = get_bits(&s->gb, 8);
 210     if (step_i > step_max) {
 211         av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE step size index\n");
 212         return AVERROR_INVALIDDATA;
 213     }
 214
 215     step = ff_dca_lfe_step_size_16[step_i];
 216
 217     for (i = 0; i < 64; i++) {
 218         code = get_bits(&s->gb, 4);
 219
 220         delta = step * 0.125f;
 221         if (code & 4)
 222             delta += step;
 223         if (code & 2)
 224             delta += step * 0.5f;
 225         if (code & 1)
 226             delta += step * 0.25f;
 227
 228         if (code & 8) {
 229             value -= delta;
 230             if (value < -3.0f)
 231                 value = -3.0f;
 232         } else {
 233             value += delta;
 234             if (value > 3.0f)
 235                 value = 3.0f;
 236         }
 237
 238         step_i += ff_dca_lfe_delta_index_16[code & 7];
 239         step_i = av_clip(step_i, 0, step_max);
 240
 241         step = ff_dca_lfe_step_size_16[step_i];
 242         s->lfe_data[i] = value * s->lfe_scale;
 243     }
 244
 245     return 0;
 246 }
 247
 248 static int parse_lfe_chunk(DCALbrDecoder *s, LBRChunk *chunk)
 249 {
 250     int ret;
 251
 252     if (!(s->flags & LBR_FLAG_LFE_PRESENT))
 253         return 0;
 254
 255     if (!chunk->len)
 256         return 0;
 257
 258     ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
 259     if (ret < 0)
 260         return ret;
 261
 262     // Determine bit depth from chunk size
 263     if (chunk->len >= 52)
 264         return parse_lfe_24(s);
 265     if (chunk->len >= 35)
 266         return parse_lfe_16(s);
 267
 268     av_log(s->avctx, AV_LOG_ERROR, "LFE chunk too short\n");
 269     return AVERROR_INVALIDDATA;
 270 }
 271
 272 static inline int parse_vlc(GetBitContext *s, VLC *vlc, int max_depth)
 273 {
 274     int v = get_vlc2(s, vlc->table, vlc->bits, max_depth);
 275     if (v > 0)
 276         return v - 1;
 277     // Rare value
 278     return get_bits(s, get_bits(s, 3) + 1);
 279 }
 280
 281 static int parse_tonal(DCALbrDecoder *s, int group)
 282 {
 283     unsigned int amp[DCA_LBR_CHANNELS_TOTAL];
 284     unsigned int phs[DCA_LBR_CHANNELS_TOTAL];
 285     unsigned int diff, main_amp, shift;
 286     int sf, sf_idx, ch, main_ch, freq;
 287     int ch_nbits = av_ceil_log2(s->nchannels_total);
 288
 289     // Parse subframes for this group
 290     for (sf = 0; sf < 1 << group; sf += diff ? 8 : 1) {
 291         sf_idx = ((s->framenum << group) + sf) & 31;
 292         s->tonal_bounds[group][sf_idx][0] = s->ntones;
 293
 294         // Parse tones for this subframe
 295         for (freq = 1;; freq++) {
 296             if (get_bits_left(&s->gb) < 1) {
 297                 av_log(s->avctx, AV_LOG_ERROR, "Tonal group chunk too short\n");
 298                 return AVERROR_INVALIDDATA;
 299             }
 300
 301             diff = parse_vlc(&s->gb, &ff_dca_vlc_tnl_grp[group], 2);
 302             if (diff >= FF_ARRAY_ELEMS(ff_dca_fst_amp)) {
 303                 av_log(s->avctx, AV_LOG_ERROR, "Invalid tonal frequency diff\n");
 304                 return AVERROR_INVALIDDATA;
 305             }
 306
 307             diff = get_bitsz(&s->gb, diff >> 2) + ff_dca_fst_amp[diff];
 308             if (diff <= 1)
 309                 break;  // End of subframe
 310
 311             freq += diff - 2;
 312             if (freq >> (5 - group) > s->nsubbands * 4 - 6) {
 313                 av_log(s->avctx, AV_LOG_ERROR, "Invalid spectral line offset\n");
 314                 return AVERROR_INVALIDDATA;
 315             }
 316
 317             // Main channel
 318             main_ch = get_bitsz(&s->gb, ch_nbits);
 319             main_amp = parse_vlc(&s->gb, &ff_dca_vlc_tnl_scf, 2)
 320                 + s->tonal_scf[ff_dca_freq_to_sb[freq >> (7 - group)]]
 321                 + s->limited_range - 2;
 322             amp[main_ch] = main_amp < AMP_MAX ? main_amp : 0;
 323             phs[main_ch] = get_bits(&s->gb, 3);
 324
 325             // Secondary channels
 326             for (ch = 0; ch < s->nchannels_total; ch++) {
 327                 if (ch == main_ch)
 328                     continue;
 329                 if (get_bits1(&s->gb)) {
 330                     amp[ch] = amp[main_ch] - parse_vlc(&s->gb, &ff_dca_vlc_damp, 1);
 331                     phs[ch] = phs[main_ch] - parse_vlc(&s->gb, &ff_dca_vlc_dph,  1);
 332                 } else {
 333                     amp[ch] = 0;
 334                     phs[ch] = 0;
 335                 }
 336             }
 337
 338             if (amp[main_ch]) {
 339                 // Allocate new tone
 340                 DCALbrTone *t = &s->tones[s->ntones];
 341                 s->ntones = (s->ntones + 1) & (DCA_LBR_TONES - 1);
 342
 343                 t->x_freq = freq >> (5 - group);
 344                 t->f_delt = (freq & ((1 << (5 - group)) - 1)) << group;
 345                 t->ph_rot = 256 - (t->x_freq & 1) * 128 - t->f_delt * 4;
 346
 347                 shift = ff_dca_ph0_shift[(t->x_freq & 3) * 2 + (freq & 1)]
 348                     - ((t->ph_rot << (5 - group)) - t->ph_rot);
 349
 350                 for (ch = 0; ch < s->nchannels; ch++) {
 351                     t->amp[ch] = amp[ch] < AMP_MAX ? amp[ch] : 0;
 352                     t->phs[ch] = 128 - phs[ch] * 32 + shift;
 353                 }
 354             }
 355         }
 356
 357         s->tonal_bounds[group][sf_idx][1] = s->ntones;
 358     }
 359
 360     return 0;
 361 }
 362
 363 static int parse_tonal_chunk(DCALbrDecoder *s, LBRChunk *chunk)
 364 {
 365     int sb, group, ret;
 366
 367     if (!chunk->len)
 368         return 0;
 369
 370     ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
 371
 372     if (ret < 0)
 373         return ret;
 374
 375     // Scale factors
 376     if (chunk->id == LBR_CHUNK_SCF || chunk->id == LBR_CHUNK_TONAL_SCF) {
 377         if (get_bits_left(&s->gb) < 36) {
 378             av_log(s->avctx, AV_LOG_ERROR, "Tonal scale factor chunk too short\n");
 379             return AVERROR_INVALIDDATA;
 380         }
 381         for (sb = 0; sb < 6; sb++)
 382             s->tonal_scf[sb] = get_bits(&s->gb, 6);
 383     }
 384
 385     // Tonal groups
 386     if (chunk->id == LBR_CHUNK_TONAL || chunk->id == LBR_CHUNK_TONAL_SCF)
 387         for (group = 0; group < 5; group++) {
 388             ret = parse_tonal(s, group);
 389             if (ret < 0)
 390                 return ret;
 391         }
 392
 393     return 0;
 394 }
 395
 396 static int parse_tonal_group(DCALbrDecoder *s, LBRChunk *chunk)
 397 {
 398     int ret;
 399
 400     if (!chunk->len)
 401         return 0;
 402
 403     ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
 404     if (ret < 0)
 405         return ret;
 406
 407     return parse_tonal(s, chunk->id);
 408 }
 409
 410 /**
 411  * Check point to ensure that enough bits are left. Aborts decoding
 412  * by skipping to the end of chunk otherwise.
 413  */
 414 static int ensure_bits(GetBitContext *s, int n)
 415 {
 416     int left = get_bits_left(s);
 417     if (left < 0)
 418         return AVERROR_INVALIDDATA;
 419     if (left < n) {
 420         skip_bits_long(s, left);
 421         return 1;
 422     }
 423     return 0;
 424 }
 425
 426 static int parse_scale_factors(DCALbrDecoder *s, uint8_t *scf)
 427 {
 428     int i, sf, prev, next, dist;
 429
 430     // Truncated scale factors remain zero
 431     if (ensure_bits(&s->gb, 20))
 432         return 0;
 433
 434     // Initial scale factor
 435     prev = parse_vlc(&s->gb, &ff_dca_vlc_fst_rsd_amp, 2);
 436
 437     for (sf = 0; sf < 7; sf += dist) {
 438         scf[sf] = prev; // Store previous value
 439
 440         if (ensure_bits(&s->gb, 20))
 441             return 0;
 442
 443         // Interpolation distance
 444         dist = parse_vlc(&s->gb, &ff_dca_vlc_rsd_apprx, 1) + 1;
 445         if (dist > 7 - sf) {
 446             av_log(s->avctx, AV_LOG_ERROR, "Invalid scale factor distance\n");
 447             return AVERROR_INVALIDDATA;
 448         }
 449
 450         if (ensure_bits(&s->gb, 20))
 451             return 0;
 452
 453         // Final interpolation point
 454         next = parse_vlc(&s->gb, &ff_dca_vlc_rsd_amp, 2);
 455
 456         if (next & 1)
 457             next = prev + ((next + 1) >> 1);
 458         else
 459             next = prev - ( next      >> 1);
 460
 461         // Interpolate
 462         switch (dist) {
 463         case 2:
 464             if (next > prev)
 465                 scf[sf + 1] = prev + ((next - prev) >> 1);
 466             else
 467                 scf[sf + 1] = prev - ((prev - next) >> 1);
 468             break;
 469
 470         case 4:
 471             if (next > prev) {
 472                 scf[sf + 1] = prev + ( (next - prev)      >> 2);
 473                 scf[sf + 2] = prev + ( (next - prev)      >> 1);
 474                 scf[sf + 3] = prev + (((next - prev) * 3) >> 2);
 475             } else {
 476                 scf[sf + 1] = prev - ( (prev - next)      >> 2);
 477                 scf[sf + 2] = prev - ( (prev - next)      >> 1);
 478                 scf[sf + 3] = prev - (((prev - next) * 3) >> 2);
 479             }
 480             break;
 481
 482         default:
 483             for (i = 1; i < dist; i++)
 484                 scf[sf + i] = prev + (next - prev) * i / dist;
 485             break;
 486         }
 487
 488         prev = next;
 489     }
 490
 491     scf[sf] = next; // Store final value
 492
 493     return 0;
 494 }
 495
 496 static int parse_st_code(GetBitContext *s, int min_v)
 497 {
 498     unsigned int v = parse_vlc(s, &ff_dca_vlc_st_grid, 2) + min_v;
 499
 500     if (v & 1)
 501         v = 16 + (v >> 1);
 502     else
 503         v = 16 - (v >> 1);
 504
 505     if (v >= FF_ARRAY_ELEMS(ff_dca_st_coeff))
 506         v = 16;
 507     return v;
 508 }
 509
 510 static int parse_grid_1_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
 511 {
 512     int ch, sb, sf, nsubbands, ret;
 513
 514     if (!chunk->len)
 515         return 0;
 516
 517     ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
 518     if (ret < 0)
 519         return ret;
 520
 521     // Scale factors
 522     nsubbands = ff_dca_scf_to_grid_1[s->nsubbands - 1] + 1;
 523     for (sb = 2; sb < nsubbands; sb++) {
 524         ret = parse_scale_factors(s, s->grid_1_scf[ch1][sb]);
 525         if (ret < 0)
 526             return ret;
 527         if (ch1 != ch2 && ff_dca_grid_1_to_scf[sb] < s->min_mono_subband) {
 528             ret = parse_scale_factors(s, s->grid_1_scf[ch2][sb]);
 529             if (ret < 0)
 530                 return ret;
 531         }
 532     }
 533
 534     if (get_bits_left(&s->gb) < 1)
 535         return 0;   // Should not happen, but a sample exists that proves otherwise
 536
 537     // Average values for third grid
 538     for (sb = 0; sb < s->nsubbands - 4; sb++) {
 539         s->grid_3_avg[ch1][sb] = parse_vlc(&s->gb, &ff_dca_vlc_avg_g3, 2) - 16;
 540         if (ch1 != ch2) {
 541             if (sb + 4 < s->min_mono_subband)
 542                 s->grid_3_avg[ch2][sb] = parse_vlc(&s->gb, &ff_dca_vlc_avg_g3, 2) - 16;
 543             else
 544                 s->grid_3_avg[ch2][sb] = s->grid_3_avg[ch1][sb];
 545         }
 546     }
 547
 548     if (get_bits_left(&s->gb) < 0) {
 549         av_log(s->avctx, AV_LOG_ERROR, "First grid chunk too short\n");
 550         return AVERROR_INVALIDDATA;
 551     }
 552
 553     // Stereo image for partial mono mode
 554     if (ch1 != ch2) {
 555         int min_v[2];
 556
 557         if (ensure_bits(&s->gb, 8))
 558             return 0;
 559
 560         min_v[0] = get_bits(&s->gb, 4);
 561         min_v[1] = get_bits(&s->gb, 4);
 562
 563         nsubbands = (s->nsubbands - s->min_mono_subband + 3) / 4;
 564         for (sb = 0; sb < nsubbands; sb++)
 565             for (ch = ch1; ch <= ch2; ch++)
 566                 for (sf = 1; sf <= 4; sf++)
 567                     s->part_stereo[ch][sb][sf] = parse_st_code(&s->gb, min_v[ch - ch1]);
 568
 569         if (get_bits_left(&s->gb) >= 0)
 570             s->part_stereo_pres |= 1 << ch1;
 571     }
 572
 573     // Low resolution spatial information is not decoded
 574
 575     return 0;
 576 }
 577
 578 static int parse_grid_1_sec_ch(DCALbrDecoder *s, int ch2)
 579 {
 580     int sb, nsubbands, ret;
 581
 582     // Scale factors
 583     nsubbands = ff_dca_scf_to_grid_1[s->nsubbands - 1] + 1;
 584     for (sb = 2; sb < nsubbands; sb++) {
 585         if (ff_dca_grid_1_to_scf[sb] >= s->min_mono_subband) {
 586             ret = parse_scale_factors(s, s->grid_1_scf[ch2][sb]);
 587             if (ret < 0)
 588                 return ret;
 589         }
 590     }
 591
 592     // Average values for third grid
 593     for (sb = 0; sb < s->nsubbands - 4; sb++) {
 594         if (sb + 4 >= s->min_mono_subband) {
 595             if (ensure_bits(&s->gb, 20))
 596                 return 0;
 597             s->grid_3_avg[ch2][sb] = parse_vlc(&s->gb, &ff_dca_vlc_avg_g3, 2) - 16;
 598         }
 599     }
 600
 601     return 0;
 602 }
 603
 604 static void parse_grid_3(DCALbrDecoder *s, int ch1, int ch2, int sb, int flag)
 605 {
 606     int i, ch;
 607
 608     for (ch = ch1; ch <= ch2; ch++) {
 609         if ((ch != ch1 && sb + 4 >= s->min_mono_subband) != flag)
 610             continue;
 611
 612         if (s->grid_3_pres[ch] & (1U << sb))
 613             continue;   // Already parsed
 614
 615         for (i = 0; i < 8; i++) {
 616             if (ensure_bits(&s->gb, 20))
 617                 return;
 618             s->grid_3_scf[ch][sb][i] = parse_vlc(&s->gb, &ff_dca_vlc_grid_3, 2) - 16;
 619         }
 620
 621         // Flag scale factors for this subband parsed
 622         s->grid_3_pres[ch] |= 1U << sb;
 623     }
 624 }
 625
 626 static float lbr_rand(DCALbrDecoder *s, int sb)
 627 {
 628     s->lbr_rand = 1103515245U * s->lbr_rand + 12345U;
 629     return s->lbr_rand * s->sb_scf[sb];
 630 }
 631
 632 /**
 633  * Parse time samples for one subband, filling truncated samples with randomness
 634  */
 635 static void parse_ch(DCALbrDecoder *s, int ch, int sb, int quant_level, int flag)
 636 {
 637     float *samples = s->time_samples[ch][sb];
 638     int i, j, code, nblocks, coding_method;
 639
 640     if (ensure_bits(&s->gb, 20))
 641         return; // Too few bits left
 642
 643     coding_method = get_bits1(&s->gb);
 644
 645     switch (quant_level) {
 646     case 1:
 647         nblocks = FFMIN(get_bits_left(&s->gb) / 8, DCA_LBR_TIME_SAMPLES / 8);
 648         for (i = 0; i < nblocks; i++, samples += 8) {
 649             code = get_bits(&s->gb, 8);
 650             for (j = 0; j < 8; j++)
 651                 samples[j] = ff_dca_rsd_level_2a[(code >> j) & 1];
 652         }
 653         i = nblocks * 8;
 654         break;
 655
 656     case 2:
 657         if (coding_method) {
 658             for (i = 0; i < DCA_LBR_TIME_SAMPLES && get_bits_left(&s->gb) >= 2; i++) {
 659                 if (get_bits1(&s->gb))
 660                     samples[i] = ff_dca_rsd_level_2b[get_bits1(&s->gb)];
 661                 else
 662                     samples[i] = 0;
 663             }
 664         } else {
 665             nblocks = FFMIN(get_bits_left(&s->gb) / 8, (DCA_LBR_TIME_SAMPLES + 4) / 5);
 666             for (i = 0; i < nblocks; i++, samples += 5) {
 667                 code = ff_dca_rsd_pack_5_in_8[get_bits(&s->gb, 8)];
 668                 for (j = 0; j < 5; j++)
 669                     samples[j] = ff_dca_rsd_level_3[(code >> j * 2) & 3];
 670             }
 671             i = nblocks * 5;
 672         }
 673         break;
 674
 675     case 3:
 676         nblocks = FFMIN(get_bits_left(&s->gb) / 7, (DCA_LBR_TIME_SAMPLES + 2) / 3);
 677         for (i = 0; i < nblocks; i++, samples += 3) {
 678             code = get_bits(&s->gb, 7);
 679             for (j = 0; j < 3; j++)
 680                 samples[j] = ff_dca_rsd_level_5[ff_dca_rsd_pack_3_in_7[code][j]];
 681         }
 682         i = nblocks * 3;
 683         break;
 684
 685     case 4:
 686         for (i = 0; i < DCA_LBR_TIME_SAMPLES && get_bits_left(&s->gb) >= 6; i++)
 687             samples[i] = ff_dca_rsd_level_8[get_vlc2(&s->gb, ff_dca_vlc_rsd.table, 6, 1)];
 688         break;
 689
 690     case 5:
 691         nblocks = FFMIN(get_bits_left(&s->gb) / 4, DCA_LBR_TIME_SAMPLES);
 692         for (i = 0; i < nblocks; i++)
 693             samples[i] = ff_dca_rsd_level_16[get_bits(&s->gb, 4)];
 694         break;
 695
 696     default:
 697         av_assert0(0);
 698     }
 699
 700     if (flag && get_bits_left(&s->gb) < 20)
 701         return; // Skip incomplete mono subband
 702
 703     for (; i < DCA_LBR_TIME_SAMPLES; i++)
 704         s->time_samples[ch][sb][i] = lbr_rand(s, sb);
 705
 706     s->ch_pres[ch] |= 1U << sb;
 707 }
 708
 709 static int parse_ts(DCALbrDecoder *s, int ch1, int ch2,
 710                     int start_sb, int end_sb, int flag)
 711 {
 712     int sb, sb_g3, sb_reorder, quant_level;
 713
 714     for (sb = start_sb; sb < end_sb; sb++) {
 715         // Subband number before reordering
 716         if (sb < 6) {
 717             sb_reorder = sb;
 718         } else if (flag && sb < s->max_mono_subband) {
 719             sb_reorder = s->sb_indices[sb];
 720         } else {
 721             if (ensure_bits(&s->gb, 28))
 722                 break;
 723             sb_reorder = get_bits(&s->gb, s->limited_range + 3);
 724             if (sb_reorder < 6)
 725                 sb_reorder = 6;
 726             s->sb_indices[sb] = sb_reorder;
 727         }
 728         if (sb_reorder >= s->nsubbands)
 729             return AVERROR_INVALIDDATA;
 730
 731         // Third grid scale factors
 732         if (sb == 12) {
 733             for (sb_g3 = 0; sb_g3 < s->g3_avg_only_start_sb - 4; sb_g3++)
 734                 parse_grid_3(s, ch1, ch2, sb_g3, flag);
 735         } else if (sb < 12 && sb_reorder >= 4) {
 736             parse_grid_3(s, ch1, ch2, sb_reorder - 4, flag);
 737         }
 738
 739         // Secondary channel flags
 740         if (ch1 != ch2) {
 741             if (ensure_bits(&s->gb, 20))
 742                 break;
 743             if (!flag || sb_reorder >= s->max_mono_subband)
 744                 s->sec_ch_sbms[ch1 / 2][sb_reorder] = get_bits(&s->gb, 8);
 745             if (flag && sb_reorder >= s->min_mono_subband)
 746                 s->sec_ch_lrms[ch1 / 2][sb_reorder] = get_bits(&s->gb, 8);
 747         }
 748
 749         quant_level = s->quant_levels[ch1 / 2][sb];
 750         if (!quant_level)
 751             return AVERROR_INVALIDDATA;
 752
 753         // Time samples for one or both channels
 754         if (sb < s->max_mono_subband && sb_reorder >= s->min_mono_subband) {
 755             if (!flag)
 756                 parse_ch(s, ch1, sb_reorder, quant_level, 0);
 757             else if (ch1 != ch2)
 758                 parse_ch(s, ch2, sb_reorder, quant_level, 1);
 759         } else {
 760             parse_ch(s, ch1, sb_reorder, quant_level, 0);
 761             if (ch1 != ch2)
 762                 parse_ch(s, ch2, sb_reorder, quant_level, 0);
 763         }
 764     }
 765
 766     return 0;
 767 }
 768
 769 /**
 770  * Convert from reflection coefficients to direct form coefficients
 771  */
 772 static void convert_lpc(float *coeff, const int *codes)
 773 {
 774     int i, j;
 775
 776     for (i = 0; i < 8; i++) {
 777         float rc = lpc_tab[codes[i]];
 778         for (j = 0; j < (i + 1) / 2; j++) {
 779             float tmp1 = coeff[    j    ];
 780             float tmp2 = coeff[i - j - 1];
 781             coeff[    j    ] = tmp1 + rc * tmp2;
 782             coeff[i - j - 1] = tmp2 + rc * tmp1;
 783         }
 784         coeff[i] = rc;
 785     }
 786 }
 787
 788 static int parse_lpc(DCALbrDecoder *s, int ch1, int ch2, int start_sb, int end_sb)
 789 {
 790     int f = s->framenum & 1;
 791     int i, sb, ch, codes[16];
 792
 793     // First two subbands have two sets of coefficients, third subband has one
 794     for (sb = start_sb; sb < end_sb; sb++) {
 795         int ncodes = 8 * (1 + (sb < 2));
 796         for (ch = ch1; ch <= ch2; ch++) {
 797             if (ensure_bits(&s->gb, 4 * ncodes))
 798                 return 0;
 799             for (i = 0; i < ncodes; i++)
 800                 codes[i] = get_bits(&s->gb, 4);
 801             for (i = 0; i < ncodes / 8; i++)
 802                 convert_lpc(s->lpc_coeff[f][ch][sb][i], &codes[i * 8]);
 803         }
 804     }
 805
 806     return 0;
 807 }
 808
 809 static int parse_high_res_grid(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
 810 {
 811     int quant_levels[DCA_LBR_SUBBANDS];
 812     int sb, ch, ol, st, max_sb, profile, ret;
 813
 814     if (!chunk->len)
 815         return 0;
 816
 817     ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
 818     if (ret < 0)
 819         return ret;
 820
 821     // Quantizer profile
 822     profile = get_bits(&s->gb, 8);
 823     // Overall level
 824     ol = (profile >> 3) & 7;
 825     // Steepness
 826     st = profile >> 6;
 827     // Max energy subband
 828     max_sb = profile & 7;
 829
 830     // Calculate quantization levels
 831     for (sb = 0; sb < s->nsubbands; sb++) {
 832         int f = sb * s->limited_rate / s->nsubbands;
 833         int a = 18000 / (12 * f / 1000 + 100 + 40 * st) + 20 * ol;
 834         if (a <= 95)
 835             quant_levels[sb] = 1;
 836         else if (a <= 140)
 837             quant_levels[sb] = 2;
 838         else if (a <= 180)
 839             quant_levels[sb] = 3;
 840         else if (a <= 230)
 841             quant_levels[sb] = 4;
 842         else
 843             quant_levels[sb] = 5;
 844     }
 845
 846     // Reorder quantization levels for lower subbands
 847     for (sb = 0; sb < 8; sb++)
 848         s->quant_levels[ch1 / 2][sb] = quant_levels[ff_dca_sb_reorder[max_sb][sb]];
 849     for (; sb < s->nsubbands; sb++)
 850         s->quant_levels[ch1 / 2][sb] = quant_levels[sb];
 851
 852     // LPC for the first two subbands
 853     ret = parse_lpc(s, ch1, ch2, 0, 2);
 854     if (ret < 0)
 855         return ret;
 856
 857     // Time-samples for the first two subbands of main channel
 858     ret = parse_ts(s, ch1, ch2, 0, 2, 0);
 859     if (ret < 0)
 860         return ret;
 861
 862     // First two bands of the first grid
 863     for (sb = 0; sb < 2; sb++)
 864         for (ch = ch1; ch <= ch2; ch++)
 865             if ((ret = parse_scale_factors(s, s->grid_1_scf[ch][sb])) < 0)
 866                 return ret;
 867
 868     return 0;
 869 }
 870
 871 static int parse_grid_2(DCALbrDecoder *s, int ch1, int ch2,
 872                         int start_sb, int end_sb, int flag)
 873 {
 874     int i, j, sb, ch, nsubbands;
 875
 876     nsubbands = ff_dca_scf_to_grid_2[s->nsubbands - 1] + 1;
 877     if (end_sb > nsubbands)
 878         end_sb = nsubbands;
 879
 880     for (sb = start_sb; sb < end_sb; sb++) {
 881         for (ch = ch1; ch <= ch2; ch++) {
 882             uint8_t *g2_scf = s->grid_2_scf[ch][sb];
 883
 884             if ((ch != ch1 && ff_dca_grid_2_to_scf[sb] >= s->min_mono_subband) != flag) {
 885                 if (!flag)
 886                     memcpy(g2_scf, s->grid_2_scf[ch1][sb], 64);
 887                 continue;
 888             }
 889
 890             // Scale factors in groups of 8
 891             for (i = 0; i < 8; i++, g2_scf += 8) {
 892                 if (get_bits_left(&s->gb) < 1) {
 893                     memset(g2_scf, 0, 64 - i * 8);
 894                     break;
 895                 }
 896                 // Bit indicating if whole group has zero values
 897                 if (get_bits1(&s->gb)) {
 898                     for (j = 0; j < 8; j++) {
 899                         if (ensure_bits(&s->gb, 20))
 900                             break;
 901                         g2_scf[j] = parse_vlc(&s->gb, &ff_dca_vlc_grid_2, 2);
 902                     }
 903                 } else {
 904                     memset(g2_scf, 0, 8);
 905                 }
 906             }
 907         }
 908     }
 909
 910     return 0;
 911 }
 912
 913 static int parse_ts1_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
 914 {
 915     int ret;
 916     if (!chunk->len)
 917         return 0;
 918     if ((ret = init_get_bits8(&s->gb, chunk->data, chunk->len)) < 0)
 919         return ret;
 920     if ((ret = parse_lpc(s, ch1, ch2, 2, 3)) < 0)
 921         return ret;
 922     if ((ret = parse_ts(s, ch1, ch2, 2, 4, 0)) < 0)
 923         return ret;
 924     if ((ret = parse_grid_2(s, ch1, ch2, 0, 1, 0)) < 0)
 925         return ret;
 926     if ((ret = parse_ts(s, ch1, ch2, 4, 6, 0)) < 0)
 927         return ret;
 928     return 0;
 929 }
 930
 931 static int parse_ts2_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
 932 {
 933     int ret;
 934
 935     if (!chunk->len)
 936         return 0;
 937     if ((ret = init_get_bits8(&s->gb, chunk->data, chunk->len)) < 0)
 938         return ret;
 939     if ((ret = parse_grid_2(s, ch1, ch2, 1, 3, 0)) < 0)
 940         return ret;
 941     if ((ret = parse_ts(s, ch1, ch2, 6, s->max_mono_subband, 0)) < 0)
 942         return ret;
 943     if (ch1 != ch2) {
 944         if ((ret = parse_grid_1_sec_ch(s, ch2)) < 0)
 945             return ret;
 946         if ((ret = parse_grid_2(s, ch1, ch2, 0, 3, 1)) < 0)
 947             return ret;
 948     }
 949     if ((ret = parse_ts(s, ch1, ch2, s->min_mono_subband, s->nsubbands, 1)) < 0)
 950         return ret;
 951     return 0;
 952 }
 953
 954 static int init_sample_rate(DCALbrDecoder *s)
 955 {
 956     double scale = (-1.0 / (1 << 17)) * sqrt(1 << (2 - s->limited_range));
 957     int i, br_per_ch = s->bit_rate_scaled / s->nchannels_total;
 958     int ret;
 959
 960     ff_mdct_end(&s->imdct);
 961
 962     ret = ff_mdct_init(&s->imdct, s->freq_range + 6, 1, scale);
 963     if (ret < 0)
 964         return ret;
 965
 966     for (i = 0; i < 32 << s->freq_range; i++)
 967         s->window[i] = ff_dca_long_window[i << (2 - s->freq_range)];
 968
 969     if (br_per_ch < 14000)
 970         scale = 0.85;
 971     else if (br_per_ch < 32000)
 972         scale = (br_per_ch - 14000) * (1.0 / 120000) + 0.85;
 973     else
 974         scale = 1.0;
 975
 976     scale *= 1.0 / INT_MAX;
 977
 978     for (i = 0; i < s->nsubbands; i++) {
 979         if (i < 2)
 980             s->sb_scf[i] = 0;   // The first two subbands are always zero
 981         else if (i < 5)
 982             s->sb_scf[i] = (i - 1) * 0.25 * 0.785 * scale;
 983         else
 984             s->sb_scf[i] = 0.785 * scale;
 985     }
 986
 987     s->lfe_scale = (16 << s->freq_range) * 0.0000078265894;
 988
 989     return 0;
 990 }
 991
 992 static int alloc_sample_buffer(DCALbrDecoder *s)
 993 {
 994     // Reserve space for history and padding
 995     int nchsamples = DCA_LBR_TIME_SAMPLES + DCA_LBR_TIME_HISTORY * 2;
 996     int nsamples = nchsamples * s->nchannels * s->nsubbands;
 997     int ch, sb;
 998     float *ptr;
 999
1000     // Reallocate time sample buffer
1001     av_fast_mallocz(&s->ts_buffer, &s->ts_size, nsamples * sizeof(float));
1002     if (!s->ts_buffer)
1003         return AVERROR(ENOMEM);
1004
1005     ptr = s->ts_buffer + DCA_LBR_TIME_HISTORY;
1006     for (ch = 0; ch < s->nchannels; ch++) {
1007         for (sb = 0; sb < s->nsubbands; sb++) {
1008             s->time_samples[ch][sb] = ptr;
1009             ptr += nchsamples;
1010         }
1011     }
1012
1013     return 0;
1014 }
1015
1016 static int parse_decoder_init(DCALbrDecoder *s, GetByteContext *gb)
1017 {
1018     int old_rate = s->sample_rate;
1019     int old_band_limit = s->band_limit;
1020     int old_nchannels = s->nchannels;
1021     int version, bit_rate_hi;
1022     unsigned int sr_code;
1023
1024     // Sample rate of LBR audio
1025     sr_code = bytestream2_get_byte(gb);
1026     if (sr_code >= FF_ARRAY_ELEMS(ff_dca_sampling_freqs)) {
1027         av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR sample rate\n");
1028         return AVERROR_INVALIDDATA;
1029     }
1030     s->sample_rate = ff_dca_sampling_freqs[sr_code];
1031     if (s->sample_rate > 48000) {
1032         avpriv_report_missing_feature(s->avctx, "%d Hz LBR sample rate", s->sample_rate);
1033         return AVERROR_PATCHWELCOME;
1034     }
1035
1036     // LBR speaker mask
1037     s->ch_mask = bytestream2_get_le16(gb);
1038     if (!(s->ch_mask & 0x7)) {
1039         avpriv_report_missing_feature(s->avctx, "LBR channel mask %#x", s->ch_mask);
1040         return AVERROR_PATCHWELCOME;
1041     }
1042     if ((s->ch_mask & 0xfff0) && !(s->warned & 1)) {
1043         avpriv_report_missing_feature(s->avctx, "LBR channel mask %#x", s->ch_mask);
1044         s->warned |= 1;
1045     }
1046
1047     // LBR bitstream version
1048     version = bytestream2_get_le16(gb);
1049     if ((version & 0xff00) != 0x0800) {
1050         avpriv_report_missing_feature(s->avctx, "LBR stream version %#x", version);
1051         return AVERROR_PATCHWELCOME;
1052     }
1053
1054     // Flags for LBR decoder initialization
1055     s->flags = bytestream2_get_byte(gb);
1056     if (s->flags & LBR_FLAG_DMIX_MULTI_CH) {
1057         avpriv_report_missing_feature(s->avctx, "LBR multi-channel downmix");
1058         return AVERROR_PATCHWELCOME;
1059     }
1060     if ((s->flags & LBR_FLAG_LFE_PRESENT) && s->sample_rate != 48000) {
1061         if (!(s->warned & 2)) {
1062             avpriv_report_missing_feature(s->avctx, "%d Hz LFE interpolation", s->sample_rate);
1063             s->warned |= 2;
1064         }
1065         s->flags &= ~LBR_FLAG_LFE_PRESENT;
1066     }
1067
1068     // Most significant bit rate nibbles
1069     bit_rate_hi = bytestream2_get_byte(gb);
1070
1071     // Least significant original bit rate word
1072     s->bit_rate_orig = bytestream2_get_le16(gb) | ((bit_rate_hi & 0x0F) << 16);
1073
1074     // Least significant scaled bit rate word
1075     s->bit_rate_scaled = bytestream2_get_le16(gb) | ((bit_rate_hi & 0xF0) << 12);
1076
1077     // Setup number of fullband channels
1078     s->nchannels_total = ff_dca_count_chs_for_mask(s->ch_mask & ~DCA_SPEAKER_PAIR_LFE1);
1079     s->nchannels = FFMIN(s->nchannels_total, DCA_LBR_CHANNELS);
1080
1081     // Setup band limit
1082     switch (s->flags & LBR_FLAG_BAND_LIMIT_MASK) {
1083     case LBR_FLAG_BAND_LIMIT_NONE:
1084         s->band_limit = 0;
1085         break;
1086     case LBR_FLAG_BAND_LIMIT_1_2:
1087         s->band_limit = 1;
1088         break;
1089     case LBR_FLAG_BAND_LIMIT_1_4:
1090         s->band_limit = 2;
1091         break;
1092     default:
1093         avpriv_report_missing_feature(s->avctx, "LBR band limit %#x", s->flags & LBR_FLAG_BAND_LIMIT_MASK);
1094         return AVERROR_PATCHWELCOME;
1095     }
1096
1097     // Setup frequency range
1098     s->freq_range = ff_dca_freq_ranges[sr_code];
1099
1100     // Setup resolution profile
1101     if (s->bit_rate_orig >= 44000 * (s->nchannels_total + 2))
1102         s->res_profile = 2;
1103     else if (s->bit_rate_orig >= 25000 * (s->nchannels_total + 2))
1104         s->res_profile = 1;
1105     else
1106         s->res_profile = 0;
1107
1108     // Setup limited sample rate, number of subbands, etc
1109     s->limited_rate = s->sample_rate >> s->band_limit;
1110     s->limited_range = s->freq_range - s->band_limit;
1111     if (s->limited_range < 0) {
1112         av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR band limit for frequency range\n");
1113         return AVERROR_INVALIDDATA;
1114     }
1115
1116     s->nsubbands = 8 << s->limited_range;
1117
1118     s->g3_avg_only_start_sb = s->nsubbands * ff_dca_avg_g3_freqs[s->res_profile] / (s->limited_rate / 2);
1119     if (s->g3_avg_only_start_sb > s->nsubbands)
1120         s->g3_avg_only_start_sb = s->nsubbands;
1121
1122     s->min_mono_subband = s->nsubbands *  2000 / (s->limited_rate / 2);
1123     if (s->min_mono_subband > s->nsubbands)
1124         s->min_mono_subband = s->nsubbands;
1125
1126     s->max_mono_subband = s->nsubbands * 14000 / (s->limited_rate / 2);
1127     if (s->max_mono_subband > s->nsubbands)
1128         s->max_mono_subband = s->nsubbands;
1129
1130     // Handle change of sample rate
1131     if ((old_rate != s->sample_rate || old_band_limit != s->band_limit) && init_sample_rate(s) < 0)
1132         return AVERROR(ENOMEM);
1133
1134     // Setup stereo downmix
1135     if (s->flags & LBR_FLAG_DMIX_STEREO) {
1136         DCAContext *dca = s->avctx->priv_data;
1137
1138         if (s->nchannels_total < 3 || s->nchannels_total > DCA_LBR_CHANNELS_TOTAL - 2) {
1139             av_log(s->avctx, AV_LOG_ERROR, "Invalid number of channels for LBR stereo downmix\n");
1140             return AVERROR_INVALIDDATA;
1141         }
1142
1143         // This decoder doesn't support ECS chunk
1144         if (dca->request_channel_layout != DCA_SPEAKER_LAYOUT_STEREO && !(s->warned & 4)) {
1145             avpriv_report_missing_feature(s->avctx, "Embedded LBR stereo downmix");
1146             s->warned |= 4;
1147         }
1148
1149         // Account for extra downmixed channel pair
1150         s->nchannels_total += 2;
1151         s->nchannels = 2;
1152         s->ch_mask = DCA_SPEAKER_PAIR_LR;
1153         s->flags &= ~LBR_FLAG_LFE_PRESENT;
1154     }
1155
1156     // Handle change of sample rate or number of channels
1157     if (old_rate != s->sample_rate
1158         || old_band_limit != s->band_limit
1159         || old_nchannels != s->nchannels) {
1160         if (alloc_sample_buffer(s) < 0)
1161             return AVERROR(ENOMEM);
1162         ff_dca_lbr_flush(s);
1163     }
1164
1165     return 0;
1166 }
1167
1168 int ff_dca_lbr_parse(DCALbrDecoder *s, uint8_t *data, DCAExssAsset *asset)
1169 {
1170     struct {
1171         LBRChunk    lfe;
1172         LBRChunk    tonal;
1173         LBRChunk    tonal_grp[5];
1174         LBRChunk    grid1[DCA_LBR_CHANNELS / 2];
1175         LBRChunk    hr_grid[DCA_LBR_CHANNELS / 2];
1176         LBRChunk    ts1[DCA_LBR_CHANNELS / 2];
1177         LBRChunk    ts2[DCA_LBR_CHANNELS / 2];
1178     } chunk = { {0} };
1179
1180     GetByteContext gb;
1181
1182     int i, ch, sb, sf, ret, group, chunk_id, chunk_len;
1183
1184     bytestream2_init(&gb, data + asset->lbr_offset, asset->lbr_size);
1185
1186     // LBR sync word
1187     if (bytestream2_get_be32(&gb) != DCA_SYNCWORD_LBR) {
1188         av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR sync word\n");
1189         return AVERROR_INVALIDDATA;
1190     }
1191
1192     // LBR header type
1193     switch (bytestream2_get_byte(&gb)) {
1194     case DCA_LBR_HEADER_SYNC_ONLY:
1195         if (!s->sample_rate) {
1196             av_log(s->avctx, AV_LOG_ERROR, "LBR decoder not initialized\n");
1197             return AVERROR_INVALIDDATA;
1198         }
1199         break;
1200     case DCA_LBR_HEADER_DECODER_INIT:
1201         if ((ret = parse_decoder_init(s, &gb)) < 0) {
1202             s->sample_rate = 0;
1203             return ret;
1204         }
1205         break;
1206     default:
1207         av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR header type\n");
1208         return AVERROR_INVALIDDATA;
1209     }
1210
1211     // LBR frame chunk header
1212     chunk_id = bytestream2_get_byte(&gb);
1213     chunk_len = (chunk_id & 0x80) ? bytestream2_get_be16(&gb) : bytestream2_get_byte(&gb);
1214
1215     if (chunk_len > bytestream2_get_bytes_left(&gb)) {
1216         chunk_len = bytestream2_get_bytes_left(&gb);
1217         av_log(s->avctx, AV_LOG_WARNING, "LBR frame chunk was truncated\n");
1218         if (s->avctx->err_recognition & AV_EF_EXPLODE)
1219             return AVERROR_INVALIDDATA;
1220     }
1221
1222     bytestream2_init(&gb, gb.buffer, chunk_len);
1223
1224     switch (chunk_id & 0x7f) {
1225     case LBR_CHUNK_FRAME:
1226         if (s->avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_CAREFUL)) {
1227             int checksum = bytestream2_get_be16(&gb);
1228             uint16_t res = chunk_id;
1229             res += (chunk_len >> 8) & 0xff;
1230             res += chunk_len & 0xff;
1231             for (i = 0; i < chunk_len - 2; i++)
1232                 res += gb.buffer[i];
1233             if (checksum != res) {
1234                 av_log(s->avctx, AV_LOG_WARNING, "Invalid LBR checksum\n");
1235                 if (s->avctx->err_recognition & AV_EF_EXPLODE)
1236                     return AVERROR_INVALIDDATA;
1237             }
1238         } else {
1239             bytestream2_skip(&gb, 2);
1240         }
1241         break;
1242     case LBR_CHUNK_FRAME_NO_CSUM:
1243         break;
1244     default:
1245         av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR frame chunk ID\n");
1246         return AVERROR_INVALIDDATA;
1247     }
1248
1249     // Clear current frame
1250     memset(s->quant_levels, 0, sizeof(s->quant_levels));
1251     memset(s->sb_indices, 0xff, sizeof(s->sb_indices));
1252     memset(s->sec_ch_sbms, 0, sizeof(s->sec_ch_sbms));
1253     memset(s->sec_ch_lrms, 0, sizeof(s->sec_ch_lrms));
1254     memset(s->ch_pres, 0, sizeof(s->ch_pres));
1255     memset(s->grid_1_scf, 0, sizeof(s->grid_1_scf));
1256     memset(s->grid_2_scf, 0, sizeof(s->grid_2_scf));
1257     memset(s->grid_3_avg, 0, sizeof(s->grid_3_avg));
1258     memset(s->grid_3_scf, 0, sizeof(s->grid_3_scf));
1259     memset(s->grid_3_pres, 0, sizeof(s->grid_3_pres));
1260     memset(s->tonal_scf, 0, sizeof(s->tonal_scf));
1261     memset(s->lfe_data, 0, sizeof(s->lfe_data));
1262     s->part_stereo_pres = 0;
1263     s->framenum = (s->framenum + 1) & 31;
1264
1265     for (ch = 0; ch < s->nchannels; ch++) {
1266         for (sb = 0; sb < s->nsubbands / 4; sb++) {
1267             s->part_stereo[ch][sb][0] = s->part_stereo[ch][sb][4];
1268             s->part_stereo[ch][sb][4] = 16;
1269         }
1270     }
1271
1272     memset(s->lpc_coeff[s->framenum & 1], 0, sizeof(s->lpc_coeff[0]));
1273
1274     for (group = 0; group < 5; group++) {
1275         for (sf = 0; sf < 1 << group; sf++) {
1276             int sf_idx = ((s->framenum << group) + sf) & 31;
1277             s->tonal_bounds[group][sf_idx][0] =
1278             s->tonal_bounds[group][sf_idx][1] = s->ntones;
1279         }
1280     }
1281
1282     // Parse chunk headers
1283     while (bytestream2_get_bytes_left(&gb) > 0) {
1284         chunk_id = bytestream2_get_byte(&gb);
1285         chunk_len = (chunk_id & 0x80) ? bytestream2_get_be16(&gb) : bytestream2_get_byte(&gb);
1286         chunk_id &= 0x7f;
1287
1288         if (chunk_len > bytestream2_get_bytes_left(&gb)) {
1289             chunk_len = bytestream2_get_bytes_left(&gb);
1290             av_log(s->avctx, AV_LOG_WARNING, "LBR chunk %#x was truncated\n", chunk_id);
1291             if (s->avctx->err_recognition & AV_EF_EXPLODE)
1292                 return AVERROR_INVALIDDATA;
1293         }
1294
1295         switch (chunk_id) {
1296         case LBR_CHUNK_LFE:
1297             chunk.lfe.len  = chunk_len;
1298             chunk.lfe.data = gb.buffer;
1299             break;
1300
1301         case LBR_CHUNK_SCF:
1302         case LBR_CHUNK_TONAL:
1303         case LBR_CHUNK_TONAL_SCF:
1304             chunk.tonal.id   = chunk_id;
1305             chunk.tonal.len  = chunk_len;
1306             chunk.tonal.data = gb.buffer;
1307             break;
1308
1309         case LBR_CHUNK_TONAL_GRP_1:
1310         case LBR_CHUNK_TONAL_GRP_2:
1311         case LBR_CHUNK_TONAL_GRP_3:
1312         case LBR_CHUNK_TONAL_GRP_4:
1313         case LBR_CHUNK_TONAL_GRP_5:
1314             i = LBR_CHUNK_TONAL_GRP_5 - chunk_id;
1315             chunk.tonal_grp[i].id   = i;
1316             chunk.tonal_grp[i].len  = chunk_len;
1317             chunk.tonal_grp[i].data = gb.buffer;
1318             break;
1319
1320         case LBR_CHUNK_TONAL_SCF_GRP_1:
1321         case LBR_CHUNK_TONAL_SCF_GRP_2:
1322         case LBR_CHUNK_TONAL_SCF_GRP_3:
1323         case LBR_CHUNK_TONAL_SCF_GRP_4:
1324         case LBR_CHUNK_TONAL_SCF_GRP_5:
1325             i = LBR_CHUNK_TONAL_SCF_GRP_5 - chunk_id;
1326             chunk.tonal_grp[i].id   = i;
1327             chunk.tonal_grp[i].len  = chunk_len;
1328             chunk.tonal_grp[i].data = gb.buffer;
1329             break;
1330
1331         case LBR_CHUNK_RES_GRID_LR:
1332         case LBR_CHUNK_RES_GRID_LR + 1:
1333         case LBR_CHUNK_RES_GRID_LR + 2:
1334             i = chunk_id - LBR_CHUNK_RES_GRID_LR;
1335             chunk.grid1[i].len  = chunk_len;
1336             chunk.grid1[i].data = gb.buffer;
1337             break;
1338
1339         case LBR_CHUNK_RES_GRID_HR:
1340         case LBR_CHUNK_RES_GRID_HR + 1:
1341         case LBR_CHUNK_RES_GRID_HR + 2:
1342             i = chunk_id - LBR_CHUNK_RES_GRID_HR;
1343             chunk.hr_grid[i].len  = chunk_len;
1344             chunk.hr_grid[i].data = gb.buffer;
1345             break;
1346
1347         case LBR_CHUNK_RES_TS_1:
1348         case LBR_CHUNK_RES_TS_1 + 1:
1349         case LBR_CHUNK_RES_TS_1 + 2:
1350             i = chunk_id - LBR_CHUNK_RES_TS_1;
1351             chunk.ts1[i].len  = chunk_len;
1352             chunk.ts1[i].data = gb.buffer;
1353             break;
1354
1355         case LBR_CHUNK_RES_TS_2:
1356         case LBR_CHUNK_RES_TS_2 + 1:
1357         case LBR_CHUNK_RES_TS_2 + 2:
1358             i = chunk_id - LBR_CHUNK_RES_TS_2;
1359             chunk.ts2[i].len  = chunk_len;
1360             chunk.ts2[i].data = gb.buffer;
1361             break;
1362         }
1363
1364         bytestream2_skip(&gb, chunk_len);
1365     }
1366
1367     // Parse the chunks
1368     ret = parse_lfe_chunk(s, &chunk.lfe);
1369
1370     ret |= parse_tonal_chunk(s, &chunk.tonal);
1371
1372     for (i = 0; i < 5; i++)
1373         ret |= parse_tonal_group(s, &chunk.tonal_grp[i]);
1374
1375     for (i = 0; i < (s->nchannels + 1) / 2; i++) {
1376         int ch1 = i * 2;
1377         int ch2 = FFMIN(ch1 + 1, s->nchannels - 1);
1378
1379         if (parse_grid_1_chunk (s, &chunk.grid1  [i], ch1, ch2) < 0 ||
1380             parse_high_res_grid(s, &chunk.hr_grid[i], ch1, ch2) < 0) {
1381             ret = -1;
1382             continue;
1383         }
1384
1385         // TS chunks depend on both grids. TS_2 depends on TS_1.
1386         if (!chunk.grid1[i].len || !chunk.hr_grid[i].len || !chunk.ts1[i].len)
1387             continue;
1388
1389         if (parse_ts1_chunk(s, &chunk.ts1[i], ch1, ch2) < 0 ||
1390             parse_ts2_chunk(s, &chunk.ts2[i], ch1, ch2) < 0) {
1391             ret = -1;
1392             continue;
1393         }
1394     }
1395
1396     if (ret < 0 && (s->avctx->err_recognition & AV_EF_EXPLODE))
1397         return AVERROR_INVALIDDATA;
1398
1399     return 0;
1400 }
1401
1402 /**
1403  * Reconstruct high-frequency resolution grid from first and third grids
1404  */
1405 static void decode_grid(DCALbrDecoder *s, int ch1, int ch2)
1406 {
1407     int i, ch, sb;
1408
1409     for (ch = ch1; ch <= ch2; ch++) {
1410         for (sb = 0; sb < s->nsubbands; sb++) {
1411             int g1_sb = ff_dca_scf_to_grid_1[sb];
1412
1413             uint8_t *g1_scf_a = s->grid_1_scf[ch][g1_sb    ];
1414             uint8_t *g1_scf_b = s->grid_1_scf[ch][g1_sb + 1];
1415
1416             int w1 = ff_dca_grid_1_weights[g1_sb    ][sb];
1417             int w2 = ff_dca_grid_1_weights[g1_sb + 1][sb];
1418
1419             uint8_t *hr_scf = s->high_res_scf[ch][sb];
1420
1421             if (sb < 4) {
1422                 for (i = 0; i < 8; i++) {
1423                     int scf = w1 * g1_scf_a[i] + w2 * g1_scf_b[i];
1424                     hr_scf[i] = scf >> 7;
1425                 }
1426             } else {
1427                 int8_t *g3_scf = s->grid_3_scf[ch][sb - 4];
1428                 int g3_avg = s->grid_3_avg[ch][sb - 4];
1429
1430                 for (i = 0; i < 8; i++) {
1431                     int scf = w1 * g1_scf_a[i] + w2 * g1_scf_b[i];
1432                     hr_scf[i] = (scf >> 7) - g3_avg - g3_scf[i];
1433                 }
1434             }
1435         }
1436     }
1437 }
1438
1439 /**
1440  * Fill unallocated subbands with randomness
1441  */
1442 static void random_ts(DCALbrDecoder *s, int ch1, int ch2)
1443 {
1444     int i, j, k, ch, sb;
1445
1446     for (ch = ch1; ch <= ch2; ch++) {
1447         for (sb = 0; sb < s->nsubbands; sb++) {
1448             float *samples = s->time_samples[ch][sb];
1449
1450             if (s->ch_pres[ch] & (1U << sb))
1451                 continue;   // Skip allocated subband
1452
1453             if (sb < 2) {
1454                 // The first two subbands are always zero
1455                 memset(samples, 0, DCA_LBR_TIME_SAMPLES * sizeof(float));
1456             } else if (sb < 10) {
1457                 for (i = 0; i < DCA_LBR_TIME_SAMPLES; i++)
1458                     samples[i] = lbr_rand(s, sb);
1459             } else {
1460                 for (i = 0; i < DCA_LBR_TIME_SAMPLES / 8; i++, samples += 8) {
1461                     float accum[8] = { 0 };
1462
1463                     // Modulate by subbands 2-5 in blocks of 8
1464                     for (k = 2; k < 6; k++) {
1465                         float *other = &s->time_samples[ch][k][i * 8];
1466                         for (j = 0; j < 8; j++)
1467                             accum[j] += fabs(other[j]);
1468                     }
1469
1470                     for (j = 0; j < 8; j++)
1471                         samples[j] = (accum[j] * 0.25f + 0.5f) * lbr_rand(s, sb);
1472                 }
1473             }
1474         }
1475     }
1476 }
1477
1478 static void predict(float *samples, const float *coeff, int nsamples)
1479 {
1480     int i, j;
1481
1482     for (i = 0; i < nsamples; i++) {
1483         float res = 0;
1484         for (j = 0; j < 8; j++)
1485             res += coeff[j] * samples[i - j - 1];
1486         samples[i] -= res;
1487     }
1488 }
1489
1490 static void synth_lpc(DCALbrDecoder *s, int ch1, int ch2, int sb)
1491 {
1492     int f = s->framenum & 1;
1493     int ch;
1494
1495     for (ch = ch1; ch <= ch2; ch++) {
1496         float *samples = s->time_samples[ch][sb];
1497
1498         if (!(s->ch_pres[ch] & (1U << sb)))
1499             continue;
1500
1501         if (sb < 2) {
1502             predict(samples,      s->lpc_coeff[f^1][ch][sb][1],  16);
1503             predict(samples + 16, s->lpc_coeff[f  ][ch][sb][0],  64);
1504             predict(samples + 80, s->lpc_coeff[f  ][ch][sb][1],  48);
1505         } else {
1506             predict(samples,      s->lpc_coeff[f^1][ch][sb][0],  16);
1507             predict(samples + 16, s->lpc_coeff[f  ][ch][sb][0], 112);
1508         }
1509     }
1510 }
1511
1512 static void filter_ts(DCALbrDecoder *s, int ch1, int ch2)
1513 {
1514     int i, j, sb, ch;
1515
1516     for (sb = 0; sb < s->nsubbands; sb++) {
1517         // Scale factors
1518         for (ch = ch1; ch <= ch2; ch++) {
1519             float *samples = s->time_samples[ch][sb];
1520             uint8_t *hr_scf = s->high_res_scf[ch][sb];
1521             if (sb < 4) {
1522                 for (i = 0; i < DCA_LBR_TIME_SAMPLES / 16; i++, samples += 16) {
1523                     unsigned int scf = hr_scf[i];
1524                     if (scf > AMP_MAX)
1525                         scf = AMP_MAX;
1526                     for (j = 0; j < 16; j++)
1527                         samples[j] *= ff_dca_quant_amp[scf];
1528                 }
1529             } else {
1530                 uint8_t *g2_scf = s->grid_2_scf[ch][ff_dca_scf_to_grid_2[sb]];
1531                 for (i = 0; i < DCA_LBR_TIME_SAMPLES / 2; i++, samples += 2) {
1532                     unsigned int scf = hr_scf[i / 8] - g2_scf[i];
1533                     if (scf > AMP_MAX)
1534                         scf = AMP_MAX;
1535                     samples[0] *= ff_dca_quant_amp[scf];
1536                     samples[1] *= ff_dca_quant_amp[scf];
1537                 }
1538             }
1539         }
1540
1541         // Mid-side stereo
1542         if (ch1 != ch2) {
1543             float *samples_l = s->time_samples[ch1][sb];
1544             float *samples_r = s->time_samples[ch2][sb];
1545             int ch2_pres = s->ch_pres[ch2] & (1U << sb);
1546
1547             for (i = 0; i < DCA_LBR_TIME_SAMPLES / 16; i++) {
1548                 int sbms = (s->sec_ch_sbms[ch1 / 2][sb] >> i) & 1;
1549                 int lrms = (s->sec_ch_lrms[ch1 / 2][sb] >> i) & 1;
1550
1551                 if (sb >= s->min_mono_subband) {
1552                     if (lrms && ch2_pres) {
1553                         if (sbms) {
1554                             for (j = 0; j < 16; j++) {
1555                                 float tmp = samples_l[j];
1556                                 samples_l[j] =  samples_r[j];
1557                                 samples_r[j] = -tmp;
1558                             }
1559                         } else {
1560                             for (j = 0; j < 16; j++) {
1561                                 float tmp = samples_l[j];
1562                                 samples_l[j] =  samples_r[j];
1563                                 samples_r[j] =  tmp;
1564                             }
1565                         }
1566                     } else if (!ch2_pres) {
1567                         if (sbms && (s->part_stereo_pres & (1 << ch1))) {
1568                             for (j = 0; j < 16; j++)
1569                                 samples_r[j] = -samples_l[j];
1570                         } else {
1571                             for (j = 0; j < 16; j++)
1572                                 samples_r[j] =  samples_l[j];
1573                         }
1574                     }
1575                 } else if (sbms && ch2_pres) {
1576                     for (j = 0; j < 16; j++) {
1577                         float tmp = samples_l[j];
1578                         samples_l[j] = (tmp + samples_r[j]) * 0.5f;
1579                         samples_r[j] = (tmp - samples_r[j]) * 0.5f;
1580                     }
1581                 }
1582
1583                 samples_l += 16;
1584                 samples_r += 16;
1585             }
1586         }
1587
1588         // Inverse prediction
1589         if (sb < 3)
1590             synth_lpc(s, ch1, ch2, sb);
1591     }
1592 }
1593
1594 /**
1595  * Modulate by interpolated partial stereo coefficients
1596  */
1597 static void decode_part_stereo(DCALbrDecoder *s, int ch1, int ch2)
1598 {
1599     int i, ch, sb, sf;
1600
1601     for (ch = ch1; ch <= ch2; ch++) {
1602         for (sb = s->min_mono_subband; sb < s->nsubbands; sb++) {
1603             uint8_t *pt_st = s->part_stereo[ch][(sb - s->min_mono_subband) / 4];
1604             float *samples = s->time_samples[ch][sb];
1605
1606             if (s->ch_pres[ch2] & (1U << sb))
1607                 continue;
1608
1609             for (sf = 1; sf <= 4; sf++, samples += 32) {
1610                 float prev = ff_dca_st_coeff[pt_st[sf - 1]];
1611                 float next = ff_dca_st_coeff[pt_st[sf    ]];
1612
1613                 for (i = 0; i < 32; i++)
1614                     samples[i] *= (32 - i) * prev + i * next;
1615             }
1616         }
1617     }
1618 }
1619
1620 /**
1621  * Synthesise tones in the given group for the given tonal subframe
1622  */
1623 static void synth_tones(DCALbrDecoder *s, int ch, float *values,
1624                         int group, int group_sf, int synth_idx)
1625 {
1626     int i, start, count;
1627
1628     if (synth_idx < 0)
1629         return;
1630
1631     start =  s->tonal_bounds[group][group_sf][0];
1632     count = (s->tonal_bounds[group][group_sf][1] - start) & (DCA_LBR_TONES - 1);
1633
1634     for (i = 0; i < count; i++) {
1635         DCALbrTone *t = &s->tones[(start + i) & (DCA_LBR_TONES - 1)];
1636
1637         if (t->amp[ch]) {
1638             float amp = ff_dca_synth_env[synth_idx] * ff_dca_quant_amp[t->amp[ch]];
1639             float c = amp * cos_tab[(t->phs[ch]     ) & 255];
1640             float s = amp * cos_tab[(t->phs[ch] + 64) & 255];
1641             const float *cf = ff_dca_corr_cf[t->f_delt];
1642             int x_freq = t->x_freq;
1643
1644             switch (x_freq) {
1645             case 0:
1646                 goto p0;
1647             case 1:
1648                 values[3] += cf[0] * -s;
1649                 values[2] += cf[1] *  c;
1650                 values[1] += cf[2] *  s;
1651                 values[0] += cf[3] * -c;
1652                 goto p1;
1653             case 2:
1654                 values[2] += cf[0] * -s;
1655                 values[1] += cf[1] *  c;
1656                 values[0] += cf[2] *  s;
1657                 goto p2;
1658             case 3:
1659                 values[1] += cf[0] * -s;
1660                 values[0] += cf[1] *  c;
1661                 goto p3;
1662             case 4:
1663                 values[0] += cf[0] * -s;
1664                 goto p4;
1665             }
1666
1667             values[x_freq - 5] += cf[ 0] * -s;
1668         p4: values[x_freq - 4] += cf[ 1] *  c;
1669         p3: values[x_freq - 3] += cf[ 2] *  s;
1670         p2: values[x_freq - 2] += cf[ 3] * -c;
1671         p1: values[x_freq - 1] += cf[ 4] * -s;
1672         p0: values[x_freq    ] += cf[ 5] *  c;
1673             values[x_freq + 1] += cf[ 6] *  s;
1674             values[x_freq + 2] += cf[ 7] * -c;
1675             values[x_freq + 3] += cf[ 8] * -s;
1676             values[x_freq + 4] += cf[ 9] *  c;
1677             values[x_freq + 5] += cf[10] *  s;
1678         }
1679
1680         t->phs[ch] += t->ph_rot;
1681     }
1682 }
1683
1684 /**
1685  * Synthesise all tones in all groups for the given residual subframe
1686  */
1687 static void base_func_synth(DCALbrDecoder *s, int ch, float *values, int sf)
1688 {
1689     int group;
1690
1691     // Tonal vs residual shift is 22 subframes
1692     for (group = 0; group < 5; group++) {
1693         int group_sf = (s->framenum << group) + ((sf - 22) >> (5 - group));
1694         int synth_idx = ((((sf - 22) & 31) << group) & 31) + (1 << group) - 1;
1695
1696         synth_tones(s, ch, values, group, (group_sf - 1) & 31, 30 - synth_idx);
1697         synth_tones(s, ch, values, group, (group_sf    ) & 31,      synth_idx);
1698     }
1699 }
1700
1701 static void transform_channel(DCALbrDecoder *s, int ch, float *output)
1702 {
1703     LOCAL_ALIGNED_32(float, values, [DCA_LBR_SUBBANDS    ], [4]);
1704     LOCAL_ALIGNED_32(float, result, [DCA_LBR_SUBBANDS * 2], [4]);
1705     int sf, sb, nsubbands = s->nsubbands, noutsubbands = 8 << s->freq_range;
1706
1707     // Clear inactive subbands
1708     if (nsubbands < noutsubbands)
1709         memset(values[nsubbands], 0, (noutsubbands - nsubbands) * sizeof(values[0]));
1710
1711     for (sf = 0; sf < DCA_LBR_TIME_SAMPLES / 4; sf++) {
1712         // Hybrid filterbank
1713         s->dcadsp->lbr_bank(values, s->time_samples[ch],
1714                             ff_dca_bank_coeff, sf * 4, nsubbands);
1715
1716         base_func_synth(s, ch, values[0], sf);
1717
1718         s->imdct.imdct_calc(&s->imdct, result[0], values[0]);
1719
1720         // Long window and overlap-add
1721         s->fdsp->vector_fmul_add(output, result[0], s->window,
1722                                  s->history[ch], noutsubbands * 4);
1723         s->fdsp->vector_fmul_reverse(s->history[ch], result[noutsubbands],
1724                                      s->window, noutsubbands * 4);
1725         output += noutsubbands * 4;
1726     }
1727
1728     // Update history for LPC and forward MDCT
1729     for (sb = 0; sb < nsubbands; sb++) {
1730         float *samples = s->time_samples[ch][sb] - DCA_LBR_TIME_HISTORY;
1731         memcpy(samples, samples + DCA_LBR_TIME_SAMPLES, DCA_LBR_TIME_HISTORY * sizeof(float));
1732     }
1733 }
1734
1735 int ff_dca_lbr_filter_frame(DCALbrDecoder *s, AVFrame *frame)
1736 {
1737     AVCodecContext *avctx = s->avctx;
1738     int i, ret, nchannels, ch_conf = (s->ch_mask & 0x7) - 1;
1739     const int8_t *reorder;
1740
1741     avctx->channel_layout = channel_layouts[ch_conf];
1742     avctx->channels = nchannels = channel_counts[ch_conf];
1743     avctx->sample_rate = s->sample_rate;
1744     avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1745     avctx->bits_per_raw_sample = 0;
1746     avctx->profile = FF_PROFILE_DTS_EXPRESS;
1747     avctx->bit_rate = s->bit_rate_scaled;
1748
1749     if (s->flags & LBR_FLAG_LFE_PRESENT) {
1750         avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1751         avctx->channels++;
1752         reorder = channel_reorder_lfe[ch_conf];
1753     } else {
1754         reorder = channel_reorder_nolfe[ch_conf];
1755     }
1756
1757     frame->nb_samples = 1024 << s->freq_range;
1758     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1759         return ret;
1760
1761     // Filter fullband channels
1762     for (i = 0; i < (s->nchannels + 1) / 2; i++) {
1763         int ch1 = i * 2;
1764         int ch2 = FFMIN(ch1 + 1, s->nchannels - 1);
1765
1766         decode_grid(s, ch1, ch2);
1767
1768         random_ts(s, ch1, ch2);
1769
1770         filter_ts(s, ch1, ch2);
1771
1772         if (ch1 != ch2 && (s->part_stereo_pres & (1 << ch1)))
1773             decode_part_stereo(s, ch1, ch2);
1774
1775         if (ch1 < nchannels)
1776             transform_channel(s, ch1, (float *)frame->extended_data[reorder[ch1]]);
1777
1778         if (ch1 != ch2 && ch2 < nchannels)
1779             transform_channel(s, ch2, (float *)frame->extended_data[reorder[ch2]]);
1780     }
1781
1782     // Interpolate LFE channel
1783     if (s->flags & LBR_FLAG_LFE_PRESENT) {
1784         s->dcadsp->lfe_iir((float *)frame->extended_data[lfe_index[ch_conf]],
1785                            s->lfe_data, ff_dca_lfe_iir,
1786                            s->lfe_history, 16 << s->freq_range);
1787     }
1788
1789     if ((ret = ff_side_data_update_matrix_encoding(frame, AV_MATRIX_ENCODING_NONE)) < 0)
1790         return ret;
1791
1792     return 0;
1793 }
1794
1795 av_cold void ff_dca_lbr_flush(DCALbrDecoder *s)
1796 {
1797     int ch, sb;
1798
1799     if (!s->sample_rate)
1800         return;
1801
1802     // Clear history
1803     memset(s->part_stereo, 16, sizeof(s->part_stereo));
1804     memset(s->lpc_coeff, 0, sizeof(s->lpc_coeff));
1805     memset(s->history, 0, sizeof(s->history));
1806     memset(s->tonal_bounds, 0, sizeof(s->tonal_bounds));
1807     memset(s->lfe_history, 0, sizeof(s->lfe_history));
1808     s->framenum = 0;
1809     s->ntones = 0;
1810
1811     for (ch = 0; ch < s->nchannels; ch++) {
1812         for (sb = 0; sb < s->nsubbands; sb++) {
1813             float *samples = s->time_samples[ch][sb] - DCA_LBR_TIME_HISTORY;
1814             memset(samples, 0, DCA_LBR_TIME_HISTORY * sizeof(float));
1815         }
1816     }
1817 }
1818
1819 av_cold int ff_dca_lbr_init(DCALbrDecoder *s)
1820 {
1821     init_tables();
1822
1823     if (!(s->fdsp = avpriv_float_dsp_alloc(0)))
1824         return AVERROR(ENOMEM);
1825
1826     s->lbr_rand = 1;
1827     return 0;
1828 }
1829
1830 av_cold void ff_dca_lbr_close(DCALbrDecoder *s)
1831 {
1832     s->sample_rate = 0;
1833
1834     av_freep(&s->ts_buffer);
1835     s->ts_size = 0;
1836
1837     av_freep(&s->fdsp);
1838     ff_mdct_end(&s->imdct);
1839 }