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#include "libavutil/channel_layout.h" 22#include "dcadec.h" 23#include "dcadata.h" 24#include "dcamath.h" 25#include "dca_syncwords.h" 26#include "internal.h" 27#include "unary.h" 28 29static int get_linear(GetBitContext *gb, int n) 30{ 31 unsigned int v = get_bits_long(gb, n); 32 return (v >> 1) ^ -(v & 1); 33} 34 35static int get_rice_un(GetBitContext *gb, int k) 36{ 37 unsigned int v = get_unary(gb, 1, get_bits_left(gb)); 38 return (v << k) | get_bits_long(gb, k); 39} 40 41static int get_rice(GetBitContext *gb, int k) 42{ 43 unsigned int v = get_rice_un(gb, k); 44 return (v >> 1) ^ -(v & 1); 45} 46 47static void get_array(GetBitContext *gb, int32_t *array, int size, int n) 48{ 49 int i; 50 51 for (i = 0; i < size; i++) 52 array[i] = get_bits(gb, n); 53} 54 55static void get_linear_array(GetBitContext *gb, int32_t *array, int size, int n) 56{ 57 int i; 58 59 if (n == 0) 60 memset(array, 0, sizeof(*array) * size); 61 else for (i = 0; i < size; i++) 62 array[i] = get_linear(gb, n); 63} 64 65static void get_rice_array(GetBitContext *gb, int32_t *array, int size, int k) 66{ 67 int i; 68 69 for (i = 0; i < size; i++) 70 array[i] = get_rice(gb, k); 71} 72 73static int parse_dmix_coeffs(DCAXllDecoder *s, DCAXllChSet *c) 74{ 75 // Size of downmix coefficient matrix 76 int m = c->primary_chset ? ff_dca_dmix_primary_nch[c->dmix_type] : c->hier_ofs; 77 int i, j, *coeff_ptr = c->dmix_coeff; 78 79 for (i = 0; i < m; i++) { 80 int code, sign, coeff, scale, scale_inv = 0; 81 unsigned int index; 82 83 // Downmix scale (only for non-primary channel sets) 84 if (!c->primary_chset) { 85 code = get_bits(&s->gb, 9); 86 sign = (code >> 8) - 1; 87 index = (code & 0xff) - FF_DCA_DMIXTABLE_OFFSET; 88 if (index >= FF_DCA_INV_DMIXTABLE_SIZE) { 89 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL downmix scale index\n"); 90 return AVERROR_INVALIDDATA; 91 } 92 scale = ff_dca_dmixtable[index + FF_DCA_DMIXTABLE_OFFSET]; 93 scale_inv = ff_dca_inv_dmixtable[index]; 94 c->dmix_scale[i] = (scale ^ sign) - sign; 95 c->dmix_scale_inv[i] = (scale_inv ^ sign) - sign; 96 } 97 98 // Downmix coefficients 99 for (j = 0; j < c->nchannels; j++) { 100 code = get_bits(&s->gb, 9); 101 sign = (code >> 8) - 1; 102 index = code & 0xff; 103 if (index >= FF_DCA_DMIXTABLE_SIZE) { 104 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL downmix coefficient index\n"); 105 return AVERROR_INVALIDDATA; 106 } 107 coeff = ff_dca_dmixtable[index]; 108 if (!c->primary_chset) 109 // Multiply by |InvDmixScale| to get |UndoDmixScale| 110 coeff = mul16(scale_inv, coeff); 111 *coeff_ptr++ = (coeff ^ sign) - sign; 112 } 113 } 114 115 return 0; 116} 117 118static int chs_parse_header(DCAXllDecoder *s, DCAXllChSet *c, DCAExssAsset *asset) 119{ 120 int i, j, k, ret, band, header_size, header_pos = get_bits_count(&s->gb); 121 DCAXllChSet *p = &s->chset[0]; 122 DCAXllBand *b; 123 124 // Size of channel set sub-header 125 header_size = get_bits(&s->gb, 10) + 1; 126 127 // Check CRC 128 if (ff_dca_check_crc(s->avctx, &s->gb, header_pos, header_pos + header_size * 8)) { 129 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL sub-header checksum\n"); 130 return AVERROR_INVALIDDATA; 131 } 132 133 // Number of channels in the channel set 134 c->nchannels = get_bits(&s->gb, 4) + 1; 135 if (c->nchannels > DCA_XLL_CHANNELS_MAX) { 136 avpriv_request_sample(s->avctx, "%d XLL channels", c->nchannels); 137 return AVERROR_PATCHWELCOME; 138 } 139 140 // Residual type 141 c->residual_encode = get_bits(&s->gb, c->nchannels); 142 143 // PCM bit resolution 144 c->pcm_bit_res = get_bits(&s->gb, 5) + 1; 145 146 // Storage unit width 147 c->storage_bit_res = get_bits(&s->gb, 5) + 1; 148 if (c->storage_bit_res != 16 && c->storage_bit_res != 20 && c->storage_bit_res != 24) { 149 avpriv_request_sample(s->avctx, "%d-bit XLL storage resolution", c->storage_bit_res); 150 return AVERROR_PATCHWELCOME; 151 } 152 153 if (c->pcm_bit_res > c->storage_bit_res) { 154 av_log(s->avctx, AV_LOG_ERROR, "Invalid PCM bit resolution for XLL channel set (%d > %d)\n", c->pcm_bit_res, c->storage_bit_res); 155 return AVERROR_INVALIDDATA; 156 } 157 158 // Original sampling frequency 159 c->freq = ff_dca_sampling_freqs[get_bits(&s->gb, 4)]; 160 if (c->freq > 192000) { 161 avpriv_request_sample(s->avctx, "%d Hz XLL sampling frequency", c->freq); 162 return AVERROR_PATCHWELCOME; 163 } 164 165 // Sampling frequency modifier 166 if (get_bits(&s->gb, 2)) { 167 avpriv_request_sample(s->avctx, "XLL sampling frequency modifier"); 168 return AVERROR_PATCHWELCOME; 169 } 170 171 // Which replacement set this channel set is member of 172 if (get_bits(&s->gb, 2)) { 173 avpriv_request_sample(s->avctx, "XLL replacement set"); 174 return AVERROR_PATCHWELCOME; 175 } 176 177 if (asset->one_to_one_map_ch_to_spkr) { 178 // Primary channel set flag 179 c->primary_chset = get_bits1(&s->gb); 180 if (c->primary_chset != (c == p)) { 181 av_log(s->avctx, AV_LOG_ERROR, "The first (and only) XLL channel set must be primary\n"); 182 return AVERROR_INVALIDDATA; 183 } 184 185 // Downmix coefficients present in stream 186 c->dmix_coeffs_present = get_bits1(&s->gb); 187 188 // Downmix already performed by encoder 189 c->dmix_embedded = c->dmix_coeffs_present && get_bits1(&s->gb); 190 191 // Downmix type 192 if (c->dmix_coeffs_present && c->primary_chset) { 193 c->dmix_type = get_bits(&s->gb, 3); 194 if (c->dmix_type >= DCA_DMIX_TYPE_COUNT) { 195 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL primary channel set downmix type\n"); 196 return AVERROR_INVALIDDATA; 197 } 198 } 199 200 // Whether the channel set is part of a hierarchy 201 c->hier_chset = get_bits1(&s->gb); 202 if (!c->hier_chset && s->nchsets != 1) { 203 avpriv_request_sample(s->avctx, "XLL channel set outside of hierarchy"); 204 return AVERROR_PATCHWELCOME; 205 } 206 207 // Downmix coefficients 208 if (c->dmix_coeffs_present && (ret = parse_dmix_coeffs(s, c)) < 0) 209 return ret; 210 211 // Channel mask enabled 212 if (!get_bits1(&s->gb)) { 213 avpriv_request_sample(s->avctx, "Disabled XLL channel mask"); 214 return AVERROR_PATCHWELCOME; 215 } 216 217 // Channel mask for set 218 c->ch_mask = get_bits_long(&s->gb, s->ch_mask_nbits); 219 if (av_popcount(c->ch_mask) != c->nchannels) { 220 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL channel mask\n"); 221 return AVERROR_INVALIDDATA; 222 } 223 224 // Build the channel to speaker map 225 for (i = 0, j = 0; i < s->ch_mask_nbits; i++) 226 if (c->ch_mask & (1U << i)) 227 c->ch_remap[j++] = i; 228 } else { 229 // Mapping coeffs present flag 230 if (c->nchannels != 2 || s->nchsets != 1 || get_bits1(&s->gb)) { 231 avpriv_request_sample(s->avctx, "Custom XLL channel to speaker mapping"); 232 return AVERROR_PATCHWELCOME; 233 } 234 235 // Setup for LtRt decoding 236 c->primary_chset = 1; 237 c->dmix_coeffs_present = 0; 238 c->dmix_embedded = 0; 239 c->hier_chset = 0; 240 c->ch_mask = DCA_SPEAKER_LAYOUT_STEREO; 241 c->ch_remap[0] = DCA_SPEAKER_L; 242 c->ch_remap[1] = DCA_SPEAKER_R; 243 } 244 245 if (c->freq > 96000) { 246 // Extra frequency bands flag 247 if (get_bits1(&s->gb)) { 248 avpriv_request_sample(s->avctx, "Extra XLL frequency bands"); 249 return AVERROR_PATCHWELCOME; 250 } 251 c->nfreqbands = 2; 252 } else { 253 c->nfreqbands = 1; 254 } 255 256 // Set the sampling frequency to that of the first frequency band. 257 // Frequency will be doubled again after bands assembly. 258 c->freq >>= c->nfreqbands - 1; 259 260 // Verify that all channel sets have the same audio characteristics 261 if (c != p && (c->nfreqbands != p->nfreqbands || c->freq != p->freq 262 || c->pcm_bit_res != p->pcm_bit_res 263 || c->storage_bit_res != p->storage_bit_res)) { 264 avpriv_request_sample(s->avctx, "Different XLL audio characteristics"); 265 return AVERROR_PATCHWELCOME; 266 } 267 268 // Determine number of bits to read bit allocation coding parameter 269 if (c->storage_bit_res > 16) 270 c->nabits = 5; 271 else if (c->storage_bit_res > 8) 272 c->nabits = 4; 273 else 274 c->nabits = 3; 275 276 // Account for embedded downmix and decimator saturation 277 if ((s->nchsets > 1 || c->nfreqbands > 1) && c->nabits < 5) 278 c->nabits++; 279 280 for (band = 0, b = c->bands; band < c->nfreqbands; band++, b++) { 281 // Pairwise channel decorrelation 282 if ((b->decor_enabled = get_bits1(&s->gb)) && c->nchannels > 1) { 283 int ch_nbits = av_ceil_log2(c->nchannels); 284 285 // Original channel order 286 for (i = 0; i < c->nchannels; i++) { 287 b->orig_order[i] = get_bits(&s->gb, ch_nbits); 288 if (b->orig_order[i] >= c->nchannels) { 289 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL original channel order\n"); 290 return AVERROR_INVALIDDATA; 291 } 292 } 293 294 // Pairwise channel coefficients 295 for (i = 0; i < c->nchannels / 2; i++) 296 b->decor_coeff[i] = get_bits1(&s->gb) ? get_linear(&s->gb, 7) : 0; 297 } else { 298 for (i = 0; i < c->nchannels; i++) 299 b->orig_order[i] = i; 300 for (i = 0; i < c->nchannels / 2; i++) 301 b->decor_coeff[i] = 0; 302 } 303 304 // Adaptive predictor order 305 b->highest_pred_order = 0; 306 for (i = 0; i < c->nchannels; i++) { 307 b->adapt_pred_order[i] = get_bits(&s->gb, 4); 308 if (b->adapt_pred_order[i] > b->highest_pred_order) 309 b->highest_pred_order = b->adapt_pred_order[i]; 310 } 311 if (b->highest_pred_order > s->nsegsamples) { 312 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL adaptive predicition order\n"); 313 return AVERROR_INVALIDDATA; 314 } 315 316 // Fixed predictor order 317 for (i = 0; i < c->nchannels; i++) 318 b->fixed_pred_order[i] = b->adapt_pred_order[i] ? 0 : get_bits(&s->gb, 2); 319 320 // Adaptive predictor quantized reflection coefficients 321 for (i = 0; i < c->nchannels; i++) { 322 for (j = 0; j < b->adapt_pred_order[i]; j++) { 323 k = get_linear(&s->gb, 8); 324 if (k == -128) { 325 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL reflection coefficient index\n"); 326 return AVERROR_INVALIDDATA; 327 } 328 if (k < 0) 329 b->adapt_refl_coeff[i][j] = -(int)ff_dca_xll_refl_coeff[-k]; 330 else 331 b->adapt_refl_coeff[i][j] = (int)ff_dca_xll_refl_coeff[ k]; 332 } 333 } 334 335 // Downmix performed by encoder in extension frequency band 336 b->dmix_embedded = c->dmix_embedded && (band == 0 || get_bits1(&s->gb)); 337 338 // MSB/LSB split flag in extension frequency band 339 if ((band == 0 && s->scalable_lsbs) || (band != 0 && get_bits1(&s->gb))) { 340 // Size of LSB section in any segment 341 b->lsb_section_size = get_bits_long(&s->gb, s->seg_size_nbits); 342 if (b->lsb_section_size < 0 || b->lsb_section_size > s->frame_size) { 343 av_log(s->avctx, AV_LOG_ERROR, "Invalid LSB section size\n"); 344 return AVERROR_INVALIDDATA; 345 } 346 347 // Account for optional CRC bytes after LSB section 348 if (b->lsb_section_size && (s->band_crc_present > 2 || 349 (band == 0 && s->band_crc_present > 1))) 350 b->lsb_section_size += 2; 351 352 // Number of bits to represent the samples in LSB part 353 for (i = 0; i < c->nchannels; i++) { 354 b->nscalablelsbs[i] = get_bits(&s->gb, 4); 355 if (b->nscalablelsbs[i] && !b->lsb_section_size) { 356 av_log(s->avctx, AV_LOG_ERROR, "LSB section missing with non-zero LSB width\n"); 357 return AVERROR_INVALIDDATA; 358 } 359 } 360 } else { 361 b->lsb_section_size = 0; 362 for (i = 0; i < c->nchannels; i++) 363 b->nscalablelsbs[i] = 0; 364 } 365 366 // Scalable resolution flag in extension frequency band 367 if ((band == 0 && s->scalable_lsbs) || (band != 0 && get_bits1(&s->gb))) { 368 // Number of bits discarded by authoring 369 for (i = 0; i < c->nchannels; i++) 370 b->bit_width_adjust[i] = get_bits(&s->gb, 4); 371 } else { 372 for (i = 0; i < c->nchannels; i++) 373 b->bit_width_adjust[i] = 0; 374 } 375 } 376 377 // Reserved 378 // Byte align 379 // CRC16 of channel set sub-header 380 if (ff_dca_seek_bits(&s->gb, header_pos + header_size * 8)) { 381 av_log(s->avctx, AV_LOG_ERROR, "Read past end of XLL sub-header\n"); 382 return AVERROR_INVALIDDATA; 383 } 384 385 return 0; 386} 387 388static int chs_alloc_msb_band_data(DCAXllDecoder *s, DCAXllChSet *c) 389{ 390 int ndecisamples = c->nfreqbands > 1 ? DCA_XLL_DECI_HISTORY_MAX : 0; 391 int nchsamples = s->nframesamples + ndecisamples; 392 int i, j, nsamples = nchsamples * c->nchannels * c->nfreqbands; 393 int32_t *ptr; 394 395 // Reallocate MSB sample buffer 396 av_fast_malloc(&c->sample_buffer[0], &c->sample_size[0], nsamples * sizeof(int32_t)); 397 if (!c->sample_buffer[0]) 398 return AVERROR(ENOMEM); 399 400 ptr = c->sample_buffer[0] + ndecisamples; 401 for (i = 0; i < c->nfreqbands; i++) { 402 for (j = 0; j < c->nchannels; j++) { 403 c->bands[i].msb_sample_buffer[j] = ptr; 404 ptr += nchsamples; 405 } 406 } 407 408 return 0; 409} 410 411static int chs_alloc_lsb_band_data(DCAXllDecoder *s, DCAXllChSet *c) 412{ 413 int i, j, nsamples = 0; 414 int32_t *ptr; 415 416 // Determine number of frequency bands that have MSB/LSB split 417 for (i = 0; i < c->nfreqbands; i++) 418 if (c->bands[i].lsb_section_size) 419 nsamples += s->nframesamples * c->nchannels; 420 if (!nsamples) 421 return 0; 422 423 // Reallocate LSB sample buffer 424 av_fast_malloc(&c->sample_buffer[1], &c->sample_size[1], nsamples * sizeof(int32_t)); 425 if (!c->sample_buffer[1]) 426 return AVERROR(ENOMEM); 427 428 ptr = c->sample_buffer[1]; 429 for (i = 0; i < c->nfreqbands; i++) { 430 if (c->bands[i].lsb_section_size) { 431 for (j = 0; j < c->nchannels; j++) { 432 c->bands[i].lsb_sample_buffer[j] = ptr; 433 ptr += s->nframesamples; 434 } 435 } else { 436 for (j = 0; j < c->nchannels; j++) 437 c->bands[i].lsb_sample_buffer[j] = NULL; 438 } 439 } 440 441 return 0; 442} 443 444static int chs_parse_band_data(DCAXllDecoder *s, DCAXllChSet *c, int band, int seg, int band_data_end) 445{ 446 DCAXllBand *b = &c->bands[band]; 447 int i, j, k; 448 449 // Start unpacking MSB portion of the segment 450 if (!(seg && get_bits1(&s->gb))) { 451 // Unpack segment type 452 // 0 - distinct coding parameters for each channel 453 // 1 - common coding parameters for all channels 454 c->seg_common = get_bits1(&s->gb); 455 456 // Determine number of coding parameters encoded in segment 457 k = c->seg_common ? 1 : c->nchannels; 458 459 // Unpack Rice coding parameters 460 for (i = 0; i < k; i++) { 461 // Unpack Rice coding flag 462 // 0 - linear code, 1 - Rice code 463 c->rice_code_flag[i] = get_bits1(&s->gb); 464 // Unpack Hybrid Rice coding flag 465 // 0 - Rice code, 1 - Hybrid Rice code 466 if (!c->seg_common && c->rice_code_flag[i] && get_bits1(&s->gb)) 467 // Unpack binary code length for isolated samples 468 c->bitalloc_hybrid_linear[i] = get_bits(&s->gb, c->nabits) + 1; 469 else 470 // 0 indicates no Hybrid Rice coding 471 c->bitalloc_hybrid_linear[i] = 0; 472 } 473 474 // Unpack coding parameters 475 for (i = 0; i < k; i++) { 476 if (seg == 0) { 477 // Unpack coding parameter for part A of segment 0 478 c->bitalloc_part_a[i] = get_bits(&s->gb, c->nabits); 479 480 // Adjust for the linear code 481 if (!c->rice_code_flag[i] && c->bitalloc_part_a[i]) 482 c->bitalloc_part_a[i]++; 483 484 if (!c->seg_common) 485 c->nsamples_part_a[i] = b->adapt_pred_order[i]; 486 else 487 c->nsamples_part_a[i] = b->highest_pred_order; 488 } else { 489 c->bitalloc_part_a[i] = 0; 490 c->nsamples_part_a[i] = 0; 491 } 492 493 // Unpack coding parameter for part B of segment 494 c->bitalloc_part_b[i] = get_bits(&s->gb, c->nabits); 495 496 // Adjust for the linear code 497 if (!c->rice_code_flag[i] && c->bitalloc_part_b[i]) 498 c->bitalloc_part_b[i]++; 499 } 500 } 501 502 // Unpack entropy codes 503 for (i = 0; i < c->nchannels; i++) { 504 int32_t *part_a, *part_b; 505 int nsamples_part_b; 506 507 // Select index of coding parameters 508 k = c->seg_common ? 0 : i; 509 510 // Slice the segment into parts A and B 511 part_a = b->msb_sample_buffer[i] + seg * s->nsegsamples; 512 part_b = part_a + c->nsamples_part_a[k]; 513 nsamples_part_b = s->nsegsamples - c->nsamples_part_a[k]; 514 515 if (get_bits_left(&s->gb) < 0) 516 return AVERROR_INVALIDDATA; 517 518 if (!c->rice_code_flag[k]) { 519 // Linear codes 520 // Unpack all residuals of part A of segment 0 521 get_linear_array(&s->gb, part_a, c->nsamples_part_a[k], 522 c->bitalloc_part_a[k]); 523 524 // Unpack all residuals of part B of segment 0 and others 525 get_linear_array(&s->gb, part_b, nsamples_part_b, 526 c->bitalloc_part_b[k]); 527 } else { 528 // Rice codes 529 // Unpack all residuals of part A of segment 0 530 get_rice_array(&s->gb, part_a, c->nsamples_part_a[k], 531 c->bitalloc_part_a[k]); 532 533 if (c->bitalloc_hybrid_linear[k]) { 534 // Hybrid Rice codes 535 // Unpack the number of isolated samples 536 int nisosamples = get_bits(&s->gb, s->nsegsamples_log2); 537 538 // Set all locations to 0 539 memset(part_b, 0, sizeof(*part_b) * nsamples_part_b); 540 541 // Extract the locations of isolated samples and flag by -1 542 for (j = 0; j < nisosamples; j++) { 543 int loc = get_bits(&s->gb, s->nsegsamples_log2); 544 if (loc >= nsamples_part_b) { 545 av_log(s->avctx, AV_LOG_ERROR, "Invalid isolated sample location\n"); 546 return AVERROR_INVALIDDATA; 547 } 548 part_b[loc] = -1; 549 } 550 551 // Unpack all residuals of part B of segment 0 and others 552 for (j = 0; j < nsamples_part_b; j++) { 553 if (part_b[j]) 554 part_b[j] = get_linear(&s->gb, c->bitalloc_hybrid_linear[k]); 555 else 556 part_b[j] = get_rice(&s->gb, c->bitalloc_part_b[k]); 557 } 558 } else { 559 // Rice codes 560 // Unpack all residuals of part B of segment 0 and others 561 get_rice_array(&s->gb, part_b, nsamples_part_b, c->bitalloc_part_b[k]); 562 } 563 } 564 } 565 566 // Unpack decimator history for frequency band 1 567 if (seg == 0 && band == 1) { 568 int nbits = get_bits(&s->gb, 5) + 1; 569 for (i = 0; i < c->nchannels; i++) 570 for (j = 1; j < DCA_XLL_DECI_HISTORY_MAX; j++) 571 c->deci_history[i][j] = get_sbits_long(&s->gb, nbits); 572 } 573 574 // Start unpacking LSB portion of the segment 575 if (b->lsb_section_size) { 576 // Skip to the start of LSB portion 577 if (ff_dca_seek_bits(&s->gb, band_data_end - b->lsb_section_size * 8)) { 578 av_log(s->avctx, AV_LOG_ERROR, "Read past end of XLL band data\n"); 579 return AVERROR_INVALIDDATA; 580 } 581 582 // Unpack all LSB parts of residuals of this segment 583 for (i = 0; i < c->nchannels; i++) { 584 if (b->nscalablelsbs[i]) { 585 get_array(&s->gb, 586 b->lsb_sample_buffer[i] + seg * s->nsegsamples, 587 s->nsegsamples, b->nscalablelsbs[i]); 588 } 589 } 590 } 591 592 // Skip to the end of band data 593 if (ff_dca_seek_bits(&s->gb, band_data_end)) { 594 av_log(s->avctx, AV_LOG_ERROR, "Read past end of XLL band data\n"); 595 return AVERROR_INVALIDDATA; 596 } 597 598 return 0; 599} 600 601static av_cold void chs_clear_band_data(DCAXllDecoder *s, DCAXllChSet *c, int band, int seg) 602{ 603 DCAXllBand *b = &c->bands[band]; 604 int i, offset, nsamples; 605 606 if (seg < 0) { 607 offset = 0; 608 nsamples = s->nframesamples; 609 } else { 610 offset = seg * s->nsegsamples; 611 nsamples = s->nsegsamples; 612 } 613 614 for (i = 0; i < c->nchannels; i++) { 615 memset(b->msb_sample_buffer[i] + offset, 0, nsamples * sizeof(int32_t)); 616 if (b->lsb_section_size) 617 memset(b->lsb_sample_buffer[i] + offset, 0, nsamples * sizeof(int32_t)); 618 } 619 620 if (seg <= 0 && band) 621 memset(c->deci_history, 0, sizeof(c->deci_history)); 622 623 if (seg < 0) { 624 memset(b->nscalablelsbs, 0, sizeof(b->nscalablelsbs)); 625 memset(b->bit_width_adjust, 0, sizeof(b->bit_width_adjust)); 626 } 627} 628 629static void chs_filter_band_data(DCAXllDecoder *s, DCAXllChSet *c, int band) 630{ 631 DCAXllBand *b = &c->bands[band]; 632 int nsamples = s->nframesamples; 633 int i, j, k; 634 635 // Inverse adaptive or fixed prediction 636 for (i = 0; i < c->nchannels; i++) { 637 int32_t *buf = b->msb_sample_buffer[i]; 638 int order = b->adapt_pred_order[i]; 639 if (order > 0) { 640 int coeff[DCA_XLL_ADAPT_PRED_ORDER_MAX]; 641 // Conversion from reflection coefficients to direct form coefficients 642 for (j = 0; j < order; j++) { 643 int rc = b->adapt_refl_coeff[i][j]; 644 for (k = 0; k < (j + 1) / 2; k++) { 645 int tmp1 = coeff[ k ]; 646 int tmp2 = coeff[j - k - 1]; 647 coeff[ k ] = tmp1 + mul16(rc, tmp2); 648 coeff[j - k - 1] = tmp2 + mul16(rc, tmp1); 649 } 650 coeff[j] = rc; 651 } 652 // Inverse adaptive prediction 653 for (j = 0; j < nsamples - order; j++) { 654 int64_t err = 0; 655 for (k = 0; k < order; k++) 656 err += (int64_t)buf[j + k] * coeff[order - k - 1]; 657 buf[j + k] -= (SUINT)clip23(norm16(err)); 658 } 659 } else { 660 // Inverse fixed coefficient prediction 661 for (j = 0; j < b->fixed_pred_order[i]; j++) 662 for (k = 1; k < nsamples; k++) 663 buf[k] += (unsigned)buf[k - 1]; 664 } 665 } 666 667 // Inverse pairwise channel decorrellation 668 if (b->decor_enabled) { 669 int32_t *tmp[DCA_XLL_CHANNELS_MAX]; 670 671 for (i = 0; i < c->nchannels / 2; i++) { 672 int coeff = b->decor_coeff[i]; 673 if (coeff) { 674 s->dcadsp->decor(b->msb_sample_buffer[i * 2 + 1], 675 b->msb_sample_buffer[i * 2 ], 676 coeff, nsamples); 677 } 678 } 679 680 // Reorder channel pointers to the original order 681 for (i = 0; i < c->nchannels; i++) 682 tmp[i] = b->msb_sample_buffer[i]; 683 684 for (i = 0; i < c->nchannels; i++) 685 b->msb_sample_buffer[b->orig_order[i]] = tmp[i]; 686 } 687 688 // Map output channel pointers for frequency band 0 689 if (c->nfreqbands == 1) 690 for (i = 0; i < c->nchannels; i++) 691 s->output_samples[c->ch_remap[i]] = b->msb_sample_buffer[i]; 692} 693 694static int chs_get_lsb_width(DCAXllDecoder *s, DCAXllChSet *c, int band, int ch) 695{ 696 int adj = c->bands[band].bit_width_adjust[ch]; 697 int shift = c->bands[band].nscalablelsbs[ch]; 698 699 if (s->fixed_lsb_width) 700 shift = s->fixed_lsb_width; 701 else if (shift && adj) 702 shift += adj - 1; 703 else 704 shift += adj; 705 706 return shift; 707} 708 709static void chs_assemble_msbs_lsbs(DCAXllDecoder *s, DCAXllChSet *c, int band) 710{ 711 DCAXllBand *b = &c->bands[band]; 712 int n, ch, nsamples = s->nframesamples; 713 714 for (ch = 0; ch < c->nchannels; ch++) { 715 int shift = chs_get_lsb_width(s, c, band, ch); 716 if (shift) { 717 int32_t *msb = b->msb_sample_buffer[ch]; 718 if (b->nscalablelsbs[ch]) { 719 int32_t *lsb = b->lsb_sample_buffer[ch]; 720 int adj = b->bit_width_adjust[ch]; 721 for (n = 0; n < nsamples; n++) 722 msb[n] = msb[n] * (SUINT)(1 << shift) + (lsb[n] << adj); 723 } else { 724 for (n = 0; n < nsamples; n++) 725 msb[n] = msb[n] * (SUINT)(1 << shift); 726 } 727 } 728 } 729} 730 731static int chs_assemble_freq_bands(DCAXllDecoder *s, DCAXllChSet *c) 732{ 733 int ch, nsamples = s->nframesamples; 734 int32_t *ptr; 735 736 av_assert1(c->nfreqbands > 1); 737 738 // Reallocate frequency band assembly buffer 739 av_fast_malloc(&c->sample_buffer[2], &c->sample_size[2], 740 2 * nsamples * c->nchannels * sizeof(int32_t)); 741 if (!c->sample_buffer[2]) 742 return AVERROR(ENOMEM); 743 744 // Assemble frequency bands 0 and 1 745 ptr = c->sample_buffer[2]; 746 for (ch = 0; ch < c->nchannels; ch++) { 747 int32_t *band0 = c->bands[0].msb_sample_buffer[ch]; 748 int32_t *band1 = c->bands[1].msb_sample_buffer[ch]; 749 750 // Copy decimator history 751 memcpy(band0 - DCA_XLL_DECI_HISTORY_MAX, 752 c->deci_history[ch], sizeof(c->deci_history[0])); 753 754 // Filter 755 s->dcadsp->assemble_freq_bands(ptr, band0, band1, 756 ff_dca_xll_band_coeff, 757 nsamples); 758 759 // Remap output channel pointer to assembly buffer 760 s->output_samples[c->ch_remap[ch]] = ptr; 761 ptr += nsamples * 2; 762 } 763 764 return 0; 765} 766 767static int parse_common_header(DCAXllDecoder *s) 768{ 769 int stream_ver, header_size, frame_size_nbits, nframesegs_log2; 770 771 // XLL extension sync word 772 if (get_bits_long(&s->gb, 32) != DCA_SYNCWORD_XLL) { 773 av_log(s->avctx, AV_LOG_VERBOSE, "Invalid XLL sync word\n"); 774 return AVERROR(EAGAIN); 775 } 776 777 // Version number 778 stream_ver = get_bits(&s->gb, 4) + 1; 779 if (stream_ver > 1) { 780 avpriv_request_sample(s->avctx, "XLL stream version %d", stream_ver); 781 return AVERROR_PATCHWELCOME; 782 } 783 784 // Lossless frame header length 785 header_size = get_bits(&s->gb, 8) + 1; 786 787 // Check CRC 788 if (ff_dca_check_crc(s->avctx, &s->gb, 32, header_size * 8)) { 789 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL common header checksum\n"); 790 return AVERROR_INVALIDDATA; 791 } 792 793 // Number of bits used to read frame size 794 frame_size_nbits = get_bits(&s->gb, 5) + 1; 795 796 // Number of bytes in a lossless frame 797 s->frame_size = get_bits_long(&s->gb, frame_size_nbits); 798 if (s->frame_size < 0 || s->frame_size >= DCA_XLL_PBR_BUFFER_MAX) { 799 av_log(s->avctx, AV_LOG_ERROR, "Invalid XLL frame size (%d bytes)\n", s->frame_size); 800 return AVERROR_INVALIDDATA; 801 } 802 s->frame_size++; 803 804 // Number of channels sets per frame 805 s->nchsets = get_bits(&s->gb, 4) + 1; 806 if (s->nchsets > DCA_XLL_CHSETS_MAX) { 807 avpriv_request_sample(s->avctx, "%d XLL channel sets", s->nchsets); 808 return AVERROR_PATCHWELCOME; 809 } 810 811 // Number of segments per frame 812 nframesegs_log2 = get_bits(&s->gb, 4); 813 s->nframesegs = 1 << nframesegs_log2; 814 if (s->nframesegs > 1024) { 815 av_log(s->avctx, AV_LOG_ERROR, "Too many segments per XLL frame\n"); 816 return AVERROR_INVALIDDATA; 817 } 818 819 // Samples in segment per one frequency band for the first channel set 820 // Maximum value is 256 for sampling frequencies <= 48 kHz 821 // Maximum value is 512 for sampling frequencies > 48 kHz 822 s->nsegsamples_log2 = get_bits(&s->gb, 4); 823 if (!s->nsegsamples_log2) { 824 av_log(s->avctx, AV_LOG_ERROR, "Too few samples per XLL segment\n"); 825 return AVERROR_INVALIDDATA; 826 } 827 s->nsegsamples = 1 << s->nsegsamples_log2; 828 if (s->nsegsamples > 512) { 829 av_log(s->avctx, AV_LOG_ERROR, "Too many samples per XLL segment\n"); 830 return AVERROR_INVALIDDATA; 831 } 832 833 // Samples in frame per one frequency band for the first channel set 834 s->nframesamples_log2 = s->nsegsamples_log2 + nframesegs_log2; 835 s->nframesamples = 1 << s->nframesamples_log2; 836 if (s->nframesamples > 65536) { 837 av_log(s->avctx, AV_LOG_ERROR, "Too many samples per XLL frame\n"); 838 return AVERROR_INVALIDDATA; 839 } 840 841 // Number of bits used to read segment size 842 s->seg_size_nbits = get_bits(&s->gb, 5) + 1; 843 844 // Presence of CRC16 within each frequency band 845 // 0 - No CRC16 within band 846 // 1 - CRC16 placed at the end of MSB0 847 // 2 - CRC16 placed at the end of MSB0 and LSB0 848 // 3 - CRC16 placed at the end of MSB0 and LSB0 and other frequency bands 849 s->band_crc_present = get_bits(&s->gb, 2); 850 851 // MSB/LSB split flag 852 s->scalable_lsbs = get_bits1(&s->gb); 853 854 // Channel position mask 855 s->ch_mask_nbits = get_bits(&s->gb, 5) + 1; 856 857 // Fixed LSB width 858 if (s->scalable_lsbs) 859 s->fixed_lsb_width = get_bits(&s->gb, 4); 860 else 861 s->fixed_lsb_width = 0; 862 863 // Reserved 864 // Byte align 865 // Header CRC16 protection 866 if (ff_dca_seek_bits(&s->gb, header_size * 8)) { 867 av_log(s->avctx, AV_LOG_ERROR, "Read past end of XLL common header\n"); 868 return AVERROR_INVALIDDATA; 869 } 870 871 return 0; 872} 873 874static int is_hier_dmix_chset(DCAXllChSet *c) 875{ 876 return !c->primary_chset && c->dmix_embedded && c->hier_chset; 877} 878 879static DCAXllChSet *find_next_hier_dmix_chset(DCAXllDecoder *s, DCAXllChSet *c) 880{ 881 if (c->hier_chset) 882 while (++c < &s->chset[s->nchsets]) 883 if (is_hier_dmix_chset(c)) 884 return c; 885 886 return NULL; 887} 888 889static void prescale_down_mix(DCAXllChSet *c, DCAXllChSet *o) 890{ 891 int i, j, *coeff_ptr = c->dmix_coeff; 892 893 for (i = 0; i < c->hier_ofs; i++) { 894 int scale = o->dmix_scale[i]; 895 int scale_inv = o->dmix_scale_inv[i]; 896 c->dmix_scale[i] = mul15(c->dmix_scale[i], scale); 897 c->dmix_scale_inv[i] = mul16(c->dmix_scale_inv[i], scale_inv); 898 for (j = 0; j < c->nchannels; j++) { 899 int coeff = mul16(*coeff_ptr, scale_inv); 900 *coeff_ptr++ = mul15(coeff, o->dmix_scale[c->hier_ofs + j]); 901 } 902 } 903} 904 905static int parse_sub_headers(DCAXllDecoder *s, DCAExssAsset *asset) 906{ 907 DCAContext *dca = s->avctx->priv_data; 908 DCAXllChSet *c; 909 int i, ret; 910 911 // Parse channel set headers 912 s->nfreqbands = 0; 913 s->nchannels = 0; 914 s->nreschsets = 0; 915 for (i = 0, c = s->chset; i < s->nchsets; i++, c++) { 916 c->hier_ofs = s->nchannels; 917 if ((ret = chs_parse_header(s, c, asset)) < 0) 918 return ret; 919 if (c->nfreqbands > s->nfreqbands) 920 s->nfreqbands = c->nfreqbands; 921 if (c->hier_chset) 922 s->nchannels += c->nchannels; 923 if (c->residual_encode != (1 << c->nchannels) - 1) 924 s->nreschsets++; 925 } 926 927 // Pre-scale downmixing coefficients for all non-primary channel sets 928 for (i = s->nchsets - 1, c = &s->chset[i]; i > 0; i--, c--) { 929 if (is_hier_dmix_chset(c)) { 930 DCAXllChSet *o = find_next_hier_dmix_chset(s, c); 931 if (o) 932 prescale_down_mix(c, o); 933 } 934 } 935 936 // Determine number of active channel sets to decode 937 switch (dca->request_channel_layout) { 938 case DCA_SPEAKER_LAYOUT_STEREO: 939 s->nactivechsets = 1; 940 break; 941 case DCA_SPEAKER_LAYOUT_5POINT0: 942 case DCA_SPEAKER_LAYOUT_5POINT1: 943 s->nactivechsets = (s->chset[0].nchannels < 5 && s->nchsets > 1) ? 2 : 1; 944 break; 945 default: 946 s->nactivechsets = s->nchsets; 947 break; 948 } 949 950 return 0; 951} 952 953static int parse_navi_table(DCAXllDecoder *s) 954{ 955 int chs, seg, band, navi_nb, navi_pos, *navi_ptr; 956 DCAXllChSet *c; 957 958 // Determine size of NAVI table 959 navi_nb = s->nfreqbands * s->nframesegs * s->nchsets; 960 if (navi_nb > 1024) { 961 av_log(s->avctx, AV_LOG_ERROR, "Too many NAVI entries (%d)\n", navi_nb); 962 return AVERROR_INVALIDDATA; 963 } 964 965 // Reallocate NAVI table 966 av_fast_malloc(&s->navi, &s->navi_size, navi_nb * sizeof(*s->navi)); 967 if (!s->navi) 968 return AVERROR(ENOMEM); 969 970 // Parse NAVI 971 navi_pos = get_bits_count(&s->gb); 972 navi_ptr = s->navi; 973 for (band = 0; band < s->nfreqbands; band++) { 974 for (seg = 0; seg < s->nframesegs; seg++) { 975 for (chs = 0, c = s->chset; chs < s->nchsets; chs++, c++) { 976 int size = 0; 977 if (c->nfreqbands > band) { 978 size = get_bits_long(&s->gb, s->seg_size_nbits); 979 if (size < 0 || size >= s->frame_size) { 980 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAVI segment size (%d bytes)\n", size); 981 return AVERROR_INVALIDDATA; 982 } 983 size++; 984 } 985 *navi_ptr++ = size; 986 } 987 } 988 } 989 990 // Byte align 991 // CRC16 992 skip_bits(&s->gb, -get_bits_count(&s->gb) & 7); 993 skip_bits(&s->gb, 16); 994 995 // Check CRC 996 if (ff_dca_check_crc(s->avctx, &s->gb, navi_pos, get_bits_count(&s->gb))) { 997 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAVI checksum\n"); 998 return AVERROR_INVALIDDATA; 999 } 1000 1001 return 0; 1002} 1003 1004static int parse_band_data(DCAXllDecoder *s) 1005{ 1006 int ret, chs, seg, band, navi_pos, *navi_ptr; 1007 DCAXllChSet *c; 1008 1009 for (chs = 0, c = s->chset; chs < s->nactivechsets; chs++, c++) { 1010 if ((ret = chs_alloc_msb_band_data(s, c)) < 0) 1011 return ret; 1012 if ((ret = chs_alloc_lsb_band_data(s, c)) < 0) 1013 return ret; 1014 } 1015 1016 navi_pos = get_bits_count(&s->gb); 1017 navi_ptr = s->navi; 1018 for (band = 0; band < s->nfreqbands; band++) { 1019 for (seg = 0; seg < s->nframesegs; seg++) { 1020 for (chs = 0, c = s->chset; chs < s->nchsets; chs++, c++) { 1021 if (c->nfreqbands > band) { 1022 navi_pos += *navi_ptr * 8; 1023 if (navi_pos > s->gb.size_in_bits) { 1024 av_log(s->avctx, AV_LOG_ERROR, "Invalid NAVI position\n"); 1025 return AVERROR_INVALIDDATA; 1026 } 1027 if (chs < s->nactivechsets && 1028 (ret = chs_parse_band_data(s, c, band, seg, navi_pos)) < 0) { 1029 if (s->avctx->err_recognition & AV_EF_EXPLODE) 1030 return ret; 1031 chs_clear_band_data(s, c, band, seg); 1032 } 1033 skip_bits_long(&s->gb, navi_pos - get_bits_count(&s->gb)); 1034 } 1035 navi_ptr++; 1036 } 1037 } 1038 } 1039 1040 return 0; 1041} 1042 1043static int parse_frame(DCAXllDecoder *s, const uint8_t *data, int size, DCAExssAsset *asset) 1044{ 1045 int ret; 1046 1047 if ((ret = init_get_bits8(&s->gb, data, size)) < 0) 1048 return ret; 1049 if ((ret = parse_common_header(s)) < 0) 1050 return ret; 1051 if ((ret = parse_sub_headers(s, asset)) < 0) 1052 return ret; 1053 if ((ret = parse_navi_table(s)) < 0) 1054 return ret; 1055 if ((ret = parse_band_data(s)) < 0) 1056 return ret; 1057 if (ff_dca_seek_bits(&s->gb, s->frame_size * 8)) { 1058 av_log(s->avctx, AV_LOG_ERROR, "Read past end of XLL frame\n"); 1059 return AVERROR_INVALIDDATA; 1060 } 1061 return ret; 1062} 1063 1064static void clear_pbr(DCAXllDecoder *s) 1065{ 1066 s->pbr_length = 0; 1067 s->pbr_delay = 0; 1068} 1069 1070static int copy_to_pbr(DCAXllDecoder *s, const uint8_t *data, int size, int delay) 1071{ 1072 if (size > DCA_XLL_PBR_BUFFER_MAX) 1073 return AVERROR(ENOSPC); 1074 1075 if (!s->pbr_buffer && !(s->pbr_buffer = av_malloc(DCA_XLL_PBR_BUFFER_MAX + AV_INPUT_BUFFER_PADDING_SIZE))) 1076 return AVERROR(ENOMEM); 1077 1078 memcpy(s->pbr_buffer, data, size); 1079 s->pbr_length = size; 1080 s->pbr_delay = delay; 1081 return 0; 1082} 1083 1084static int parse_frame_no_pbr(DCAXllDecoder *s, const uint8_t *data, int size, DCAExssAsset *asset) 1085{ 1086 int ret = parse_frame(s, data, size, asset); 1087 1088 // If XLL packet data didn't start with a sync word, we must have jumped 1089 // right into the middle of PBR smoothing period 1090 if (ret == AVERROR(EAGAIN) && asset->xll_sync_present && asset->xll_sync_offset < size) { 1091 // Skip to the next sync word in this packet 1092 data += asset->xll_sync_offset; 1093 size -= asset->xll_sync_offset; 1094 1095 // If decoding delay is set, put the frame into PBR buffer and return 1096 // failure code. Higher level decoder is expected to switch to lossy 1097 // core decoding or mute its output until decoding delay expires. 1098 if (asset->xll_delay_nframes > 0) { 1099 if ((ret = copy_to_pbr(s, data, size, asset->xll_delay_nframes)) < 0) 1100 return ret; 1101 return AVERROR(EAGAIN); 1102 } 1103 1104 // No decoding delay, just parse the frame in place 1105 ret = parse_frame(s, data, size, asset); 1106 } 1107 1108 if (ret < 0) 1109 return ret; 1110 1111 if (s->frame_size > size) 1112 return AVERROR(EINVAL); 1113 1114 // If the XLL decoder didn't consume full packet, start PBR smoothing period 1115 if (s->frame_size < size) 1116 if ((ret = copy_to_pbr(s, data + s->frame_size, size - s->frame_size, 0)) < 0) 1117 return ret; 1118 1119 return 0; 1120} 1121 1122static int parse_frame_pbr(DCAXllDecoder *s, const uint8_t *data, int size, DCAExssAsset *asset) 1123{ 1124 int ret; 1125 1126 if (size > DCA_XLL_PBR_BUFFER_MAX - s->pbr_length) { 1127 ret = AVERROR(ENOSPC); 1128 goto fail; 1129 } 1130 1131 memcpy(s->pbr_buffer + s->pbr_length, data, size); 1132 s->pbr_length += size; 1133 1134 // Respect decoding delay after synchronization error 1135 if (s->pbr_delay > 0 && --s->pbr_delay) 1136 return AVERROR(EAGAIN); 1137 1138 if ((ret = parse_frame(s, s->pbr_buffer, s->pbr_length, asset)) < 0) 1139 goto fail; 1140 1141 if (s->frame_size > s->pbr_length) { 1142 ret = AVERROR(EINVAL); 1143 goto fail; 1144 } 1145 1146 if (s->frame_size == s->pbr_length) { 1147 // End of PBR smoothing period 1148 clear_pbr(s); 1149 } else { 1150 s->pbr_length -= s->frame_size; 1151 memmove(s->pbr_buffer, s->pbr_buffer + s->frame_size, s->pbr_length); 1152 } 1153 1154 return 0; 1155 1156fail: 1157 // For now, throw out all PBR state on failure. 1158 // Perhaps we can be smarter and try to resync somehow. 1159 clear_pbr(s); 1160 return ret; 1161} 1162 1163int ff_dca_xll_parse(DCAXllDecoder *s, const uint8_t *data, DCAExssAsset *asset) 1164{ 1165 int ret; 1166 1167 if (s->hd_stream_id != asset->hd_stream_id) { 1168 clear_pbr(s); 1169 s->hd_stream_id = asset->hd_stream_id; 1170 } 1171 1172 if (s->pbr_length) 1173 ret = parse_frame_pbr(s, data + asset->xll_offset, asset->xll_size, asset); 1174 else 1175 ret = parse_frame_no_pbr(s, data + asset->xll_offset, asset->xll_size, asset); 1176 1177 return ret; 1178} 1179 1180static void undo_down_mix(DCAXllDecoder *s, DCAXllChSet *o, int band) 1181{ 1182 int i, j, k, nchannels = 0, *coeff_ptr = o->dmix_coeff; 1183 DCAXllChSet *c; 1184 1185 for (i = 0, c = s->chset; i < s->nactivechsets; i++, c++) { 1186 if (!c->hier_chset) 1187 continue; 1188 1189 av_assert1(band < c->nfreqbands); 1190 for (j = 0; j < c->nchannels; j++) { 1191 for (k = 0; k < o->nchannels; k++) { 1192 int coeff = *coeff_ptr++; 1193 if (coeff) { 1194 s->dcadsp->dmix_sub(c->bands[band].msb_sample_buffer[j], 1195 o->bands[band].msb_sample_buffer[k], 1196 coeff, s->nframesamples); 1197 if (band) 1198 s->dcadsp->dmix_sub(c->deci_history[j], 1199 o->deci_history[k], 1200 coeff, DCA_XLL_DECI_HISTORY_MAX); 1201 } 1202 } 1203 } 1204 1205 nchannels += c->nchannels; 1206 if (nchannels >= o->hier_ofs) 1207 break; 1208 } 1209} 1210 1211static void scale_down_mix(DCAXllDecoder *s, DCAXllChSet *o, int band) 1212{ 1213 int i, j, nchannels = 0; 1214 DCAXllChSet *c; 1215 1216 for (i = 0, c = s->chset; i < s->nactivechsets; i++, c++) { 1217 if (!c->hier_chset) 1218 continue; 1219 1220 av_assert1(band < c->nfreqbands); 1221 for (j = 0; j < c->nchannels; j++) { 1222 int scale = o->dmix_scale[nchannels++]; 1223 if (scale != (1 << 15)) { 1224 s->dcadsp->dmix_scale(c->bands[band].msb_sample_buffer[j], 1225 scale, s->nframesamples); 1226 if (band) 1227 s->dcadsp->dmix_scale(c->deci_history[j], 1228 scale, DCA_XLL_DECI_HISTORY_MAX); 1229 } 1230 } 1231 1232 if (nchannels >= o->hier_ofs) 1233 break; 1234 } 1235} 1236 1237// Clear all band data and replace non-residual encoded channels with lossy 1238// counterparts 1239static av_cold void force_lossy_output(DCAXllDecoder *s, DCAXllChSet *c) 1240{ 1241 DCAContext *dca = s->avctx->priv_data; 1242 int band, ch; 1243 1244 for (band = 0; band < c->nfreqbands; band++) 1245 chs_clear_band_data(s, c, band, -1); 1246 1247 for (ch = 0; ch < c->nchannels; ch++) { 1248 if (!(c->residual_encode & (1 << ch))) 1249 continue; 1250 if (ff_dca_core_map_spkr(&dca->core, c->ch_remap[ch]) < 0) 1251 continue; 1252 c->residual_encode &= ~(1 << ch); 1253 } 1254} 1255 1256static int combine_residual_frame(DCAXllDecoder *s, DCAXllChSet *c) 1257{ 1258 DCAContext *dca = s->avctx->priv_data; 1259 int ch, nsamples = s->nframesamples; 1260 DCAXllChSet *o; 1261 1262 // Verify that core is compatible 1263 if (!(dca->packet & DCA_PACKET_CORE)) { 1264 av_log(s->avctx, AV_LOG_ERROR, "Residual encoded channels are present without core\n"); 1265 return AVERROR(EINVAL); 1266 } 1267 1268 if (c->freq != dca->core.output_rate) { 1269 av_log(s->avctx, AV_LOG_WARNING, "Sample rate mismatch between core (%d Hz) and XLL (%d Hz)\n", dca->core.output_rate, c->freq); 1270 return AVERROR_INVALIDDATA; 1271 } 1272 1273 if (nsamples != dca->core.npcmsamples) { 1274 av_log(s->avctx, AV_LOG_WARNING, "Number of samples per frame mismatch between core (%d) and XLL (%d)\n", dca->core.npcmsamples, nsamples); 1275 return AVERROR_INVALIDDATA; 1276 } 1277 1278 // See if this channel set is downmixed and find the next channel set in 1279 // hierarchy. If downmixed, undo core pre-scaling before combining with 1280 // residual (residual is not scaled). 1281 o = find_next_hier_dmix_chset(s, c); 1282 1283 // Reduce core bit width and combine with residual 1284 for (ch = 0; ch < c->nchannels; ch++) { 1285 int n, spkr, shift, round; 1286 int32_t *src, *dst; 1287 1288 if (c->residual_encode & (1 << ch)) 1289 continue; 1290 1291 // Map this channel to core speaker 1292 spkr = ff_dca_core_map_spkr(&dca->core, c->ch_remap[ch]); 1293 if (spkr < 0) { 1294 av_log(s->avctx, AV_LOG_WARNING, "Residual encoded channel (%d) references unavailable core channel\n", c->ch_remap[ch]); 1295 return AVERROR_INVALIDDATA; 1296 } 1297 1298 // Account for LSB width 1299 shift = 24 - c->pcm_bit_res + chs_get_lsb_width(s, c, 0, ch); 1300 if (shift > 24) { 1301 av_log(s->avctx, AV_LOG_WARNING, "Invalid core shift (%d bits)\n", shift); 1302 return AVERROR_INVALIDDATA; 1303 } 1304 1305 round = shift > 0 ? 1 << (shift - 1) : 0; 1306 1307 src = dca->core.output_samples[spkr]; 1308 dst = c->bands[0].msb_sample_buffer[ch]; 1309 if (o) { 1310 // Undo embedded core downmix pre-scaling 1311 int scale_inv = o->dmix_scale_inv[c->hier_ofs + ch]; 1312 for (n = 0; n < nsamples; n++) 1313 dst[n] += (SUINT)clip23((mul16(src[n], scale_inv) + round) >> shift); 1314 } else { 1315 // No downmix scaling 1316 for (n = 0; n < nsamples; n++) 1317 dst[n] += (unsigned)((src[n] + round) >> shift); 1318 } 1319 } 1320 1321 return 0; 1322} 1323 1324int ff_dca_xll_filter_frame(DCAXllDecoder *s, AVFrame *frame) 1325{ 1326 AVCodecContext *avctx = s->avctx; 1327 DCAContext *dca = avctx->priv_data; 1328 DCAExssAsset *asset = &dca->exss.assets[0]; 1329 DCAXllChSet *p = &s->chset[0], *c; 1330 enum AVMatrixEncoding matrix_encoding = AV_MATRIX_ENCODING_NONE; 1331 int i, j, k, ret, shift, nsamples, request_mask; 1332 int ch_remap[DCA_SPEAKER_COUNT]; 1333 1334 // Force lossy downmixed output during recovery 1335 if (dca->packet & DCA_PACKET_RECOVERY) { 1336 for (i = 0, c = s->chset; i < s->nchsets; i++, c++) { 1337 if (i < s->nactivechsets) 1338 force_lossy_output(s, c); 1339 1340 if (!c->primary_chset) 1341 c->dmix_embedded = 0; 1342 } 1343 1344 s->scalable_lsbs = 0; 1345 s->fixed_lsb_width = 0; 1346 } 1347 1348 // Filter frequency bands for active channel sets 1349 s->output_mask = 0; 1350 for (i = 0, c = s->chset; i < s->nactivechsets; i++, c++) { 1351 chs_filter_band_data(s, c, 0); 1352 1353 if (c->residual_encode != (1 << c->nchannels) - 1 1354 && (ret = combine_residual_frame(s, c)) < 0) 1355 return ret; 1356 1357 if (s->scalable_lsbs) 1358 chs_assemble_msbs_lsbs(s, c, 0); 1359 1360 if (c->nfreqbands > 1) { 1361 chs_filter_band_data(s, c, 1); 1362 chs_assemble_msbs_lsbs(s, c, 1); 1363 } 1364 1365 s->output_mask |= c->ch_mask; 1366 } 1367 1368 // Undo hierarchial downmix and/or apply scaling 1369 for (i = 1, c = &s->chset[1]; i < s->nchsets; i++, c++) { 1370 if (!is_hier_dmix_chset(c)) 1371 continue; 1372 1373 if (i >= s->nactivechsets) { 1374 for (j = 0; j < c->nfreqbands; j++) 1375 if (c->bands[j].dmix_embedded) 1376 scale_down_mix(s, c, j); 1377 break; 1378 } 1379 1380 for (j = 0; j < c->nfreqbands; j++) 1381 if (c->bands[j].dmix_embedded) 1382 undo_down_mix(s, c, j); 1383 } 1384 1385 // Assemble frequency bands for active channel sets 1386 if (s->nfreqbands > 1) { 1387 for (i = 0; i < s->nactivechsets; i++) 1388 if ((ret = chs_assemble_freq_bands(s, &s->chset[i])) < 0) 1389 return ret; 1390 } 1391 1392 // Normalize to regular 5.1 layout if downmixing 1393 if (dca->request_channel_layout) { 1394 if (s->output_mask & DCA_SPEAKER_MASK_Lss) { 1395 s->output_samples[DCA_SPEAKER_Ls] = s->output_samples[DCA_SPEAKER_Lss]; 1396 s->output_mask = (s->output_mask & ~DCA_SPEAKER_MASK_Lss) | DCA_SPEAKER_MASK_Ls; 1397 } 1398 if (s->output_mask & DCA_SPEAKER_MASK_Rss) { 1399 s->output_samples[DCA_SPEAKER_Rs] = s->output_samples[DCA_SPEAKER_Rss]; 1400 s->output_mask = (s->output_mask & ~DCA_SPEAKER_MASK_Rss) | DCA_SPEAKER_MASK_Rs; 1401 } 1402 } 1403 1404 // Handle downmixing to stereo request 1405 if (dca->request_channel_layout == DCA_SPEAKER_LAYOUT_STEREO 1406 && DCA_HAS_STEREO(s->output_mask) && p->dmix_embedded 1407 && (p->dmix_type == DCA_DMIX_TYPE_LoRo || 1408 p->dmix_type == DCA_DMIX_TYPE_LtRt)) 1409 request_mask = DCA_SPEAKER_LAYOUT_STEREO; 1410 else 1411 request_mask = s->output_mask; 1412 if (!ff_dca_set_channel_layout(avctx, ch_remap, request_mask)) 1413 return AVERROR(EINVAL); 1414 1415 avctx->sample_rate = p->freq << (s->nfreqbands - 1); 1416 1417 switch (p->storage_bit_res) { 1418 case 16: 1419 avctx->sample_fmt = AV_SAMPLE_FMT_S16P; 1420 shift = 16 - p->pcm_bit_res; 1421 break; 1422 case 20: 1423 case 24: 1424 avctx->sample_fmt = AV_SAMPLE_FMT_S32P; 1425 shift = 24 - p->pcm_bit_res; 1426 break; 1427 default: 1428 return AVERROR(EINVAL); 1429 } 1430 1431 avctx->bits_per_raw_sample = p->storage_bit_res; 1432 avctx->profile = FF_PROFILE_DTS_HD_MA; 1433 avctx->bit_rate = 0; 1434 1435 frame->nb_samples = nsamples = s->nframesamples << (s->nfreqbands - 1); 1436 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) 1437 return ret; 1438 1439 // Downmix primary channel set to stereo 1440 if (request_mask != s->output_mask) { 1441 ff_dca_downmix_to_stereo_fixed(s->dcadsp, s->output_samples, 1442 p->dmix_coeff, nsamples, 1443 s->output_mask); 1444 } 1445 1446 for (i = 0; i < avctx->ch_layout.nb_channels; i++) { 1447 int32_t *samples = s->output_samples[ch_remap[i]]; 1448 if (frame->format == AV_SAMPLE_FMT_S16P) { 1449 int16_t *plane = (int16_t *)frame->extended_data[i]; 1450 for (k = 0; k < nsamples; k++) 1451 plane[k] = av_clip_int16(samples[k] * (SUINT)(1 << shift)); 1452 } else { 1453 int32_t *plane = (int32_t *)frame->extended_data[i]; 1454 for (k = 0; k < nsamples; k++) 1455 plane[k] = clip23(samples[k] * (SUINT)(1 << shift)) * (1 << 8); 1456 } 1457 } 1458 1459 if (!asset->one_to_one_map_ch_to_spkr) { 1460 if (asset->representation_type == DCA_REPR_TYPE_LtRt) 1461 matrix_encoding = AV_MATRIX_ENCODING_DOLBY; 1462 else if (asset->representation_type == DCA_REPR_TYPE_LhRh) 1463 matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE; 1464 } else if (request_mask != s->output_mask && p->dmix_type == DCA_DMIX_TYPE_LtRt) { 1465 matrix_encoding = AV_MATRIX_ENCODING_DOLBY; 1466 } 1467 if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0) 1468 return ret; 1469 1470 return 0; 1471} 1472 1473av_cold void ff_dca_xll_flush(DCAXllDecoder *s) 1474{ 1475 clear_pbr(s); 1476} 1477 1478av_cold void ff_dca_xll_close(DCAXllDecoder *s) 1479{ 1480 DCAXllChSet *c; 1481 int i, j; 1482 1483 for (i = 0, c = s->chset; i < DCA_XLL_CHSETS_MAX; i++, c++) { 1484 for (j = 0; j < DCA_XLL_SAMPLE_BUFFERS_MAX; j++) { 1485 av_freep(&c->sample_buffer[j]); 1486 c->sample_size[j] = 0; 1487 } 1488 } 1489 1490 av_freep(&s->navi); 1491 s->navi_size = 0; 1492 1493 av_freep(&s->pbr_buffer); 1494 clear_pbr(s); 1495} 1496