1/* 2 * WavPack lossless audio encoder 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_WRITER_LE 22 23#include "libavutil/intreadwrite.h" 24#include "libavutil/opt.h" 25#include "avcodec.h" 26#include "internal.h" 27#include "put_bits.h" 28#include "bytestream.h" 29#include "wavpackenc.h" 30#include "wavpack.h" 31 32#define UPDATE_WEIGHT(weight, delta, source, result) \ 33 if ((source) && (result)) { \ 34 int32_t s = (int32_t) ((source) ^ (result)) >> 31; \ 35 weight = ((delta) ^ s) + ((weight) - s); \ 36 } 37 38#define APPLY_WEIGHT_F(weight, sample) ((((((sample) & 0xffff) * (weight)) >> 9) + \ 39 ((((sample) & ~0xffff) >> 9) * (weight)) + 1) >> 1) 40 41#define APPLY_WEIGHT_I(weight, sample) (((weight) * (sample) + 512) >> 10) 42 43#define APPLY_WEIGHT(weight, sample) ((sample) != (short) (sample) ? \ 44 APPLY_WEIGHT_F(weight, sample) : APPLY_WEIGHT_I (weight, sample)) 45 46#define CLEAR(destin) memset(&destin, 0, sizeof(destin)); 47 48#define SHIFT_LSB 13 49#define SHIFT_MASK (0x1FU << SHIFT_LSB) 50 51#define MAG_LSB 18 52#define MAG_MASK (0x1FU << MAG_LSB) 53 54#define SRATE_LSB 23 55#define SRATE_MASK (0xFU << SRATE_LSB) 56 57#define EXTRA_TRY_DELTAS 1 58#define EXTRA_ADJUST_DELTAS 2 59#define EXTRA_SORT_FIRST 4 60#define EXTRA_BRANCHES 8 61#define EXTRA_SORT_LAST 16 62 63typedef struct WavPackExtraInfo { 64 struct Decorr dps[MAX_TERMS]; 65 int nterms, log_limit, gt16bit; 66 uint32_t best_bits; 67} WavPackExtraInfo; 68 69typedef struct WavPackWords { 70 int pend_data, holding_one, zeros_acc; 71 int holding_zero, pend_count; 72 WvChannel c[2]; 73} WavPackWords; 74 75typedef struct WavPackEncodeContext { 76 AVClass *class; 77 AVCodecContext *avctx; 78 PutBitContext pb; 79 int block_samples; 80 int buffer_size; 81 int sample_index; 82 int stereo, stereo_in; 83 int ch_offset; 84 85 int32_t *samples[2]; 86 int samples_size[2]; 87 88 int32_t *sampleptrs[MAX_TERMS+2][2]; 89 int sampleptrs_size[MAX_TERMS+2][2]; 90 91 int32_t *temp_buffer[2][2]; 92 int temp_buffer_size[2][2]; 93 94 int32_t *best_buffer[2]; 95 int best_buffer_size[2]; 96 97 int32_t *js_left, *js_right; 98 int js_left_size, js_right_size; 99 100 int32_t *orig_l, *orig_r; 101 int orig_l_size, orig_r_size; 102 103 unsigned extra_flags; 104 int optimize_mono; 105 int decorr_filter; 106 int joint; 107 int num_branches; 108 109 uint32_t flags; 110 uint32_t crc_x; 111 WavPackWords w; 112 113 uint8_t int32_sent_bits, int32_zeros, int32_ones, int32_dups; 114 uint8_t float_flags, float_shift, float_max_exp, max_exp; 115 int32_t shifted_ones, shifted_zeros, shifted_both; 116 int32_t false_zeros, neg_zeros, ordata; 117 118 int num_terms, shift, joint_stereo, false_stereo; 119 int num_decorrs, num_passes, best_decorr, mask_decorr; 120 struct Decorr decorr_passes[MAX_TERMS]; 121 const WavPackDecorrSpec *decorr_specs; 122 float delta_decay; 123} WavPackEncodeContext; 124 125static av_cold int wavpack_encode_init(AVCodecContext *avctx) 126{ 127 WavPackEncodeContext *s = avctx->priv_data; 128 129 s->avctx = avctx; 130 131 if (!avctx->frame_size) { 132 int block_samples; 133 if (!(avctx->sample_rate & 1)) 134 block_samples = avctx->sample_rate / 2; 135 else 136 block_samples = avctx->sample_rate; 137 138 while (block_samples * avctx->channels > 150000) 139 block_samples /= 2; 140 141 while (block_samples * avctx->channels < 40000) 142 block_samples *= 2; 143 avctx->frame_size = block_samples; 144 } else if (avctx->frame_size && (avctx->frame_size < 128 || 145 avctx->frame_size > WV_MAX_SAMPLES)) { 146 av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n", avctx->frame_size); 147 return AVERROR(EINVAL); 148 } 149 150 if (avctx->compression_level != FF_COMPRESSION_DEFAULT) { 151 if (avctx->compression_level >= 3) { 152 s->decorr_filter = 3; 153 s->num_passes = 9; 154 if (avctx->compression_level >= 8) { 155 s->num_branches = 4; 156 s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_SORT_FIRST|EXTRA_SORT_LAST|EXTRA_BRANCHES; 157 } else if (avctx->compression_level >= 7) { 158 s->num_branches = 3; 159 s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_SORT_FIRST|EXTRA_BRANCHES; 160 } else if (avctx->compression_level >= 6) { 161 s->num_branches = 2; 162 s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_SORT_FIRST|EXTRA_BRANCHES; 163 } else if (avctx->compression_level >= 5) { 164 s->num_branches = 1; 165 s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_SORT_FIRST|EXTRA_BRANCHES; 166 } else if (avctx->compression_level >= 4) { 167 s->num_branches = 1; 168 s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_BRANCHES; 169 } 170 } else if (avctx->compression_level == 2) { 171 s->decorr_filter = 2; 172 s->num_passes = 4; 173 } else if (avctx->compression_level == 1) { 174 s->decorr_filter = 1; 175 s->num_passes = 2; 176 } else if (avctx->compression_level < 1) { 177 s->decorr_filter = 0; 178 s->num_passes = 0; 179 } 180 } 181 182 s->num_decorrs = decorr_filter_sizes[s->decorr_filter]; 183 s->decorr_specs = decorr_filters[s->decorr_filter]; 184 185 s->delta_decay = 2.0; 186 187 return 0; 188} 189 190static void shift_mono(int32_t *samples, int nb_samples, int shift) 191{ 192 int i; 193 for (i = 0; i < nb_samples; i++) 194 samples[i] >>= shift; 195} 196 197static void shift_stereo(int32_t *left, int32_t *right, 198 int nb_samples, int shift) 199{ 200 int i; 201 for (i = 0; i < nb_samples; i++) { 202 left [i] >>= shift; 203 right[i] >>= shift; 204 } 205} 206 207#define FLOAT_SHIFT_ONES 1 208#define FLOAT_SHIFT_SAME 2 209#define FLOAT_SHIFT_SENT 4 210#define FLOAT_ZEROS_SENT 8 211#define FLOAT_NEG_ZEROS 0x10 212#define FLOAT_EXCEPTIONS 0x20 213 214#define get_mantissa(f) ((f) & 0x7fffff) 215#define get_exponent(f) (((f) >> 23) & 0xff) 216#define get_sign(f) (((f) >> 31) & 0x1) 217 218static void process_float(WavPackEncodeContext *s, int32_t *sample) 219{ 220 int32_t shift_count, value, f = *sample; 221 222 if (get_exponent(f) == 255) { 223 s->float_flags |= FLOAT_EXCEPTIONS; 224 value = 0x1000000; 225 shift_count = 0; 226 } else if (get_exponent(f)) { 227 shift_count = s->max_exp - get_exponent(f); 228 value = 0x800000 + get_mantissa(f); 229 } else { 230 shift_count = s->max_exp ? s->max_exp - 1 : 0; 231 value = get_mantissa(f); 232 } 233 234 if (shift_count < 25) 235 value >>= shift_count; 236 else 237 value = 0; 238 239 if (!value) { 240 if (get_exponent(f) || get_mantissa(f)) 241 s->false_zeros++; 242 else if (get_sign(f)) 243 s->neg_zeros++; 244 } else if (shift_count) { 245 int32_t mask = (1 << shift_count) - 1; 246 247 if (!(get_mantissa(f) & mask)) 248 s->shifted_zeros++; 249 else if ((get_mantissa(f) & mask) == mask) 250 s->shifted_ones++; 251 else 252 s->shifted_both++; 253 } 254 255 s->ordata |= value; 256 *sample = get_sign(f) ? -value : value; 257} 258 259static int scan_float(WavPackEncodeContext *s, 260 int32_t *samples_l, int32_t *samples_r, 261 int nb_samples) 262{ 263 uint32_t crc = 0xffffffffu; 264 int i; 265 266 s->shifted_ones = s->shifted_zeros = s->shifted_both = s->ordata = 0; 267 s->float_shift = s->float_flags = 0; 268 s->false_zeros = s->neg_zeros = 0; 269 s->max_exp = 0; 270 271 if (s->flags & WV_MONO_DATA) { 272 for (i = 0; i < nb_samples; i++) { 273 int32_t f = samples_l[i]; 274 crc = crc * 27 + get_mantissa(f) * 9 + get_exponent(f) * 3 + get_sign(f); 275 276 if (get_exponent(f) > s->max_exp && get_exponent(f) < 255) 277 s->max_exp = get_exponent(f); 278 } 279 } else { 280 for (i = 0; i < nb_samples; i++) { 281 int32_t f; 282 283 f = samples_l[i]; 284 crc = crc * 27 + get_mantissa(f) * 9 + get_exponent(f) * 3 + get_sign(f); 285 if (get_exponent(f) > s->max_exp && get_exponent(f) < 255) 286 s->max_exp = get_exponent(f); 287 288 f = samples_r[i]; 289 crc = crc * 27 + get_mantissa(f) * 9 + get_exponent(f) * 3 + get_sign(f); 290 291 if (get_exponent(f) > s->max_exp && get_exponent(f) < 255) 292 s->max_exp = get_exponent(f); 293 } 294 } 295 296 s->crc_x = crc; 297 298 if (s->flags & WV_MONO_DATA) { 299 for (i = 0; i < nb_samples; i++) 300 process_float(s, &samples_l[i]); 301 } else { 302 for (i = 0; i < nb_samples; i++) { 303 process_float(s, &samples_l[i]); 304 process_float(s, &samples_r[i]); 305 } 306 } 307 308 s->float_max_exp = s->max_exp; 309 310 if (s->shifted_both) 311 s->float_flags |= FLOAT_SHIFT_SENT; 312 else if (s->shifted_ones && !s->shifted_zeros) 313 s->float_flags |= FLOAT_SHIFT_ONES; 314 else if (s->shifted_ones && s->shifted_zeros) 315 s->float_flags |= FLOAT_SHIFT_SAME; 316 else if (s->ordata && !(s->ordata & 1)) { 317 do { 318 s->float_shift++; 319 s->ordata >>= 1; 320 } while (!(s->ordata & 1)); 321 322 if (s->flags & WV_MONO_DATA) 323 shift_mono(samples_l, nb_samples, s->float_shift); 324 else 325 shift_stereo(samples_l, samples_r, nb_samples, s->float_shift); 326 } 327 328 s->flags &= ~MAG_MASK; 329 330 while (s->ordata) { 331 s->flags += 1 << MAG_LSB; 332 s->ordata >>= 1; 333 } 334 335 if (s->false_zeros || s->neg_zeros) 336 s->float_flags |= FLOAT_ZEROS_SENT; 337 338 if (s->neg_zeros) 339 s->float_flags |= FLOAT_NEG_ZEROS; 340 341 return s->float_flags & (FLOAT_EXCEPTIONS | FLOAT_ZEROS_SENT | 342 FLOAT_SHIFT_SENT | FLOAT_SHIFT_SAME); 343} 344 345static void scan_int23(WavPackEncodeContext *s, 346 int32_t *samples_l, int32_t *samples_r, 347 int nb_samples) 348{ 349 uint32_t magdata = 0, ordata = 0, xordata = 0, anddata = ~0; 350 int i, total_shift = 0; 351 352 s->int32_sent_bits = s->int32_zeros = s->int32_ones = s->int32_dups = 0; 353 354 if (s->flags & WV_MONO_DATA) { 355 for (i = 0; i < nb_samples; i++) { 356 int32_t M = samples_l[i]; 357 358 magdata |= (M < 0) ? ~M : M; 359 xordata |= M ^ -(M & 1); 360 anddata &= M; 361 ordata |= M; 362 363 if ((ordata & 1) && !(anddata & 1) && (xordata & 2)) 364 return; 365 } 366 } else { 367 for (i = 0; i < nb_samples; i++) { 368 int32_t L = samples_l[i]; 369 int32_t R = samples_r[i]; 370 371 magdata |= (L < 0) ? ~L : L; 372 magdata |= (R < 0) ? ~R : R; 373 xordata |= L ^ -(L & 1); 374 xordata |= R ^ -(R & 1); 375 anddata &= L & R; 376 ordata |= L | R; 377 378 if ((ordata & 1) && !(anddata & 1) && (xordata & 2)) 379 return; 380 } 381 } 382 383 s->flags &= ~MAG_MASK; 384 385 while (magdata) { 386 s->flags += 1 << MAG_LSB; 387 magdata >>= 1; 388 } 389 390 if (!(s->flags & MAG_MASK)) 391 return; 392 393 if (!(ordata & 1)) { 394 do { 395 s->flags -= 1 << MAG_LSB; 396 s->int32_zeros++; 397 total_shift++; 398 ordata >>= 1; 399 } while (!(ordata & 1)); 400 } else if (anddata & 1) { 401 do { 402 s->flags -= 1 << MAG_LSB; 403 s->int32_ones++; 404 total_shift++; 405 anddata >>= 1; 406 } while (anddata & 1); 407 } else if (!(xordata & 2)) { 408 do { 409 s->flags -= 1 << MAG_LSB; 410 s->int32_dups++; 411 total_shift++; 412 xordata >>= 1; 413 } while (!(xordata & 2)); 414 } 415 416 if (total_shift) { 417 s->flags |= WV_INT32_DATA; 418 419 if (s->flags & WV_MONO_DATA) 420 shift_mono(samples_l, nb_samples, total_shift); 421 else 422 shift_stereo(samples_l, samples_r, nb_samples, total_shift); 423 } 424} 425 426static int scan_int32(WavPackEncodeContext *s, 427 int32_t *samples_l, int32_t *samples_r, 428 int nb_samples) 429{ 430 uint32_t magdata = 0, ordata = 0, xordata = 0, anddata = ~0; 431 uint32_t crc = 0xffffffffu; 432 int i, total_shift = 0; 433 434 s->int32_sent_bits = s->int32_zeros = s->int32_ones = s->int32_dups = 0; 435 436 if (s->flags & WV_MONO_DATA) { 437 for (i = 0; i < nb_samples; i++) { 438 int32_t M = samples_l[i]; 439 440 crc = crc * 9 + (M & 0xffff) * 3 + ((M >> 16) & 0xffff); 441 magdata |= (M < 0) ? ~M : M; 442 xordata |= M ^ -(M & 1); 443 anddata &= M; 444 ordata |= M; 445 } 446 } else { 447 for (i = 0; i < nb_samples; i++) { 448 int32_t L = samples_l[i]; 449 int32_t R = samples_r[i]; 450 451 crc = crc * 9 + (L & 0xffff) * 3 + ((L >> 16) & 0xffff); 452 crc = crc * 9 + (R & 0xffff) * 3 + ((R >> 16) & 0xffff); 453 magdata |= (L < 0) ? ~L : L; 454 magdata |= (R < 0) ? ~R : R; 455 xordata |= L ^ -(L & 1); 456 xordata |= R ^ -(R & 1); 457 anddata &= L & R; 458 ordata |= L | R; 459 } 460 } 461 462 s->crc_x = crc; 463 s->flags &= ~MAG_MASK; 464 465 while (magdata) { 466 s->flags += 1 << MAG_LSB; 467 magdata >>= 1; 468 } 469 470 if (!((s->flags & MAG_MASK) >> MAG_LSB)) { 471 s->flags &= ~WV_INT32_DATA; 472 return 0; 473 } 474 475 if (!(ordata & 1)) 476 do { 477 s->flags -= 1 << MAG_LSB; 478 s->int32_zeros++; 479 total_shift++; 480 ordata >>= 1; 481 } while (!(ordata & 1)); 482 else if (anddata & 1) 483 do { 484 s->flags -= 1 << MAG_LSB; 485 s->int32_ones++; 486 total_shift++; 487 anddata >>= 1; 488 } while (anddata & 1); 489 else if (!(xordata & 2)) 490 do { 491 s->flags -= 1 << MAG_LSB; 492 s->int32_dups++; 493 total_shift++; 494 xordata >>= 1; 495 } while (!(xordata & 2)); 496 497 if (((s->flags & MAG_MASK) >> MAG_LSB) > 23) { 498 s->int32_sent_bits = (uint8_t)(((s->flags & MAG_MASK) >> MAG_LSB) - 23); 499 total_shift += s->int32_sent_bits; 500 s->flags &= ~MAG_MASK; 501 s->flags += 23 << MAG_LSB; 502 } 503 504 if (total_shift) { 505 s->flags |= WV_INT32_DATA; 506 507 if (s->flags & WV_MONO_DATA) 508 shift_mono(samples_l, nb_samples, total_shift); 509 else 510 shift_stereo(samples_l, samples_r, nb_samples, total_shift); 511 } 512 513 return s->int32_sent_bits; 514} 515 516static int8_t store_weight(int weight) 517{ 518 weight = av_clip(weight, -1024, 1024); 519 if (weight > 0) 520 weight -= (weight + 64) >> 7; 521 522 return (weight + 4) >> 3; 523} 524 525static int restore_weight(int8_t weight) 526{ 527 int result; 528 529 if ((result = (int) weight << 3) > 0) 530 result += (result + 64) >> 7; 531 532 return result; 533} 534 535static int log2s(int32_t value) 536{ 537 return (value < 0) ? -wp_log2(-value) : wp_log2(value); 538} 539 540static void decorr_mono(int32_t *in_samples, int32_t *out_samples, 541 int nb_samples, struct Decorr *dpp, int dir) 542{ 543 int m = 0, i; 544 545 dpp->sumA = 0; 546 547 if (dir < 0) { 548 out_samples += (nb_samples - 1); 549 in_samples += (nb_samples - 1); 550 } 551 552 dpp->weightA = restore_weight(store_weight(dpp->weightA)); 553 554 for (i = 0; i < MAX_TERM; i++) 555 dpp->samplesA[i] = wp_exp2(log2s(dpp->samplesA[i])); 556 557 if (dpp->value > MAX_TERM) { 558 while (nb_samples--) { 559 int32_t left, sam_A; 560 561 sam_A = ((3 - (dpp->value & 1)) * dpp->samplesA[0] - dpp->samplesA[1]) >> !(dpp->value & 1); 562 563 dpp->samplesA[1] = dpp->samplesA[0]; 564 dpp->samplesA[0] = left = in_samples[0]; 565 566 left -= APPLY_WEIGHT(dpp->weightA, sam_A); 567 UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam_A, left); 568 dpp->sumA += dpp->weightA; 569 out_samples[0] = left; 570 in_samples += dir; 571 out_samples += dir; 572 } 573 } else if (dpp->value > 0) { 574 while (nb_samples--) { 575 int k = (m + dpp->value) & (MAX_TERM - 1); 576 int32_t left, sam_A; 577 578 sam_A = dpp->samplesA[m]; 579 dpp->samplesA[k] = left = in_samples[0]; 580 m = (m + 1) & (MAX_TERM - 1); 581 582 left -= APPLY_WEIGHT(dpp->weightA, sam_A); 583 UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam_A, left); 584 dpp->sumA += dpp->weightA; 585 out_samples[0] = left; 586 in_samples += dir; 587 out_samples += dir; 588 } 589 } 590 591 if (m && dpp->value > 0 && dpp->value <= MAX_TERM) { 592 int32_t temp_A[MAX_TERM]; 593 594 memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA)); 595 596 for (i = 0; i < MAX_TERM; i++) { 597 dpp->samplesA[i] = temp_A[m]; 598 m = (m + 1) & (MAX_TERM - 1); 599 } 600 } 601} 602 603static void reverse_mono_decorr(struct Decorr *dpp) 604{ 605 if (dpp->value > MAX_TERM) { 606 int32_t sam_A; 607 608 if (dpp->value & 1) 609 sam_A = 2 * dpp->samplesA[0] - dpp->samplesA[1]; 610 else 611 sam_A = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1; 612 613 dpp->samplesA[1] = dpp->samplesA[0]; 614 dpp->samplesA[0] = sam_A; 615 616 if (dpp->value & 1) 617 sam_A = 2 * dpp->samplesA[0] - dpp->samplesA[1]; 618 else 619 sam_A = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1; 620 621 dpp->samplesA[1] = sam_A; 622 } else if (dpp->value > 1) { 623 int i, j, k; 624 625 for (i = 0, j = dpp->value - 1, k = 0; k < dpp->value / 2; i++, j--, k++) { 626 i &= (MAX_TERM - 1); 627 j &= (MAX_TERM - 1); 628 dpp->samplesA[i] ^= dpp->samplesA[j]; 629 dpp->samplesA[j] ^= dpp->samplesA[i]; 630 dpp->samplesA[i] ^= dpp->samplesA[j]; 631 } 632 } 633} 634 635static uint32_t log2sample(uint32_t v, int limit, uint32_t *result) 636{ 637 uint32_t dbits; 638 639 if ((v += v >> 9) < (1 << 8)) { 640 dbits = nbits_table[v]; 641 *result += (dbits << 8) + wp_log2_table[(v << (9 - dbits)) & 0xff]; 642 } else { 643 if (v < (1L << 16)) 644 dbits = nbits_table[v >> 8] + 8; 645 else if (v < (1L << 24)) 646 dbits = nbits_table[v >> 16] + 16; 647 else 648 dbits = nbits_table[v >> 24] + 24; 649 650 *result += dbits = (dbits << 8) + wp_log2_table[(v >> (dbits - 9)) & 0xff]; 651 652 if (limit && dbits >= limit) 653 return 1; 654 } 655 656 return 0; 657} 658 659static uint32_t log2mono(int32_t *samples, int nb_samples, int limit) 660{ 661 uint32_t result = 0; 662 while (nb_samples--) { 663 if (log2sample(abs(*samples++), limit, &result)) 664 return UINT32_MAX; 665 } 666 return result; 667} 668 669static uint32_t log2stereo(int32_t *samples_l, int32_t *samples_r, 670 int nb_samples, int limit) 671{ 672 uint32_t result = 0; 673 while (nb_samples--) { 674 if (log2sample(abs(*samples_l++), limit, &result) || 675 log2sample(abs(*samples_r++), limit, &result)) 676 return UINT32_MAX; 677 } 678 return result; 679} 680 681static void decorr_mono_buffer(int32_t *samples, int32_t *outsamples, 682 int nb_samples, struct Decorr *dpp, 683 int tindex) 684{ 685 struct Decorr dp, *dppi = dpp + tindex; 686 int delta = dppi->delta, pre_delta, term = dppi->value; 687 688 if (delta == 7) 689 pre_delta = 7; 690 else if (delta < 2) 691 pre_delta = 3; 692 else 693 pre_delta = delta + 1; 694 695 CLEAR(dp); 696 dp.value = term; 697 dp.delta = pre_delta; 698 decorr_mono(samples, outsamples, FFMIN(2048, nb_samples), &dp, -1); 699 dp.delta = delta; 700 701 if (tindex == 0) 702 reverse_mono_decorr(&dp); 703 else 704 CLEAR(dp.samplesA); 705 706 memcpy(dppi->samplesA, dp.samplesA, sizeof(dp.samplesA)); 707 dppi->weightA = dp.weightA; 708 709 if (delta == 0) { 710 dp.delta = 1; 711 decorr_mono(samples, outsamples, nb_samples, &dp, 1); 712 dp.delta = 0; 713 memcpy(dp.samplesA, dppi->samplesA, sizeof(dp.samplesA)); 714 dppi->weightA = dp.weightA = dp.sumA / nb_samples; 715 } 716 717 decorr_mono(samples, outsamples, nb_samples, &dp, 1); 718} 719 720static void recurse_mono(WavPackEncodeContext *s, WavPackExtraInfo *info, 721 int depth, int delta, uint32_t input_bits) 722{ 723 int term, branches = s->num_branches - depth; 724 int32_t *samples, *outsamples; 725 uint32_t term_bits[22], bits; 726 727 if (branches < 1 || depth + 1 == info->nterms) 728 branches = 1; 729 730 CLEAR(term_bits); 731 samples = s->sampleptrs[depth][0]; 732 outsamples = s->sampleptrs[depth + 1][0]; 733 734 for (term = 1; term <= 18; term++) { 735 if (term == 17 && branches == 1 && depth + 1 < info->nterms) 736 continue; 737 738 if (term > 8 && term < 17) 739 continue; 740 741 if (!s->extra_flags && (term > 4 && term < 17)) 742 continue; 743 744 info->dps[depth].value = term; 745 info->dps[depth].delta = delta; 746 decorr_mono_buffer(samples, outsamples, s->block_samples, info->dps, depth); 747 bits = log2mono(outsamples, s->block_samples, info->log_limit); 748 749 if (bits < info->best_bits) { 750 info->best_bits = bits; 751 CLEAR(s->decorr_passes); 752 memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * (depth + 1)); 753 memcpy(s->sampleptrs[info->nterms + 1][0], 754 s->sampleptrs[depth + 1][0], s->block_samples * 4); 755 } 756 757 term_bits[term + 3] = bits; 758 } 759 760 while (depth + 1 < info->nterms && branches--) { 761 uint32_t local_best_bits = input_bits; 762 int best_term = 0, i; 763 764 for (i = 0; i < 22; i++) 765 if (term_bits[i] && term_bits[i] < local_best_bits) { 766 local_best_bits = term_bits[i]; 767 best_term = i - 3; 768 } 769 770 if (!best_term) 771 break; 772 773 term_bits[best_term + 3] = 0; 774 775 info->dps[depth].value = best_term; 776 info->dps[depth].delta = delta; 777 decorr_mono_buffer(samples, outsamples, s->block_samples, info->dps, depth); 778 779 recurse_mono(s, info, depth + 1, delta, local_best_bits); 780 } 781} 782 783static void sort_mono(WavPackEncodeContext *s, WavPackExtraInfo *info) 784{ 785 int reversed = 1; 786 uint32_t bits; 787 788 while (reversed) { 789 int ri, i; 790 791 memcpy(info->dps, s->decorr_passes, sizeof(s->decorr_passes)); 792 reversed = 0; 793 794 for (ri = 0; ri < info->nterms && s->decorr_passes[ri].value; ri++) { 795 796 if (ri + 1 >= info->nterms || !s->decorr_passes[ri+1].value) 797 break; 798 799 if (s->decorr_passes[ri].value == s->decorr_passes[ri+1].value) { 800 decorr_mono_buffer(s->sampleptrs[ri][0], s->sampleptrs[ri+1][0], 801 s->block_samples, info->dps, ri); 802 continue; 803 } 804 805 info->dps[ri ] = s->decorr_passes[ri+1]; 806 info->dps[ri+1] = s->decorr_passes[ri ]; 807 808 for (i = ri; i < info->nterms && s->decorr_passes[i].value; i++) 809 decorr_mono_buffer(s->sampleptrs[i][0], s->sampleptrs[i+1][0], 810 s->block_samples, info->dps, i); 811 812 bits = log2mono(s->sampleptrs[i][0], s->block_samples, info->log_limit); 813 if (bits < info->best_bits) { 814 reversed = 1; 815 info->best_bits = bits; 816 CLEAR(s->decorr_passes); 817 memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i); 818 memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[i][0], 819 s->block_samples * 4); 820 } else { 821 info->dps[ri ] = s->decorr_passes[ri]; 822 info->dps[ri+1] = s->decorr_passes[ri+1]; 823 decorr_mono_buffer(s->sampleptrs[ri][0], s->sampleptrs[ri+1][0], 824 s->block_samples, info->dps, ri); 825 } 826 } 827 } 828} 829 830static void delta_mono(WavPackEncodeContext *s, WavPackExtraInfo *info) 831{ 832 int lower = 0, delta, d; 833 uint32_t bits; 834 835 if (!s->decorr_passes[0].value) 836 return; 837 delta = s->decorr_passes[0].delta; 838 839 for (d = delta - 1; d >= 0; d--) { 840 int i; 841 842 for (i = 0; i < info->nterms && s->decorr_passes[i].value; i++) { 843 info->dps[i].value = s->decorr_passes[i].value; 844 info->dps[i].delta = d; 845 decorr_mono_buffer(s->sampleptrs[i][0], s->sampleptrs[i+1][0], 846 s->block_samples, info->dps, i); 847 } 848 849 bits = log2mono(s->sampleptrs[i][0], s->block_samples, info->log_limit); 850 if (bits >= info->best_bits) 851 break; 852 853 lower = 1; 854 info->best_bits = bits; 855 CLEAR(s->decorr_passes); 856 memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i); 857 memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[i][0], 858 s->block_samples * 4); 859 } 860 861 for (d = delta + 1; !lower && d <= 7; d++) { 862 int i; 863 864 for (i = 0; i < info->nterms && s->decorr_passes[i].value; i++) { 865 info->dps[i].value = s->decorr_passes[i].value; 866 info->dps[i].delta = d; 867 decorr_mono_buffer(s->sampleptrs[i][0], s->sampleptrs[i+1][0], 868 s->block_samples, info->dps, i); 869 } 870 871 bits = log2mono(s->sampleptrs[i][0], s->block_samples, info->log_limit); 872 if (bits >= info->best_bits) 873 break; 874 875 info->best_bits = bits; 876 CLEAR(s->decorr_passes); 877 memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i); 878 memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[i][0], 879 s->block_samples * 4); 880 } 881} 882 883static int allocate_buffers2(WavPackEncodeContext *s, int nterms) 884{ 885 int i; 886 887 for (i = 0; i < nterms + 2; i++) { 888 av_fast_padded_malloc(&s->sampleptrs[i][0], &s->sampleptrs_size[i][0], 889 s->block_samples * 4); 890 if (!s->sampleptrs[i][0]) 891 return AVERROR(ENOMEM); 892 if (!(s->flags & WV_MONO_DATA)) { 893 av_fast_padded_malloc(&s->sampleptrs[i][1], &s->sampleptrs_size[i][1], 894 s->block_samples * 4); 895 if (!s->sampleptrs[i][1]) 896 return AVERROR(ENOMEM); 897 } 898 } 899 900 return 0; 901} 902 903static int allocate_buffers(WavPackEncodeContext *s) 904{ 905 int i; 906 907 for (i = 0; i < 2; i++) { 908 av_fast_padded_malloc(&s->best_buffer[0], &s->best_buffer_size[0], 909 s->block_samples * 4); 910 if (!s->best_buffer[0]) 911 return AVERROR(ENOMEM); 912 913 av_fast_padded_malloc(&s->temp_buffer[i][0], &s->temp_buffer_size[i][0], 914 s->block_samples * 4); 915 if (!s->temp_buffer[i][0]) 916 return AVERROR(ENOMEM); 917 if (!(s->flags & WV_MONO_DATA)) { 918 av_fast_padded_malloc(&s->best_buffer[1], &s->best_buffer_size[1], 919 s->block_samples * 4); 920 if (!s->best_buffer[1]) 921 return AVERROR(ENOMEM); 922 923 av_fast_padded_malloc(&s->temp_buffer[i][1], &s->temp_buffer_size[i][1], 924 s->block_samples * 4); 925 if (!s->temp_buffer[i][1]) 926 return AVERROR(ENOMEM); 927 } 928 } 929 930 return 0; 931} 932 933static void analyze_mono(WavPackEncodeContext *s, int32_t *samples, int do_samples) 934{ 935 WavPackExtraInfo info; 936 int i; 937 938 info.log_limit = (((s->flags & MAG_MASK) >> MAG_LSB) + 4) * 256; 939 info.log_limit = FFMIN(6912, info.log_limit); 940 941 info.nterms = s->num_terms; 942 943 if (allocate_buffers2(s, s->num_terms)) 944 return; 945 946 memcpy(info.dps, s->decorr_passes, sizeof(info.dps)); 947 memcpy(s->sampleptrs[0][0], samples, s->block_samples * 4); 948 949 for (i = 0; i < info.nterms && info.dps[i].value; i++) 950 decorr_mono(s->sampleptrs[i][0], s->sampleptrs[i + 1][0], 951 s->block_samples, info.dps + i, 1); 952 953 info.best_bits = log2mono(s->sampleptrs[info.nterms][0], s->block_samples, 0) * 1; 954 memcpy(s->sampleptrs[info.nterms + 1][0], s->sampleptrs[i][0], s->block_samples * 4); 955 956 if (s->extra_flags & EXTRA_BRANCHES) 957 recurse_mono(s, &info, 0, (int) floor(s->delta_decay + 0.5), 958 log2mono(s->sampleptrs[0][0], s->block_samples, 0)); 959 960 if (s->extra_flags & EXTRA_SORT_FIRST) 961 sort_mono(s, &info); 962 963 if (s->extra_flags & EXTRA_TRY_DELTAS) { 964 delta_mono(s, &info); 965 966 if ((s->extra_flags & EXTRA_ADJUST_DELTAS) && s->decorr_passes[0].value) 967 s->delta_decay = (float)((s->delta_decay * 2.0 + s->decorr_passes[0].delta) / 3.0); 968 else 969 s->delta_decay = 2.0; 970 } 971 972 if (s->extra_flags & EXTRA_SORT_LAST) 973 sort_mono(s, &info); 974 975 if (do_samples) 976 memcpy(samples, s->sampleptrs[info.nterms + 1][0], s->block_samples * 4); 977 978 for (i = 0; i < info.nterms; i++) 979 if (!s->decorr_passes[i].value) 980 break; 981 982 s->num_terms = i; 983} 984 985static void scan_word(WavPackEncodeContext *s, WvChannel *c, 986 int32_t *samples, int nb_samples, int dir) 987{ 988 if (dir < 0) 989 samples += nb_samples - 1; 990 991 while (nb_samples--) { 992 uint32_t low, value = labs(samples[0]); 993 994 if (value < GET_MED(0)) { 995 DEC_MED(0); 996 } else { 997 low = GET_MED(0); 998 INC_MED(0); 999 1000 if (value - low < GET_MED(1)) { 1001 DEC_MED(1); 1002 } else { 1003 low += GET_MED(1); 1004 INC_MED(1); 1005 1006 if (value - low < GET_MED(2)) { 1007 DEC_MED(2); 1008 } else { 1009 INC_MED(2); 1010 } 1011 } 1012 } 1013 samples += dir; 1014 } 1015} 1016 1017static int wv_mono(WavPackEncodeContext *s, int32_t *samples, 1018 int no_history, int do_samples) 1019{ 1020 struct Decorr temp_decorr_pass, save_decorr_passes[MAX_TERMS] = {{0}}; 1021 int nb_samples = s->block_samples; 1022 int buf_size = sizeof(int32_t) * nb_samples; 1023 uint32_t best_size = UINT32_MAX, size; 1024 int log_limit, pi, i, ret; 1025 1026 for (i = 0; i < nb_samples; i++) 1027 if (samples[i]) 1028 break; 1029 1030 if (i == nb_samples) { 1031 CLEAR(s->decorr_passes); 1032 CLEAR(s->w); 1033 s->num_terms = 0; 1034 return 0; 1035 } 1036 1037 log_limit = (((s->flags & MAG_MASK) >> MAG_LSB) + 4) * 256; 1038 log_limit = FFMIN(6912, log_limit); 1039 1040 if ((ret = allocate_buffers(s)) < 0) 1041 return ret; 1042 1043 if (no_history || s->num_passes >= 7) 1044 s->best_decorr = s->mask_decorr = 0; 1045 1046 for (pi = 0; pi < s->num_passes;) { 1047 const WavPackDecorrSpec *wpds; 1048 int nterms, c, j; 1049 1050 if (!pi) { 1051 c = s->best_decorr; 1052 } else { 1053 if (s->mask_decorr == 0) 1054 c = 0; 1055 else 1056 c = (s->best_decorr & (s->mask_decorr - 1)) | s->mask_decorr; 1057 1058 if (c == s->best_decorr) { 1059 s->mask_decorr = s->mask_decorr ? ((s->mask_decorr << 1) & (s->num_decorrs - 1)) : 1; 1060 continue; 1061 } 1062 } 1063 1064 wpds = &s->decorr_specs[c]; 1065 nterms = decorr_filter_nterms[s->decorr_filter]; 1066 1067 while (1) { 1068 memcpy(s->temp_buffer[0][0], samples, buf_size); 1069 CLEAR(save_decorr_passes); 1070 1071 for (j = 0; j < nterms; j++) { 1072 CLEAR(temp_decorr_pass); 1073 temp_decorr_pass.delta = wpds->delta; 1074 temp_decorr_pass.value = wpds->terms[j]; 1075 1076 if (temp_decorr_pass.value < 0) 1077 temp_decorr_pass.value = 1; 1078 1079 decorr_mono(s->temp_buffer[j&1][0], s->temp_buffer[~j&1][0], 1080 FFMIN(nb_samples, 2048), &temp_decorr_pass, -1); 1081 1082 if (j) { 1083 CLEAR(temp_decorr_pass.samplesA); 1084 } else { 1085 reverse_mono_decorr(&temp_decorr_pass); 1086 } 1087 1088 memcpy(save_decorr_passes + j, &temp_decorr_pass, sizeof(struct Decorr)); 1089 decorr_mono(s->temp_buffer[j&1][0], s->temp_buffer[~j&1][0], 1090 nb_samples, &temp_decorr_pass, 1); 1091 } 1092 1093 size = log2mono(s->temp_buffer[j&1][0], nb_samples, log_limit); 1094 if (size != UINT32_MAX || !nterms) 1095 break; 1096 nterms >>= 1; 1097 } 1098 1099 if (size < best_size) { 1100 memcpy(s->best_buffer[0], s->temp_buffer[j&1][0], buf_size); 1101 memcpy(s->decorr_passes, save_decorr_passes, sizeof(struct Decorr) * MAX_TERMS); 1102 s->num_terms = nterms; 1103 s->best_decorr = c; 1104 best_size = size; 1105 } 1106 1107 if (pi++) 1108 s->mask_decorr = s->mask_decorr ? ((s->mask_decorr << 1) & (s->num_decorrs - 1)) : 1; 1109 } 1110 1111 if (s->extra_flags) 1112 analyze_mono(s, samples, do_samples); 1113 else if (do_samples) 1114 memcpy(samples, s->best_buffer[0], buf_size); 1115 1116 if (no_history || s->extra_flags) { 1117 CLEAR(s->w); 1118 scan_word(s, &s->w.c[0], s->best_buffer[0], nb_samples, -1); 1119 } 1120 return 0; 1121} 1122 1123static void decorr_stereo(int32_t *in_left, int32_t *in_right, 1124 int32_t *out_left, int32_t *out_right, 1125 int nb_samples, struct Decorr *dpp, int dir) 1126{ 1127 int m = 0, i; 1128 1129 dpp->sumA = dpp->sumB = 0; 1130 1131 if (dir < 0) { 1132 out_left += nb_samples - 1; 1133 out_right += nb_samples - 1; 1134 in_left += nb_samples - 1; 1135 in_right += nb_samples - 1; 1136 } 1137 1138 dpp->weightA = restore_weight(store_weight(dpp->weightA)); 1139 dpp->weightB = restore_weight(store_weight(dpp->weightB)); 1140 1141 for (i = 0; i < MAX_TERM; i++) { 1142 dpp->samplesA[i] = wp_exp2(log2s(dpp->samplesA[i])); 1143 dpp->samplesB[i] = wp_exp2(log2s(dpp->samplesB[i])); 1144 } 1145 1146 switch (dpp->value) { 1147 case 2: 1148 while (nb_samples--) { 1149 int32_t sam, tmp; 1150 1151 sam = dpp->samplesA[0]; 1152 dpp->samplesA[0] = dpp->samplesA[1]; 1153 out_left[0] = tmp = (dpp->samplesA[1] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam); 1154 UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); 1155 dpp->sumA += dpp->weightA; 1156 1157 sam = dpp->samplesB[0]; 1158 dpp->samplesB[0] = dpp->samplesB[1]; 1159 out_right[0] = tmp = (dpp->samplesB[1] = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam); 1160 UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); 1161 dpp->sumB += dpp->weightB; 1162 1163 in_left += dir; 1164 out_left += dir; 1165 in_right += dir; 1166 out_right += dir; 1167 } 1168 break; 1169 case 17: 1170 while (nb_samples--) { 1171 int32_t sam, tmp; 1172 1173 sam = 2 * dpp->samplesA[0] - dpp->samplesA[1]; 1174 dpp->samplesA[1] = dpp->samplesA[0]; 1175 out_left[0] = tmp = (dpp->samplesA[0] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam); 1176 UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); 1177 dpp->sumA += dpp->weightA; 1178 1179 sam = 2 * dpp->samplesB[0] - dpp->samplesB[1]; 1180 dpp->samplesB[1] = dpp->samplesB[0]; 1181 out_right[0] = tmp = (dpp->samplesB[0] = in_right[0]) - APPLY_WEIGHT (dpp->weightB, sam); 1182 UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); 1183 dpp->sumB += dpp->weightB; 1184 1185 in_left += dir; 1186 out_left += dir; 1187 in_right += dir; 1188 out_right += dir; 1189 } 1190 break; 1191 case 18: 1192 while (nb_samples--) { 1193 int32_t sam, tmp; 1194 1195 sam = dpp->samplesA[0] + ((dpp->samplesA[0] - dpp->samplesA[1]) >> 1); 1196 dpp->samplesA[1] = dpp->samplesA[0]; 1197 out_left[0] = tmp = (dpp->samplesA[0] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam); 1198 UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); 1199 dpp->sumA += dpp->weightA; 1200 1201 sam = dpp->samplesB[0] + ((dpp->samplesB[0] - dpp->samplesB[1]) >> 1); 1202 dpp->samplesB[1] = dpp->samplesB[0]; 1203 out_right[0] = tmp = (dpp->samplesB[0] = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam); 1204 UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); 1205 dpp->sumB += dpp->weightB; 1206 1207 in_left += dir; 1208 out_left += dir; 1209 in_right += dir; 1210 out_right += dir; 1211 } 1212 break; 1213 default: { 1214 int k = dpp->value & (MAX_TERM - 1); 1215 1216 while (nb_samples--) { 1217 int32_t sam, tmp; 1218 1219 sam = dpp->samplesA[m]; 1220 out_left[0] = tmp = (dpp->samplesA[k] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam); 1221 UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); 1222 dpp->sumA += dpp->weightA; 1223 1224 sam = dpp->samplesB[m]; 1225 out_right[0] = tmp = (dpp->samplesB[k] = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam); 1226 UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); 1227 dpp->sumB += dpp->weightB; 1228 1229 in_left += dir; 1230 out_left += dir; 1231 in_right += dir; 1232 out_right += dir; 1233 m = (m + 1) & (MAX_TERM - 1); 1234 k = (k + 1) & (MAX_TERM - 1); 1235 } 1236 1237 if (m) { 1238 int32_t temp_A[MAX_TERM], temp_B[MAX_TERM]; 1239 int k; 1240 1241 memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA)); 1242 memcpy(temp_B, dpp->samplesB, sizeof(dpp->samplesB)); 1243 1244 for (k = 0; k < MAX_TERM; k++) { 1245 dpp->samplesA[k] = temp_A[m]; 1246 dpp->samplesB[k] = temp_B[m]; 1247 m = (m + 1) & (MAX_TERM - 1); 1248 } 1249 } 1250 break; 1251 } 1252 case -1: 1253 while (nb_samples--) { 1254 int32_t sam_A, sam_B, tmp; 1255 1256 sam_A = dpp->samplesA[0]; 1257 out_left[0] = tmp = (sam_B = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam_A); 1258 UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); 1259 dpp->sumA += dpp->weightA; 1260 1261 out_right[0] = tmp = (dpp->samplesA[0] = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam_B); 1262 UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); 1263 dpp->sumB += dpp->weightB; 1264 1265 in_left += dir; 1266 out_left += dir; 1267 in_right += dir; 1268 out_right += dir; 1269 } 1270 break; 1271 case -2: 1272 while (nb_samples--) { 1273 int32_t sam_A, sam_B, tmp; 1274 1275 sam_B = dpp->samplesB[0]; 1276 out_right[0] = tmp = (sam_A = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam_B); 1277 UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); 1278 dpp->sumB += dpp->weightB; 1279 1280 out_left[0] = tmp = (dpp->samplesB[0] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam_A); 1281 UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); 1282 dpp->sumA += dpp->weightA; 1283 1284 in_left += dir; 1285 out_left += dir; 1286 in_right += dir; 1287 out_right += dir; 1288 } 1289 break; 1290 case -3: 1291 while (nb_samples--) { 1292 int32_t sam_A, sam_B, tmp; 1293 1294 sam_A = dpp->samplesA[0]; 1295 sam_B = dpp->samplesB[0]; 1296 1297 dpp->samplesA[0] = tmp = in_right[0]; 1298 out_right[0] = tmp -= APPLY_WEIGHT(dpp->weightB, sam_B); 1299 UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); 1300 dpp->sumB += dpp->weightB; 1301 1302 dpp->samplesB[0] = tmp = in_left[0]; 1303 out_left[0] = tmp -= APPLY_WEIGHT(dpp->weightA, sam_A); 1304 UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); 1305 dpp->sumA += dpp->weightA; 1306 1307 in_left += dir; 1308 out_left += dir; 1309 in_right += dir; 1310 out_right += dir; 1311 } 1312 break; 1313 } 1314} 1315 1316static void reverse_decorr(struct Decorr *dpp) 1317{ 1318 if (dpp->value > MAX_TERM) { 1319 int32_t sam_A, sam_B; 1320 1321 if (dpp->value & 1) { 1322 sam_A = 2 * dpp->samplesA[0] - dpp->samplesA[1]; 1323 sam_B = 2 * dpp->samplesB[0] - dpp->samplesB[1]; 1324 } else { 1325 sam_A = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1; 1326 sam_B = (3 * dpp->samplesB[0] - dpp->samplesB[1]) >> 1; 1327 } 1328 1329 dpp->samplesA[1] = dpp->samplesA[0]; 1330 dpp->samplesB[1] = dpp->samplesB[0]; 1331 dpp->samplesA[0] = sam_A; 1332 dpp->samplesB[0] = sam_B; 1333 1334 if (dpp->value & 1) { 1335 sam_A = 2 * dpp->samplesA[0] - dpp->samplesA[1]; 1336 sam_B = 2 * dpp->samplesB[0] - dpp->samplesB[1]; 1337 } else { 1338 sam_A = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1; 1339 sam_B = (3 * dpp->samplesB[0] - dpp->samplesB[1]) >> 1; 1340 } 1341 1342 dpp->samplesA[1] = sam_A; 1343 dpp->samplesB[1] = sam_B; 1344 } else if (dpp->value > 1) { 1345 int i, j, k; 1346 1347 for (i = 0, j = dpp->value - 1, k = 0; k < dpp->value / 2; i++, j--, k++) { 1348 i &= (MAX_TERM - 1); 1349 j &= (MAX_TERM - 1); 1350 dpp->samplesA[i] ^= dpp->samplesA[j]; 1351 dpp->samplesA[j] ^= dpp->samplesA[i]; 1352 dpp->samplesA[i] ^= dpp->samplesA[j]; 1353 dpp->samplesB[i] ^= dpp->samplesB[j]; 1354 dpp->samplesB[j] ^= dpp->samplesB[i]; 1355 dpp->samplesB[i] ^= dpp->samplesB[j]; 1356 } 1357 } 1358} 1359 1360static void decorr_stereo_quick(int32_t *in_left, int32_t *in_right, 1361 int32_t *out_left, int32_t *out_right, 1362 int nb_samples, struct Decorr *dpp) 1363{ 1364 int m = 0, i; 1365 1366 dpp->weightA = restore_weight(store_weight(dpp->weightA)); 1367 dpp->weightB = restore_weight(store_weight(dpp->weightB)); 1368 1369 for (i = 0; i < MAX_TERM; i++) { 1370 dpp->samplesA[i] = wp_exp2(log2s(dpp->samplesA[i])); 1371 dpp->samplesB[i] = wp_exp2(log2s(dpp->samplesB[i])); 1372 } 1373 1374 switch (dpp->value) { 1375 case 2: 1376 for (i = 0; i < nb_samples; i++) { 1377 int32_t sam, tmp; 1378 1379 sam = dpp->samplesA[0]; 1380 dpp->samplesA[0] = dpp->samplesA[1]; 1381 out_left[i] = tmp = (dpp->samplesA[1] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam); 1382 UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); 1383 1384 sam = dpp->samplesB[0]; 1385 dpp->samplesB[0] = dpp->samplesB[1]; 1386 out_right[i] = tmp = (dpp->samplesB[1] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam); 1387 UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); 1388 } 1389 break; 1390 case 17: 1391 for (i = 0; i < nb_samples; i++) { 1392 int32_t sam, tmp; 1393 1394 sam = 2 * dpp->samplesA[0] - dpp->samplesA[1]; 1395 dpp->samplesA[1] = dpp->samplesA[0]; 1396 out_left[i] = tmp = (dpp->samplesA[0] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam); 1397 UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); 1398 1399 sam = 2 * dpp->samplesB[0] - dpp->samplesB[1]; 1400 dpp->samplesB[1] = dpp->samplesB[0]; 1401 out_right[i] = tmp = (dpp->samplesB[0] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam); 1402 UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); 1403 } 1404 break; 1405 case 18: 1406 for (i = 0; i < nb_samples; i++) { 1407 int32_t sam, tmp; 1408 1409 sam = dpp->samplesA[0] + ((dpp->samplesA[0] - dpp->samplesA[1]) >> 1); 1410 dpp->samplesA[1] = dpp->samplesA[0]; 1411 out_left[i] = tmp = (dpp->samplesA[0] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam); 1412 UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); 1413 1414 sam = dpp->samplesB[0] + ((dpp->samplesB[0] - dpp->samplesB[1]) >> 1); 1415 dpp->samplesB[1] = dpp->samplesB[0]; 1416 out_right[i] = tmp = (dpp->samplesB[0] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam); 1417 UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); 1418 } 1419 break; 1420 default: { 1421 int k = dpp->value & (MAX_TERM - 1); 1422 1423 for (i = 0; i < nb_samples; i++) { 1424 int32_t sam, tmp; 1425 1426 sam = dpp->samplesA[m]; 1427 out_left[i] = tmp = (dpp->samplesA[k] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam); 1428 UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); 1429 1430 sam = dpp->samplesB[m]; 1431 out_right[i] = tmp = (dpp->samplesB[k] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam); 1432 UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); 1433 1434 m = (m + 1) & (MAX_TERM - 1); 1435 k = (k + 1) & (MAX_TERM - 1); 1436 } 1437 1438 if (m) { 1439 int32_t temp_A[MAX_TERM], temp_B[MAX_TERM]; 1440 int k; 1441 1442 memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA)); 1443 memcpy(temp_B, dpp->samplesB, sizeof(dpp->samplesB)); 1444 1445 for (k = 0; k < MAX_TERM; k++) { 1446 dpp->samplesA[k] = temp_A[m]; 1447 dpp->samplesB[k] = temp_B[m]; 1448 m = (m + 1) & (MAX_TERM - 1); 1449 } 1450 } 1451 break; 1452 } 1453 case -1: 1454 for (i = 0; i < nb_samples; i++) { 1455 int32_t sam_A, sam_B, tmp; 1456 1457 sam_A = dpp->samplesA[0]; 1458 out_left[i] = tmp = (sam_B = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam_A); 1459 UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); 1460 1461 out_right[i] = tmp = (dpp->samplesA[0] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam_B); 1462 UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); 1463 } 1464 break; 1465 case -2: 1466 for (i = 0; i < nb_samples; i++) { 1467 int32_t sam_A, sam_B, tmp; 1468 1469 sam_B = dpp->samplesB[0]; 1470 out_right[i] = tmp = (sam_A = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam_B); 1471 UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); 1472 1473 out_left[i] = tmp = (dpp->samplesB[0] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam_A); 1474 UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); 1475 } 1476 break; 1477 case -3: 1478 for (i = 0; i < nb_samples; i++) { 1479 int32_t sam_A, sam_B, tmp; 1480 1481 sam_A = dpp->samplesA[0]; 1482 sam_B = dpp->samplesB[0]; 1483 1484 dpp->samplesA[0] = tmp = in_right[i]; 1485 out_right[i] = tmp -= APPLY_WEIGHT_I(dpp->weightB, sam_B); 1486 UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); 1487 1488 dpp->samplesB[0] = tmp = in_left[i]; 1489 out_left[i] = tmp -= APPLY_WEIGHT_I(dpp->weightA, sam_A); 1490 UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); 1491 } 1492 break; 1493 } 1494} 1495 1496static void decorr_stereo_buffer(WavPackExtraInfo *info, 1497 int32_t *in_left, int32_t *in_right, 1498 int32_t *out_left, int32_t *out_right, 1499 int nb_samples, int tindex) 1500{ 1501 struct Decorr dp = {0}, *dppi = info->dps + tindex; 1502 int delta = dppi->delta, pre_delta; 1503 int term = dppi->value; 1504 1505 if (delta == 7) 1506 pre_delta = 7; 1507 else if (delta < 2) 1508 pre_delta = 3; 1509 else 1510 pre_delta = delta + 1; 1511 1512 dp.value = term; 1513 dp.delta = pre_delta; 1514 decorr_stereo(in_left, in_right, out_left, out_right, 1515 FFMIN(2048, nb_samples), &dp, -1); 1516 dp.delta = delta; 1517 1518 if (tindex == 0) { 1519 reverse_decorr(&dp); 1520 } else { 1521 CLEAR(dp.samplesA); 1522 CLEAR(dp.samplesB); 1523 } 1524 1525 memcpy(dppi->samplesA, dp.samplesA, sizeof(dp.samplesA)); 1526 memcpy(dppi->samplesB, dp.samplesB, sizeof(dp.samplesB)); 1527 dppi->weightA = dp.weightA; 1528 dppi->weightB = dp.weightB; 1529 1530 if (delta == 0) { 1531 dp.delta = 1; 1532 decorr_stereo(in_left, in_right, out_left, out_right, nb_samples, &dp, 1); 1533 dp.delta = 0; 1534 memcpy(dp.samplesA, dppi->samplesA, sizeof(dp.samplesA)); 1535 memcpy(dp.samplesB, dppi->samplesB, sizeof(dp.samplesB)); 1536 dppi->weightA = dp.weightA = dp.sumA / nb_samples; 1537 dppi->weightB = dp.weightB = dp.sumB / nb_samples; 1538 } 1539 1540 if (info->gt16bit) 1541 decorr_stereo(in_left, in_right, out_left, out_right, 1542 nb_samples, &dp, 1); 1543 else 1544 decorr_stereo_quick(in_left, in_right, out_left, out_right, 1545 nb_samples, &dp); 1546} 1547 1548static void sort_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info) 1549{ 1550 int reversed = 1; 1551 uint32_t bits; 1552 1553 while (reversed) { 1554 int ri, i; 1555 1556 memcpy(info->dps, s->decorr_passes, sizeof(s->decorr_passes)); 1557 reversed = 0; 1558 1559 for (ri = 0; ri < info->nterms && s->decorr_passes[ri].value; ri++) { 1560 1561 if (ri + 1 >= info->nterms || !s->decorr_passes[ri+1].value) 1562 break; 1563 1564 if (s->decorr_passes[ri].value == s->decorr_passes[ri+1].value) { 1565 decorr_stereo_buffer(info, 1566 s->sampleptrs[ri ][0], s->sampleptrs[ri ][1], 1567 s->sampleptrs[ri+1][0], s->sampleptrs[ri+1][1], 1568 s->block_samples, ri); 1569 continue; 1570 } 1571 1572 info->dps[ri ] = s->decorr_passes[ri+1]; 1573 info->dps[ri+1] = s->decorr_passes[ri ]; 1574 1575 for (i = ri; i < info->nterms && s->decorr_passes[i].value; i++) 1576 decorr_stereo_buffer(info, 1577 s->sampleptrs[i ][0], s->sampleptrs[i ][1], 1578 s->sampleptrs[i+1][0], s->sampleptrs[i+1][1], 1579 s->block_samples, i); 1580 1581 bits = log2stereo(s->sampleptrs[i][0], s->sampleptrs[i][1], 1582 s->block_samples, info->log_limit); 1583 1584 if (bits < info->best_bits) { 1585 reversed = 1; 1586 info->best_bits = bits; 1587 CLEAR(s->decorr_passes); 1588 memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i); 1589 memcpy(s->sampleptrs[info->nterms + 1][0], 1590 s->sampleptrs[i][0], s->block_samples * 4); 1591 memcpy(s->sampleptrs[info->nterms + 1][1], 1592 s->sampleptrs[i][1], s->block_samples * 4); 1593 } else { 1594 info->dps[ri ] = s->decorr_passes[ri ]; 1595 info->dps[ri+1] = s->decorr_passes[ri+1]; 1596 decorr_stereo_buffer(info, 1597 s->sampleptrs[ri ][0], s->sampleptrs[ri ][1], 1598 s->sampleptrs[ri+1][0], s->sampleptrs[ri+1][1], 1599 s->block_samples, ri); 1600 } 1601 } 1602 } 1603} 1604 1605static void delta_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info) 1606{ 1607 int lower = 0, delta, d, i; 1608 uint32_t bits; 1609 1610 if (!s->decorr_passes[0].value) 1611 return; 1612 delta = s->decorr_passes[0].delta; 1613 1614 for (d = delta - 1; d >= 0; d--) { 1615 for (i = 0; i < info->nterms && s->decorr_passes[i].value; i++) { 1616 info->dps[i].value = s->decorr_passes[i].value; 1617 info->dps[i].delta = d; 1618 decorr_stereo_buffer(info, 1619 s->sampleptrs[i ][0], s->sampleptrs[i ][1], 1620 s->sampleptrs[i+1][0], s->sampleptrs[i+1][1], 1621 s->block_samples, i); 1622 } 1623 1624 bits = log2stereo(s->sampleptrs[i][0], s->sampleptrs[i][1], 1625 s->block_samples, info->log_limit); 1626 if (bits >= info->best_bits) 1627 break; 1628 lower = 1; 1629 info->best_bits = bits; 1630 CLEAR(s->decorr_passes); 1631 memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i); 1632 memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[i][0], 1633 s->block_samples * 4); 1634 memcpy(s->sampleptrs[info->nterms + 1][1], s->sampleptrs[i][1], 1635 s->block_samples * 4); 1636 } 1637 1638 for (d = delta + 1; !lower && d <= 7; d++) { 1639 for (i = 0; i < info->nterms && s->decorr_passes[i].value; i++) { 1640 info->dps[i].value = s->decorr_passes[i].value; 1641 info->dps[i].delta = d; 1642 decorr_stereo_buffer(info, 1643 s->sampleptrs[i ][0], s->sampleptrs[i ][1], 1644 s->sampleptrs[i+1][0], s->sampleptrs[i+1][1], 1645 s->block_samples, i); 1646 } 1647 1648 bits = log2stereo(s->sampleptrs[i][0], s->sampleptrs[i][1], 1649 s->block_samples, info->log_limit); 1650 1651 if (bits < info->best_bits) { 1652 info->best_bits = bits; 1653 CLEAR(s->decorr_passes); 1654 memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i); 1655 memcpy(s->sampleptrs[info->nterms + 1][0], 1656 s->sampleptrs[i][0], s->block_samples * 4); 1657 memcpy(s->sampleptrs[info->nterms + 1][1], 1658 s->sampleptrs[i][1], s->block_samples * 4); 1659 } 1660 else 1661 break; 1662 } 1663} 1664 1665static void recurse_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info, 1666 int depth, int delta, uint32_t input_bits) 1667{ 1668 int term, branches = s->num_branches - depth; 1669 int32_t *in_left, *in_right, *out_left, *out_right; 1670 uint32_t term_bits[22], bits; 1671 1672 if (branches < 1 || depth + 1 == info->nterms) 1673 branches = 1; 1674 1675 CLEAR(term_bits); 1676 in_left = s->sampleptrs[depth ][0]; 1677 in_right = s->sampleptrs[depth ][1]; 1678 out_left = s->sampleptrs[depth + 1][0]; 1679 out_right = s->sampleptrs[depth + 1][1]; 1680 1681 for (term = -3; term <= 18; term++) { 1682 if (!term || (term > 8 && term < 17)) 1683 continue; 1684 1685 if (term == 17 && branches == 1 && depth + 1 < info->nterms) 1686 continue; 1687 1688 if (term == -1 || term == -2) 1689 if (!(s->flags & WV_CROSS_DECORR)) 1690 continue; 1691 1692 if (!s->extra_flags && (term > 4 && term < 17)) 1693 continue; 1694 1695 info->dps[depth].value = term; 1696 info->dps[depth].delta = delta; 1697 decorr_stereo_buffer(info, in_left, in_right, out_left, out_right, 1698 s->block_samples, depth); 1699 bits = log2stereo(out_left, out_right, s->block_samples, info->log_limit); 1700 1701 if (bits < info->best_bits) { 1702 info->best_bits = bits; 1703 CLEAR(s->decorr_passes); 1704 memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * (depth + 1)); 1705 memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[depth + 1][0], 1706 s->block_samples * 4); 1707 memcpy(s->sampleptrs[info->nterms + 1][1], s->sampleptrs[depth + 1][1], 1708 s->block_samples * 4); 1709 } 1710 1711 term_bits[term + 3] = bits; 1712 } 1713 1714 while (depth + 1 < info->nterms && branches--) { 1715 uint32_t local_best_bits = input_bits; 1716 int best_term = 0, i; 1717 1718 for (i = 0; i < 22; i++) 1719 if (term_bits[i] && term_bits[i] < local_best_bits) { 1720 local_best_bits = term_bits[i]; 1721 best_term = i - 3; 1722 } 1723 1724 if (!best_term) 1725 break; 1726 1727 term_bits[best_term + 3] = 0; 1728 1729 info->dps[depth].value = best_term; 1730 info->dps[depth].delta = delta; 1731 decorr_stereo_buffer(info, in_left, in_right, out_left, out_right, 1732 s->block_samples, depth); 1733 1734 recurse_stereo(s, info, depth + 1, delta, local_best_bits); 1735 } 1736} 1737 1738static void analyze_stereo(WavPackEncodeContext *s, 1739 int32_t *in_left, int32_t *in_right, 1740 int do_samples) 1741{ 1742 WavPackExtraInfo info; 1743 int i; 1744 1745 info.gt16bit = ((s->flags & MAG_MASK) >> MAG_LSB) >= 16; 1746 1747 info.log_limit = (((s->flags & MAG_MASK) >> MAG_LSB) + 4) * 256; 1748 info.log_limit = FFMIN(6912, info.log_limit); 1749 1750 info.nterms = s->num_terms; 1751 1752 if (allocate_buffers2(s, s->num_terms)) 1753 return; 1754 1755 memcpy(info.dps, s->decorr_passes, sizeof(info.dps)); 1756 memcpy(s->sampleptrs[0][0], in_left, s->block_samples * 4); 1757 memcpy(s->sampleptrs[0][1], in_right, s->block_samples * 4); 1758 1759 for (i = 0; i < info.nterms && info.dps[i].value; i++) 1760 if (info.gt16bit) 1761 decorr_stereo(s->sampleptrs[i ][0], s->sampleptrs[i ][1], 1762 s->sampleptrs[i + 1][0], s->sampleptrs[i + 1][1], 1763 s->block_samples, info.dps + i, 1); 1764 else 1765 decorr_stereo_quick(s->sampleptrs[i ][0], s->sampleptrs[i ][1], 1766 s->sampleptrs[i + 1][0], s->sampleptrs[i + 1][1], 1767 s->block_samples, info.dps + i); 1768 1769 info.best_bits = log2stereo(s->sampleptrs[info.nterms][0], s->sampleptrs[info.nterms][1], 1770 s->block_samples, 0); 1771 1772 memcpy(s->sampleptrs[info.nterms + 1][0], s->sampleptrs[i][0], s->block_samples * 4); 1773 memcpy(s->sampleptrs[info.nterms + 1][1], s->sampleptrs[i][1], s->block_samples * 4); 1774 1775 if (s->extra_flags & EXTRA_BRANCHES) 1776 recurse_stereo(s, &info, 0, (int) floor(s->delta_decay + 0.5), 1777 log2stereo(s->sampleptrs[0][0], s->sampleptrs[0][1], 1778 s->block_samples, 0)); 1779 1780 if (s->extra_flags & EXTRA_SORT_FIRST) 1781 sort_stereo(s, &info); 1782 1783 if (s->extra_flags & EXTRA_TRY_DELTAS) { 1784 delta_stereo(s, &info); 1785 1786 if ((s->extra_flags & EXTRA_ADJUST_DELTAS) && s->decorr_passes[0].value) 1787 s->delta_decay = (float)((s->delta_decay * 2.0 + s->decorr_passes[0].delta) / 3.0); 1788 else 1789 s->delta_decay = 2.0; 1790 } 1791 1792 if (s->extra_flags & EXTRA_SORT_LAST) 1793 sort_stereo(s, &info); 1794 1795 if (do_samples) { 1796 memcpy(in_left, s->sampleptrs[info.nterms + 1][0], s->block_samples * 4); 1797 memcpy(in_right, s->sampleptrs[info.nterms + 1][1], s->block_samples * 4); 1798 } 1799 1800 for (i = 0; i < info.nterms; i++) 1801 if (!s->decorr_passes[i].value) 1802 break; 1803 1804 s->num_terms = i; 1805} 1806 1807static int wv_stereo(WavPackEncodeContext *s, 1808 int32_t *samples_l, int32_t *samples_r, 1809 int no_history, int do_samples) 1810{ 1811 struct Decorr temp_decorr_pass, save_decorr_passes[MAX_TERMS] = {{0}}; 1812 int nb_samples = s->block_samples, ret; 1813 int buf_size = sizeof(int32_t) * nb_samples; 1814 int log_limit, force_js = 0, force_ts = 0, got_js = 0, pi, i; 1815 uint32_t best_size = UINT32_MAX, size; 1816 1817 for (i = 0; i < nb_samples; i++) 1818 if (samples_l[i] || samples_r[i]) 1819 break; 1820 1821 if (i == nb_samples) { 1822 s->flags &= ~((uint32_t) WV_JOINT_STEREO); 1823 CLEAR(s->decorr_passes); 1824 CLEAR(s->w); 1825 s->num_terms = 0; 1826 return 0; 1827 } 1828 1829 log_limit = (((s->flags & MAG_MASK) >> MAG_LSB) + 4) * 256; 1830 log_limit = FFMIN(6912, log_limit); 1831 1832 if (s->joint) { 1833 force_js = s->joint > 0; 1834 force_ts = s->joint < 0; 1835 } 1836 1837 if ((ret = allocate_buffers(s)) < 0) 1838 return ret; 1839 1840 if (no_history || s->num_passes >= 7) 1841 s->best_decorr = s->mask_decorr = 0; 1842 1843 for (pi = 0; pi < s->num_passes;) { 1844 const WavPackDecorrSpec *wpds; 1845 int nterms, c, j; 1846 1847 if (!pi) 1848 c = s->best_decorr; 1849 else { 1850 if (s->mask_decorr == 0) 1851 c = 0; 1852 else 1853 c = (s->best_decorr & (s->mask_decorr - 1)) | s->mask_decorr; 1854 1855 if (c == s->best_decorr) { 1856 s->mask_decorr = s->mask_decorr ? ((s->mask_decorr << 1) & (s->num_decorrs - 1)) : 1; 1857 continue; 1858 } 1859 } 1860 1861 wpds = &s->decorr_specs[c]; 1862 nterms = decorr_filter_nterms[s->decorr_filter]; 1863 1864 while (1) { 1865 if (force_js || (wpds->joint_stereo && !force_ts)) { 1866 if (!got_js) { 1867 av_fast_padded_malloc(&s->js_left, &s->js_left_size, buf_size); 1868 av_fast_padded_malloc(&s->js_right, &s->js_right_size, buf_size); 1869 memcpy(s->js_left, samples_l, buf_size); 1870 memcpy(s->js_right, samples_r, buf_size); 1871 1872 for (i = 0; i < nb_samples; i++) 1873 s->js_right[i] += ((s->js_left[i] -= s->js_right[i]) >> 1); 1874 got_js = 1; 1875 } 1876 1877 memcpy(s->temp_buffer[0][0], s->js_left, buf_size); 1878 memcpy(s->temp_buffer[0][1], s->js_right, buf_size); 1879 } else { 1880 memcpy(s->temp_buffer[0][0], samples_l, buf_size); 1881 memcpy(s->temp_buffer[0][1], samples_r, buf_size); 1882 } 1883 1884 CLEAR(save_decorr_passes); 1885 1886 for (j = 0; j < nterms; j++) { 1887 CLEAR(temp_decorr_pass); 1888 temp_decorr_pass.delta = wpds->delta; 1889 temp_decorr_pass.value = wpds->terms[j]; 1890 1891 if (temp_decorr_pass.value < 0 && !(s->flags & WV_CROSS_DECORR)) 1892 temp_decorr_pass.value = -3; 1893 1894 decorr_stereo(s->temp_buffer[ j&1][0], s->temp_buffer[ j&1][1], 1895 s->temp_buffer[~j&1][0], s->temp_buffer[~j&1][1], 1896 FFMIN(2048, nb_samples), &temp_decorr_pass, -1); 1897 1898 if (j) { 1899 CLEAR(temp_decorr_pass.samplesA); 1900 CLEAR(temp_decorr_pass.samplesB); 1901 } else { 1902 reverse_decorr(&temp_decorr_pass); 1903 } 1904 1905 memcpy(save_decorr_passes + j, &temp_decorr_pass, sizeof(struct Decorr)); 1906 1907 if (((s->flags & MAG_MASK) >> MAG_LSB) >= 16) 1908 decorr_stereo(s->temp_buffer[ j&1][0], s->temp_buffer[ j&1][1], 1909 s->temp_buffer[~j&1][0], s->temp_buffer[~j&1][1], 1910 nb_samples, &temp_decorr_pass, 1); 1911 else 1912 decorr_stereo_quick(s->temp_buffer[ j&1][0], s->temp_buffer[ j&1][1], 1913 s->temp_buffer[~j&1][0], s->temp_buffer[~j&1][1], 1914 nb_samples, &temp_decorr_pass); 1915 } 1916 1917 size = log2stereo(s->temp_buffer[j&1][0], s->temp_buffer[j&1][1], 1918 nb_samples, log_limit); 1919 if (size != UINT32_MAX || !nterms) 1920 break; 1921 nterms >>= 1; 1922 } 1923 1924 if (size < best_size) { 1925 memcpy(s->best_buffer[0], s->temp_buffer[j&1][0], buf_size); 1926 memcpy(s->best_buffer[1], s->temp_buffer[j&1][1], buf_size); 1927 memcpy(s->decorr_passes, save_decorr_passes, sizeof(struct Decorr) * MAX_TERMS); 1928 s->num_terms = nterms; 1929 s->best_decorr = c; 1930 best_size = size; 1931 } 1932 1933 if (pi++) 1934 s->mask_decorr = s->mask_decorr ? ((s->mask_decorr << 1) & (s->num_decorrs - 1)) : 1; 1935 } 1936 1937 if (force_js || (s->decorr_specs[s->best_decorr].joint_stereo && !force_ts)) 1938 s->flags |= WV_JOINT_STEREO; 1939 else 1940 s->flags &= ~((uint32_t) WV_JOINT_STEREO); 1941 1942 if (s->extra_flags) { 1943 if (s->flags & WV_JOINT_STEREO) { 1944 analyze_stereo(s, s->js_left, s->js_right, do_samples); 1945 1946 if (do_samples) { 1947 memcpy(samples_l, s->js_left, buf_size); 1948 memcpy(samples_r, s->js_right, buf_size); 1949 } 1950 } else 1951 analyze_stereo(s, samples_l, samples_r, do_samples); 1952 } else if (do_samples) { 1953 memcpy(samples_l, s->best_buffer[0], buf_size); 1954 memcpy(samples_r, s->best_buffer[1], buf_size); 1955 } 1956 1957 if (s->extra_flags || no_history || 1958 s->joint_stereo != s->decorr_specs[s->best_decorr].joint_stereo) { 1959 s->joint_stereo = s->decorr_specs[s->best_decorr].joint_stereo; 1960 CLEAR(s->w); 1961 scan_word(s, &s->w.c[0], s->best_buffer[0], nb_samples, -1); 1962 scan_word(s, &s->w.c[1], s->best_buffer[1], nb_samples, -1); 1963 } 1964 return 0; 1965} 1966 1967#define count_bits(av) ( \ 1968 (av) < (1 << 8) ? nbits_table[av] : \ 1969 ( \ 1970 (av) < (1L << 16) ? nbits_table[(av) >> 8] + 8 : \ 1971 ((av) < (1L << 24) ? nbits_table[(av) >> 16] + 16 : nbits_table[(av) >> 24] + 24) \ 1972 ) \ 1973) 1974 1975static void encode_flush(WavPackEncodeContext *s) 1976{ 1977 WavPackWords *w = &s->w; 1978 PutBitContext *pb = &s->pb; 1979 1980 if (w->zeros_acc) { 1981 int cbits = count_bits(w->zeros_acc); 1982 1983 do { 1984 if (cbits > 31) { 1985 put_bits(pb, 31, 0x7FFFFFFF); 1986 cbits -= 31; 1987 } else { 1988 put_bits(pb, cbits, (1 << cbits) - 1); 1989 cbits = 0; 1990 } 1991 } while (cbits); 1992 1993 put_bits(pb, 1, 0); 1994 1995 while (w->zeros_acc > 1) { 1996 put_bits(pb, 1, w->zeros_acc & 1); 1997 w->zeros_acc >>= 1; 1998 } 1999 2000 w->zeros_acc = 0; 2001 } 2002 2003 if (w->holding_one) { 2004 if (w->holding_one >= 16) { 2005 int cbits; 2006 2007 put_bits(pb, 16, (1 << 16) - 1); 2008 put_bits(pb, 1, 0); 2009 w->holding_one -= 16; 2010 cbits = count_bits(w->holding_one); 2011 2012 do { 2013 if (cbits > 31) { 2014 put_bits(pb, 31, 0x7FFFFFFF); 2015 cbits -= 31; 2016 } else { 2017 put_bits(pb, cbits, (1 << cbits) - 1); 2018 cbits = 0; 2019 } 2020 } while (cbits); 2021 2022 put_bits(pb, 1, 0); 2023 2024 while (w->holding_one > 1) { 2025 put_bits(pb, 1, w->holding_one & 1); 2026 w->holding_one >>= 1; 2027 } 2028 2029 w->holding_zero = 0; 2030 } else { 2031 put_bits(pb, w->holding_one, (1 << w->holding_one) - 1); 2032 } 2033 2034 w->holding_one = 0; 2035 } 2036 2037 if (w->holding_zero) { 2038 put_bits(pb, 1, 0); 2039 w->holding_zero = 0; 2040 } 2041 2042 if (w->pend_count) { 2043 put_bits(pb, w->pend_count, w->pend_data); 2044 w->pend_data = w->pend_count = 0; 2045 } 2046} 2047 2048static void wavpack_encode_sample(WavPackEncodeContext *s, WvChannel *c, int32_t sample) 2049{ 2050 WavPackWords *w = &s->w; 2051 uint32_t ones_count, low, high; 2052 int sign = sample < 0; 2053 2054 if (s->w.c[0].median[0] < 2 && !s->w.holding_zero && s->w.c[1].median[0] < 2) { 2055 if (w->zeros_acc) { 2056 if (sample) 2057 encode_flush(s); 2058 else { 2059 w->zeros_acc++; 2060 return; 2061 } 2062 } else if (sample) { 2063 put_bits(&s->pb, 1, 0); 2064 } else { 2065 CLEAR(s->w.c[0].median); 2066 CLEAR(s->w.c[1].median); 2067 w->zeros_acc = 1; 2068 return; 2069 } 2070 } 2071 2072 if (sign) 2073 sample = ~sample; 2074 2075 if (sample < (int32_t) GET_MED(0)) { 2076 ones_count = low = 0; 2077 high = GET_MED(0) - 1; 2078 DEC_MED(0); 2079 } else { 2080 low = GET_MED(0); 2081 INC_MED(0); 2082 2083 if (sample - low < GET_MED(1)) { 2084 ones_count = 1; 2085 high = low + GET_MED(1) - 1; 2086 DEC_MED(1); 2087 } else { 2088 low += GET_MED(1); 2089 INC_MED(1); 2090 2091 if (sample - low < GET_MED(2)) { 2092 ones_count = 2; 2093 high = low + GET_MED(2) - 1; 2094 DEC_MED(2); 2095 } else { 2096 ones_count = 2 + (sample - low) / GET_MED(2); 2097 low += (ones_count - 2) * GET_MED(2); 2098 high = low + GET_MED(2) - 1; 2099 INC_MED(2); 2100 } 2101 } 2102 } 2103 2104 if (w->holding_zero) { 2105 if (ones_count) 2106 w->holding_one++; 2107 2108 encode_flush(s); 2109 2110 if (ones_count) { 2111 w->holding_zero = 1; 2112 ones_count--; 2113 } else 2114 w->holding_zero = 0; 2115 } else 2116 w->holding_zero = 1; 2117 2118 w->holding_one = ones_count * 2; 2119 2120 if (high != low) { 2121 uint32_t maxcode = high - low, code = sample - low; 2122 int bitcount = count_bits(maxcode); 2123 uint32_t extras = (1 << bitcount) - maxcode - 1; 2124 2125 if (code < extras) { 2126 w->pend_data |= code << w->pend_count; 2127 w->pend_count += bitcount - 1; 2128 } else { 2129 w->pend_data |= ((code + extras) >> 1) << w->pend_count; 2130 w->pend_count += bitcount - 1; 2131 w->pend_data |= ((code + extras) & 1) << w->pend_count++; 2132 } 2133 } 2134 2135 w->pend_data |= ((int32_t) sign << w->pend_count++); 2136 2137 if (!w->holding_zero) 2138 encode_flush(s); 2139} 2140 2141static void pack_int32(WavPackEncodeContext *s, 2142 int32_t *samples_l, int32_t *samples_r, 2143 int nb_samples) 2144{ 2145 const int sent_bits = s->int32_sent_bits; 2146 int32_t value, mask = (1 << sent_bits) - 1; 2147 PutBitContext *pb = &s->pb; 2148 int i, pre_shift; 2149 2150 pre_shift = s->int32_zeros + s->int32_ones + s->int32_dups; 2151 2152 if (!sent_bits) 2153 return; 2154 2155 if (s->flags & WV_MONO_DATA) { 2156 for (i = 0; i < nb_samples; i++) { 2157 value = (samples_l[i] >> pre_shift) & mask; 2158 put_bits(pb, sent_bits, value); 2159 } 2160 } else { 2161 for (i = 0; i < nb_samples; i++) { 2162 value = (samples_l[i] >> pre_shift) & mask; 2163 put_bits(pb, sent_bits, value); 2164 value = (samples_r[i] >> pre_shift) & mask; 2165 put_bits(pb, sent_bits, value); 2166 } 2167 } 2168} 2169 2170static void pack_float_sample(WavPackEncodeContext *s, int32_t *sample) 2171{ 2172 const int max_exp = s->float_max_exp; 2173 PutBitContext *pb = &s->pb; 2174 int32_t value, shift_count; 2175 2176 if (get_exponent(*sample) == 255) { 2177 if (get_mantissa(*sample)) { 2178 put_bits(pb, 1, 1); 2179 put_bits(pb, 23, get_mantissa(*sample)); 2180 } else { 2181 put_bits(pb, 1, 0); 2182 } 2183 2184 value = 0x1000000; 2185 shift_count = 0; 2186 } else if (get_exponent(*sample)) { 2187 shift_count = max_exp - get_exponent(*sample); 2188 value = 0x800000 + get_mantissa(*sample); 2189 } else { 2190 shift_count = max_exp ? max_exp - 1 : 0; 2191 value = get_mantissa(*sample); 2192 } 2193 2194 if (shift_count < 25) 2195 value >>= shift_count; 2196 else 2197 value = 0; 2198 2199 if (!value) { 2200 if (s->float_flags & FLOAT_ZEROS_SENT) { 2201 if (get_exponent(*sample) || get_mantissa(*sample)) { 2202 put_bits(pb, 1, 1); 2203 put_bits(pb, 23, get_mantissa(*sample)); 2204 2205 if (max_exp >= 25) 2206 put_bits(pb, 8, get_exponent(*sample)); 2207 2208 put_bits(pb, 1, get_sign(*sample)); 2209 } else { 2210 put_bits(pb, 1, 0); 2211 2212 if (s->float_flags & FLOAT_NEG_ZEROS) 2213 put_bits(pb, 1, get_sign(*sample)); 2214 } 2215 } 2216 } else if (shift_count) { 2217 if (s->float_flags & FLOAT_SHIFT_SENT) { 2218 int32_t data = get_mantissa(*sample) & ((1 << shift_count) - 1); 2219 put_bits(pb, shift_count, data); 2220 } else if (s->float_flags & FLOAT_SHIFT_SAME) { 2221 put_bits(pb, 1, get_mantissa(*sample) & 1); 2222 } 2223 } 2224} 2225 2226static void pack_float(WavPackEncodeContext *s, 2227 int32_t *samples_l, int32_t *samples_r, 2228 int nb_samples) 2229{ 2230 int i; 2231 2232 if (s->flags & WV_MONO_DATA) { 2233 for (i = 0; i < nb_samples; i++) 2234 pack_float_sample(s, &samples_l[i]); 2235 } else { 2236 for (i = 0; i < nb_samples; i++) { 2237 pack_float_sample(s, &samples_l[i]); 2238 pack_float_sample(s, &samples_r[i]); 2239 } 2240 } 2241} 2242 2243static void decorr_stereo_pass2(struct Decorr *dpp, 2244 int32_t *samples_l, int32_t *samples_r, 2245 int nb_samples) 2246{ 2247 int i, m, k; 2248 2249 switch (dpp->value) { 2250 case 17: 2251 for (i = 0; i < nb_samples; i++) { 2252 int32_t sam, tmp; 2253 2254 sam = 2 * dpp->samplesA[0] - dpp->samplesA[1]; 2255 dpp->samplesA[1] = dpp->samplesA[0]; 2256 samples_l[i] = tmp = (dpp->samplesA[0] = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam); 2257 UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); 2258 2259 sam = 2 * dpp->samplesB[0] - dpp->samplesB[1]; 2260 dpp->samplesB[1] = dpp->samplesB[0]; 2261 samples_r[i] = tmp = (dpp->samplesB[0] = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam); 2262 UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); 2263 } 2264 break; 2265 case 18: 2266 for (i = 0; i < nb_samples; i++) { 2267 int32_t sam, tmp; 2268 2269 sam = dpp->samplesA[0] + ((dpp->samplesA[0] - dpp->samplesA[1]) >> 1); 2270 dpp->samplesA[1] = dpp->samplesA[0]; 2271 samples_l[i] = tmp = (dpp->samplesA[0] = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam); 2272 UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); 2273 2274 sam = dpp->samplesB[0] + ((dpp->samplesB[0] - dpp->samplesB[1]) >> 1); 2275 dpp->samplesB[1] = dpp->samplesB[0]; 2276 samples_r[i] = tmp = (dpp->samplesB[0] = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam); 2277 UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); 2278 } 2279 break; 2280 default: 2281 for (m = 0, k = dpp->value & (MAX_TERM - 1), i = 0; i < nb_samples; i++) { 2282 int32_t sam, tmp; 2283 2284 sam = dpp->samplesA[m]; 2285 samples_l[i] = tmp = (dpp->samplesA[k] = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam); 2286 UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); 2287 2288 sam = dpp->samplesB[m]; 2289 samples_r[i] = tmp = (dpp->samplesB[k] = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam); 2290 UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); 2291 2292 m = (m + 1) & (MAX_TERM - 1); 2293 k = (k + 1) & (MAX_TERM - 1); 2294 } 2295 if (m) { 2296 int32_t temp_A[MAX_TERM], temp_B[MAX_TERM]; 2297 2298 memcpy(temp_A, dpp->samplesA, sizeof (dpp->samplesA)); 2299 memcpy(temp_B, dpp->samplesB, sizeof (dpp->samplesB)); 2300 2301 for (k = 0; k < MAX_TERM; k++) { 2302 dpp->samplesA[k] = temp_A[m]; 2303 dpp->samplesB[k] = temp_B[m]; 2304 m = (m + 1) & (MAX_TERM - 1); 2305 } 2306 } 2307 break; 2308 case -1: 2309 for (i = 0; i < nb_samples; i++) { 2310 int32_t sam_A, sam_B, tmp; 2311 2312 sam_A = dpp->samplesA[0]; 2313 samples_l[i] = tmp = (sam_B = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam_A); 2314 UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); 2315 2316 samples_r[i] = tmp = (dpp->samplesA[0] = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam_B); 2317 UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); 2318 } 2319 break; 2320 case -2: 2321 for (i = 0; i < nb_samples; i++) { 2322 int32_t sam_A, sam_B, tmp; 2323 2324 sam_B = dpp->samplesB[0]; 2325 samples_r[i] = tmp = (sam_A = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam_B); 2326 UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); 2327 2328 samples_l[i] = tmp = (dpp->samplesB[0] = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam_A); 2329 UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); 2330 } 2331 break; 2332 case -3: 2333 for (i = 0; i < nb_samples; i++) { 2334 int32_t sam_A, sam_B, tmp; 2335 2336 sam_A = dpp->samplesA[0]; 2337 sam_B = dpp->samplesB[0]; 2338 2339 dpp->samplesA[0] = tmp = samples_r[i]; 2340 samples_r[i] = tmp -= APPLY_WEIGHT(dpp->weightB, sam_B); 2341 UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); 2342 2343 dpp->samplesB[0] = tmp = samples_l[i]; 2344 samples_l[i] = tmp -= APPLY_WEIGHT(dpp->weightA, sam_A); 2345 UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); 2346 } 2347 break; 2348 } 2349} 2350 2351#define update_weight_d2(weight, delta, source, result) \ 2352 if (source && result) \ 2353 weight -= (((source ^ result) >> 29) & 4) - 2; 2354 2355#define update_weight_clip_d2(weight, delta, source, result) \ 2356 if (source && result) { \ 2357 const int32_t s = (source ^ result) >> 31; \ 2358 if ((weight = (weight ^ s) + (2 - s)) > 1024) weight = 1024; \ 2359 weight = (weight ^ s) - s; \ 2360 } 2361 2362static void decorr_stereo_pass_id2(struct Decorr *dpp, 2363 int32_t *samples_l, int32_t *samples_r, 2364 int nb_samples) 2365{ 2366 int i, m, k; 2367 2368 switch (dpp->value) { 2369 case 17: 2370 for (i = 0; i < nb_samples; i++) { 2371 int32_t sam, tmp; 2372 2373 sam = 2 * dpp->samplesA[0] - dpp->samplesA[1]; 2374 dpp->samplesA[1] = dpp->samplesA[0]; 2375 samples_l[i] = tmp = (dpp->samplesA[0] = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam); 2376 update_weight_d2(dpp->weightA, dpp->delta, sam, tmp); 2377 2378 sam = 2 * dpp->samplesB[0] - dpp->samplesB[1]; 2379 dpp->samplesB[1] = dpp->samplesB[0]; 2380 samples_r[i] = tmp = (dpp->samplesB[0] = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam); 2381 update_weight_d2(dpp->weightB, dpp->delta, sam, tmp); 2382 } 2383 break; 2384 case 18: 2385 for (i = 0; i < nb_samples; i++) { 2386 int32_t sam, tmp; 2387 2388 sam = dpp->samplesA[0] + ((dpp->samplesA[0] - dpp->samplesA[1]) >> 1); 2389 dpp->samplesA[1] = dpp->samplesA[0]; 2390 samples_l[i] = tmp = (dpp->samplesA[0] = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam); 2391 update_weight_d2(dpp->weightA, dpp->delta, sam, tmp); 2392 2393 sam = dpp->samplesB[0] + ((dpp->samplesB[0] - dpp->samplesB[1]) >> 1); 2394 dpp->samplesB[1] = dpp->samplesB[0]; 2395 samples_r[i] = tmp = (dpp->samplesB[0] = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam); 2396 update_weight_d2(dpp->weightB, dpp->delta, sam, tmp); 2397 } 2398 break; 2399 default: 2400 for (m = 0, k = dpp->value & (MAX_TERM - 1), i = 0; i < nb_samples; i++) { 2401 int32_t sam, tmp; 2402 2403 sam = dpp->samplesA[m]; 2404 samples_l[i] = tmp = (dpp->samplesA[k] = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam); 2405 update_weight_d2(dpp->weightA, dpp->delta, sam, tmp); 2406 2407 sam = dpp->samplesB[m]; 2408 samples_r[i] = tmp = (dpp->samplesB[k] = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam); 2409 update_weight_d2(dpp->weightB, dpp->delta, sam, tmp); 2410 2411 m = (m + 1) & (MAX_TERM - 1); 2412 k = (k + 1) & (MAX_TERM - 1); 2413 } 2414 2415 if (m) { 2416 int32_t temp_A[MAX_TERM], temp_B[MAX_TERM]; 2417 2418 memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA)); 2419 memcpy(temp_B, dpp->samplesB, sizeof(dpp->samplesB)); 2420 2421 for (k = 0; k < MAX_TERM; k++) { 2422 dpp->samplesA[k] = temp_A[m]; 2423 dpp->samplesB[k] = temp_B[m]; 2424 m = (m + 1) & (MAX_TERM - 1); 2425 } 2426 } 2427 break; 2428 case -1: 2429 for (i = 0; i < nb_samples; i++) { 2430 int32_t sam_A, sam_B, tmp; 2431 2432 sam_A = dpp->samplesA[0]; 2433 samples_l[i] = tmp = (sam_B = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam_A); 2434 update_weight_clip_d2(dpp->weightA, dpp->delta, sam_A, tmp); 2435 2436 samples_r[i] = tmp = (dpp->samplesA[0] = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam_B); 2437 update_weight_clip_d2(dpp->weightB, dpp->delta, sam_B, tmp); 2438 } 2439 break; 2440 case -2: 2441 for (i = 0; i < nb_samples; i++) { 2442 int32_t sam_A, sam_B, tmp; 2443 2444 sam_B = dpp->samplesB[0]; 2445 samples_r[i] = tmp = (sam_A = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam_B); 2446 update_weight_clip_d2(dpp->weightB, dpp->delta, sam_B, tmp); 2447 2448 samples_l[i] = tmp = (dpp->samplesB[0] = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam_A); 2449 update_weight_clip_d2(dpp->weightA, dpp->delta, sam_A, tmp); 2450 } 2451 break; 2452 case -3: 2453 for (i = 0; i < nb_samples; i++) { 2454 int32_t sam_A, sam_B, tmp; 2455 2456 sam_A = dpp->samplesA[0]; 2457 sam_B = dpp->samplesB[0]; 2458 2459 dpp->samplesA[0] = tmp = samples_r[i]; 2460 samples_r[i] = tmp -= APPLY_WEIGHT_I(dpp->weightB, sam_B); 2461 update_weight_clip_d2(dpp->weightB, dpp->delta, sam_B, tmp); 2462 2463 dpp->samplesB[0] = tmp = samples_l[i]; 2464 samples_l[i] = tmp -= APPLY_WEIGHT_I(dpp->weightA, sam_A); 2465 update_weight_clip_d2(dpp->weightA, dpp->delta, sam_A, tmp); 2466 } 2467 break; 2468 } 2469} 2470 2471static void put_metadata_block(PutByteContext *pb, int flags, int size) 2472{ 2473 if (size & 1) 2474 flags |= WP_IDF_ODD; 2475 2476 bytestream2_put_byte(pb, flags); 2477 bytestream2_put_byte(pb, (size + 1) >> 1); 2478} 2479 2480static int wavpack_encode_block(WavPackEncodeContext *s, 2481 int32_t *samples_l, int32_t *samples_r, 2482 uint8_t *out, int out_size) 2483{ 2484 int block_size, start, end, data_size, tcount, temp, m = 0; 2485 int i, j, ret = 0, got_extra = 0, nb_samples = s->block_samples; 2486 uint32_t crc = 0xffffffffu; 2487 struct Decorr *dpp; 2488 PutByteContext pb; 2489 2490 if (!(s->flags & WV_MONO) && s->optimize_mono) { 2491 int32_t lor = 0, diff = 0; 2492 2493 for (i = 0; i < nb_samples; i++) { 2494 lor |= samples_l[i] | samples_r[i]; 2495 diff |= samples_l[i] - samples_r[i]; 2496 2497 if (lor && diff) 2498 break; 2499 } 2500 2501 if (i == nb_samples && lor && !diff) { 2502 s->flags &= ~(WV_JOINT_STEREO | WV_CROSS_DECORR); 2503 s->flags |= WV_FALSE_STEREO; 2504 2505 if (!s->false_stereo) { 2506 s->false_stereo = 1; 2507 s->num_terms = 0; 2508 CLEAR(s->w); 2509 } 2510 } else if (s->false_stereo) { 2511 s->false_stereo = 0; 2512 s->num_terms = 0; 2513 CLEAR(s->w); 2514 } 2515 } 2516 2517 if (s->flags & SHIFT_MASK) { 2518 int shift = (s->flags & SHIFT_MASK) >> SHIFT_LSB; 2519 int mag = (s->flags & MAG_MASK) >> MAG_LSB; 2520 2521 if (s->flags & WV_MONO_DATA) 2522 shift_mono(samples_l, nb_samples, shift); 2523 else 2524 shift_stereo(samples_l, samples_r, nb_samples, shift); 2525 2526 if ((mag -= shift) < 0) 2527 s->flags &= ~MAG_MASK; 2528 else 2529 s->flags -= (1 << MAG_LSB) * shift; 2530 } 2531 2532 if ((s->flags & WV_FLOAT_DATA) || (s->flags & MAG_MASK) >> MAG_LSB >= 24) { 2533 av_fast_padded_malloc(&s->orig_l, &s->orig_l_size, sizeof(int32_t) * nb_samples); 2534 memcpy(s->orig_l, samples_l, sizeof(int32_t) * nb_samples); 2535 if (!(s->flags & WV_MONO_DATA)) { 2536 av_fast_padded_malloc(&s->orig_r, &s->orig_r_size, sizeof(int32_t) * nb_samples); 2537 memcpy(s->orig_r, samples_r, sizeof(int32_t) * nb_samples); 2538 } 2539 2540 if (s->flags & WV_FLOAT_DATA) 2541 got_extra = scan_float(s, samples_l, samples_r, nb_samples); 2542 else 2543 got_extra = scan_int32(s, samples_l, samples_r, nb_samples); 2544 s->num_terms = 0; 2545 } else { 2546 scan_int23(s, samples_l, samples_r, nb_samples); 2547 if (s->shift != s->int32_zeros + s->int32_ones + s->int32_dups) { 2548 s->shift = s->int32_zeros + s->int32_ones + s->int32_dups; 2549 s->num_terms = 0; 2550 } 2551 } 2552 2553 if (!s->num_passes && !s->num_terms) { 2554 s->num_passes = 1; 2555 2556 if (s->flags & WV_MONO_DATA) 2557 ret = wv_mono(s, samples_l, 1, 0); 2558 else 2559 ret = wv_stereo(s, samples_l, samples_r, 1, 0); 2560 2561 s->num_passes = 0; 2562 } 2563 if (s->flags & WV_MONO_DATA) { 2564 for (i = 0; i < nb_samples; i++) 2565 crc += (crc << 1) + samples_l[i]; 2566 2567 if (s->num_passes) 2568 ret = wv_mono(s, samples_l, !s->num_terms, 1); 2569 } else { 2570 for (i = 0; i < nb_samples; i++) 2571 crc += (crc << 3) + (samples_l[i] << 1) + samples_l[i] + samples_r[i]; 2572 2573 if (s->num_passes) 2574 ret = wv_stereo(s, samples_l, samples_r, !s->num_terms, 1); 2575 } 2576 if (ret < 0) 2577 return ret; 2578 2579 if (!s->ch_offset) 2580 s->flags |= WV_INITIAL_BLOCK; 2581 2582 s->ch_offset += 1 + !(s->flags & WV_MONO); 2583 2584 if (s->ch_offset == s->avctx->channels) 2585 s->flags |= WV_FINAL_BLOCK; 2586 2587 bytestream2_init_writer(&pb, out, out_size); 2588 bytestream2_put_le32(&pb, MKTAG('w', 'v', 'p', 'k')); 2589 bytestream2_put_le32(&pb, 0); 2590 bytestream2_put_le16(&pb, 0x410); 2591 bytestream2_put_le16(&pb, 0); 2592 bytestream2_put_le32(&pb, 0); 2593 bytestream2_put_le32(&pb, s->sample_index); 2594 bytestream2_put_le32(&pb, nb_samples); 2595 bytestream2_put_le32(&pb, s->flags); 2596 bytestream2_put_le32(&pb, crc); 2597 2598 if (s->flags & WV_INITIAL_BLOCK && 2599 s->avctx->channel_layout != AV_CH_LAYOUT_MONO && 2600 s->avctx->channel_layout != AV_CH_LAYOUT_STEREO) { 2601 put_metadata_block(&pb, WP_ID_CHANINFO, 5); 2602 bytestream2_put_byte(&pb, s->avctx->channels); 2603 bytestream2_put_le32(&pb, s->avctx->channel_layout); 2604 bytestream2_put_byte(&pb, 0); 2605 } 2606 2607 if ((s->flags & SRATE_MASK) == SRATE_MASK) { 2608 put_metadata_block(&pb, WP_ID_SAMPLE_RATE, 3); 2609 bytestream2_put_le24(&pb, s->avctx->sample_rate); 2610 bytestream2_put_byte(&pb, 0); 2611 } 2612 2613 put_metadata_block(&pb, WP_ID_DECTERMS, s->num_terms); 2614 for (i = 0; i < s->num_terms; i++) { 2615 struct Decorr *dpp = &s->decorr_passes[i]; 2616 bytestream2_put_byte(&pb, ((dpp->value + 5) & 0x1f) | ((dpp->delta << 5) & 0xe0)); 2617 } 2618 if (s->num_terms & 1) 2619 bytestream2_put_byte(&pb, 0); 2620 2621#define WRITE_DECWEIGHT(type) do { \ 2622 temp = store_weight(type); \ 2623 bytestream2_put_byte(&pb, temp); \ 2624 type = restore_weight(temp); \ 2625 } while (0) 2626 2627 bytestream2_put_byte(&pb, WP_ID_DECWEIGHTS); 2628 bytestream2_put_byte(&pb, 0); 2629 start = bytestream2_tell_p(&pb); 2630 for (i = s->num_terms - 1; i >= 0; --i) { 2631 struct Decorr *dpp = &s->decorr_passes[i]; 2632 2633 if (store_weight(dpp->weightA) || 2634 (!(s->flags & WV_MONO_DATA) && store_weight(dpp->weightB))) 2635 break; 2636 } 2637 tcount = i + 1; 2638 for (i = 0; i < s->num_terms; i++) { 2639 struct Decorr *dpp = &s->decorr_passes[i]; 2640 if (i < tcount) { 2641 WRITE_DECWEIGHT(dpp->weightA); 2642 if (!(s->flags & WV_MONO_DATA)) 2643 WRITE_DECWEIGHT(dpp->weightB); 2644 } else { 2645 dpp->weightA = dpp->weightB = 0; 2646 } 2647 } 2648 end = bytestream2_tell_p(&pb); 2649 out[start - 2] = WP_ID_DECWEIGHTS | (((end - start) & 1) ? WP_IDF_ODD: 0); 2650 out[start - 1] = (end - start + 1) >> 1; 2651 if ((end - start) & 1) 2652 bytestream2_put_byte(&pb, 0); 2653 2654#define WRITE_DECSAMPLE(type) do { \ 2655 temp = log2s(type); \ 2656 type = wp_exp2(temp); \ 2657 bytestream2_put_le16(&pb, temp); \ 2658 } while (0) 2659 2660 bytestream2_put_byte(&pb, WP_ID_DECSAMPLES); 2661 bytestream2_put_byte(&pb, 0); 2662 start = bytestream2_tell_p(&pb); 2663 for (i = 0; i < s->num_terms; i++) { 2664 struct Decorr *dpp = &s->decorr_passes[i]; 2665 if (i == 0) { 2666 if (dpp->value > MAX_TERM) { 2667 WRITE_DECSAMPLE(dpp->samplesA[0]); 2668 WRITE_DECSAMPLE(dpp->samplesA[1]); 2669 if (!(s->flags & WV_MONO_DATA)) { 2670 WRITE_DECSAMPLE(dpp->samplesB[0]); 2671 WRITE_DECSAMPLE(dpp->samplesB[1]); 2672 } 2673 } else if (dpp->value < 0) { 2674 WRITE_DECSAMPLE(dpp->samplesA[0]); 2675 WRITE_DECSAMPLE(dpp->samplesB[0]); 2676 } else { 2677 for (j = 0; j < dpp->value; j++) { 2678 WRITE_DECSAMPLE(dpp->samplesA[j]); 2679 if (!(s->flags & WV_MONO_DATA)) 2680 WRITE_DECSAMPLE(dpp->samplesB[j]); 2681 } 2682 } 2683 } else { 2684 CLEAR(dpp->samplesA); 2685 CLEAR(dpp->samplesB); 2686 } 2687 } 2688 end = bytestream2_tell_p(&pb); 2689 out[start - 1] = (end - start) >> 1; 2690 2691#define WRITE_CHAN_ENTROPY(chan) do { \ 2692 for (i = 0; i < 3; i++) { \ 2693 temp = wp_log2(s->w.c[chan].median[i]); \ 2694 bytestream2_put_le16(&pb, temp); \ 2695 s->w.c[chan].median[i] = wp_exp2(temp); \ 2696 } \ 2697 } while (0) 2698 2699 put_metadata_block(&pb, WP_ID_ENTROPY, 6 * (1 + (!(s->flags & WV_MONO_DATA)))); 2700 WRITE_CHAN_ENTROPY(0); 2701 if (!(s->flags & WV_MONO_DATA)) 2702 WRITE_CHAN_ENTROPY(1); 2703 2704 if (s->flags & WV_FLOAT_DATA) { 2705 put_metadata_block(&pb, WP_ID_FLOATINFO, 4); 2706 bytestream2_put_byte(&pb, s->float_flags); 2707 bytestream2_put_byte(&pb, s->float_shift); 2708 bytestream2_put_byte(&pb, s->float_max_exp); 2709 bytestream2_put_byte(&pb, 127); 2710 } 2711 2712 if (s->flags & WV_INT32_DATA) { 2713 put_metadata_block(&pb, WP_ID_INT32INFO, 4); 2714 bytestream2_put_byte(&pb, s->int32_sent_bits); 2715 bytestream2_put_byte(&pb, s->int32_zeros); 2716 bytestream2_put_byte(&pb, s->int32_ones); 2717 bytestream2_put_byte(&pb, s->int32_dups); 2718 } 2719 2720 if (s->flags & WV_MONO_DATA && !s->num_passes) { 2721 for (i = 0; i < nb_samples; i++) { 2722 int32_t code = samples_l[i]; 2723 2724 for (tcount = s->num_terms, dpp = s->decorr_passes; tcount--; dpp++) { 2725 int32_t sam; 2726 2727 if (dpp->value > MAX_TERM) { 2728 if (dpp->value & 1) 2729 sam = 2 * dpp->samplesA[0] - dpp->samplesA[1]; 2730 else 2731 sam = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1; 2732 2733 dpp->samplesA[1] = dpp->samplesA[0]; 2734 dpp->samplesA[0] = code; 2735 } else { 2736 sam = dpp->samplesA[m]; 2737 dpp->samplesA[(m + dpp->value) & (MAX_TERM - 1)] = code; 2738 } 2739 2740 code -= APPLY_WEIGHT(dpp->weightA, sam); 2741 UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, code); 2742 } 2743 2744 m = (m + 1) & (MAX_TERM - 1); 2745 samples_l[i] = code; 2746 } 2747 if (m) { 2748 for (tcount = s->num_terms, dpp = s->decorr_passes; tcount--; dpp++) 2749 if (dpp->value > 0 && dpp->value <= MAX_TERM) { 2750 int32_t temp_A[MAX_TERM], temp_B[MAX_TERM]; 2751 int k; 2752 2753 memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA)); 2754 memcpy(temp_B, dpp->samplesB, sizeof(dpp->samplesB)); 2755 2756 for (k = 0; k < MAX_TERM; k++) { 2757 dpp->samplesA[k] = temp_A[m]; 2758 dpp->samplesB[k] = temp_B[m]; 2759 m = (m + 1) & (MAX_TERM - 1); 2760 } 2761 } 2762 } 2763 } else if (!s->num_passes) { 2764 if (s->flags & WV_JOINT_STEREO) { 2765 for (i = 0; i < nb_samples; i++) 2766 samples_r[i] += ((samples_l[i] -= samples_r[i]) >> 1); 2767 } 2768 2769 for (i = 0; i < s->num_terms; i++) { 2770 struct Decorr *dpp = &s->decorr_passes[i]; 2771 if (((s->flags & MAG_MASK) >> MAG_LSB) >= 16 || dpp->delta != 2) 2772 decorr_stereo_pass2(dpp, samples_l, samples_r, nb_samples); 2773 else 2774 decorr_stereo_pass_id2(dpp, samples_l, samples_r, nb_samples); 2775 } 2776 } 2777 2778 bytestream2_put_byte(&pb, WP_ID_DATA | WP_IDF_LONG); 2779 init_put_bits(&s->pb, pb.buffer + 3, bytestream2_get_bytes_left_p(&pb)); 2780 if (s->flags & WV_MONO_DATA) { 2781 for (i = 0; i < nb_samples; i++) 2782 wavpack_encode_sample(s, &s->w.c[0], s->samples[0][i]); 2783 } else { 2784 for (i = 0; i < nb_samples; i++) { 2785 wavpack_encode_sample(s, &s->w.c[0], s->samples[0][i]); 2786 wavpack_encode_sample(s, &s->w.c[1], s->samples[1][i]); 2787 } 2788 } 2789 encode_flush(s); 2790 flush_put_bits(&s->pb); 2791 data_size = put_bits_count(&s->pb) >> 3; 2792 bytestream2_put_le24(&pb, (data_size + 1) >> 1); 2793 bytestream2_skip_p(&pb, data_size); 2794 if (data_size & 1) 2795 bytestream2_put_byte(&pb, 0); 2796 2797 if (got_extra) { 2798 bytestream2_put_byte(&pb, WP_ID_EXTRABITS | WP_IDF_LONG); 2799 init_put_bits(&s->pb, pb.buffer + 7, bytestream2_get_bytes_left_p(&pb)); 2800 if (s->flags & WV_FLOAT_DATA) 2801 pack_float(s, s->orig_l, s->orig_r, nb_samples); 2802 else 2803 pack_int32(s, s->orig_l, s->orig_r, nb_samples); 2804 flush_put_bits(&s->pb); 2805 data_size = put_bits_count(&s->pb) >> 3; 2806 bytestream2_put_le24(&pb, (data_size + 5) >> 1); 2807 bytestream2_put_le32(&pb, s->crc_x); 2808 bytestream2_skip_p(&pb, data_size); 2809 if (data_size & 1) 2810 bytestream2_put_byte(&pb, 0); 2811 } 2812 2813 block_size = bytestream2_tell_p(&pb); 2814 AV_WL32(out + 4, block_size - 8); 2815 2816 return block_size; 2817} 2818 2819static void fill_buffer(WavPackEncodeContext *s, 2820 const int8_t *src, int32_t *dst, 2821 int nb_samples) 2822{ 2823 int i; 2824 2825#define COPY_SAMPLES(type, offset, shift) do { \ 2826 const type *sptr = (const type *)src; \ 2827 for (i = 0; i < nb_samples; i++) \ 2828 dst[i] = (sptr[i] - offset) >> shift; \ 2829 } while (0) 2830 2831 switch (s->avctx->sample_fmt) { 2832 case AV_SAMPLE_FMT_U8P: 2833 COPY_SAMPLES(int8_t, 0x80, 0); 2834 break; 2835 case AV_SAMPLE_FMT_S16P: 2836 COPY_SAMPLES(int16_t, 0, 0); 2837 break; 2838 case AV_SAMPLE_FMT_S32P: 2839 if (s->avctx->bits_per_raw_sample <= 24) { 2840 COPY_SAMPLES(int32_t, 0, 8); 2841 break; 2842 } 2843 case AV_SAMPLE_FMT_FLTP: 2844 memcpy(dst, src, nb_samples * 4); 2845 } 2846} 2847 2848static void set_samplerate(WavPackEncodeContext *s) 2849{ 2850 int i; 2851 2852 for (i = 0; i < 15; i++) { 2853 if (wv_rates[i] == s->avctx->sample_rate) 2854 break; 2855 } 2856 2857 s->flags = i << SRATE_LSB; 2858} 2859 2860static int wavpack_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, 2861 const AVFrame *frame, int *got_packet_ptr) 2862{ 2863 WavPackEncodeContext *s = avctx->priv_data; 2864 int buf_size, ret; 2865 uint8_t *buf; 2866 2867 s->block_samples = frame->nb_samples; 2868 av_fast_padded_malloc(&s->samples[0], &s->samples_size[0], 2869 sizeof(int32_t) * s->block_samples); 2870 if (!s->samples[0]) 2871 return AVERROR(ENOMEM); 2872 if (avctx->channels > 1) { 2873 av_fast_padded_malloc(&s->samples[1], &s->samples_size[1], 2874 sizeof(int32_t) * s->block_samples); 2875 if (!s->samples[1]) 2876 return AVERROR(ENOMEM); 2877 } 2878 2879 buf_size = s->block_samples * avctx->channels * 8 2880 + 200 /* for headers */; 2881 if ((ret = ff_alloc_packet2(avctx, avpkt, buf_size)) < 0) 2882 return ret; 2883 buf = avpkt->data; 2884 2885 for (s->ch_offset = 0; s->ch_offset < avctx->channels;) { 2886 set_samplerate(s); 2887 2888 switch (s->avctx->sample_fmt) { 2889 case AV_SAMPLE_FMT_S16P: s->flags |= 1; break; 2890 case AV_SAMPLE_FMT_S32P: s->flags |= 3 - (s->avctx->bits_per_raw_sample <= 24); break; 2891 case AV_SAMPLE_FMT_FLTP: s->flags |= 3 | WV_FLOAT_DATA; 2892 } 2893 2894 fill_buffer(s, frame->extended_data[s->ch_offset], s->samples[0], s->block_samples); 2895 if (avctx->channels - s->ch_offset == 1) { 2896 s->flags |= WV_MONO; 2897 } else { 2898 s->flags |= WV_CROSS_DECORR; 2899 fill_buffer(s, frame->extended_data[s->ch_offset + 1], s->samples[1], s->block_samples); 2900 } 2901 2902 s->flags += (1 << MAG_LSB) * ((s->flags & 3) * 8 + 7); 2903 2904 if ((ret = wavpack_encode_block(s, s->samples[0], s->samples[1], 2905 buf, buf_size)) < 0) 2906 return ret; 2907 2908 buf += ret; 2909 buf_size -= ret; 2910 } 2911 s->sample_index += frame->nb_samples; 2912 2913 avpkt->pts = frame->pts; 2914 avpkt->size = buf - avpkt->data; 2915 avpkt->duration = ff_samples_to_time_base(avctx, frame->nb_samples); 2916 *got_packet_ptr = 1; 2917 return 0; 2918} 2919 2920static av_cold int wavpack_encode_close(AVCodecContext *avctx) 2921{ 2922 WavPackEncodeContext *s = avctx->priv_data; 2923 int i; 2924 2925 for (i = 0; i < MAX_TERMS + 2; i++) { 2926 av_freep(&s->sampleptrs[i][0]); 2927 av_freep(&s->sampleptrs[i][1]); 2928 s->sampleptrs_size[i][0] = s->sampleptrs_size[i][1] = 0; 2929 } 2930 2931 for (i = 0; i < 2; i++) { 2932 av_freep(&s->samples[i]); 2933 s->samples_size[i] = 0; 2934 2935 av_freep(&s->best_buffer[i]); 2936 s->best_buffer_size[i] = 0; 2937 2938 av_freep(&s->temp_buffer[i][0]); 2939 av_freep(&s->temp_buffer[i][1]); 2940 s->temp_buffer_size[i][0] = s->temp_buffer_size[i][1] = 0; 2941 } 2942 2943 av_freep(&s->js_left); 2944 av_freep(&s->js_right); 2945 s->js_left_size = s->js_right_size = 0; 2946 2947 av_freep(&s->orig_l); 2948 av_freep(&s->orig_r); 2949 s->orig_l_size = s->orig_r_size = 0; 2950 2951 return 0; 2952} 2953 2954#define OFFSET(x) offsetof(WavPackEncodeContext, x) 2955#define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM 2956static const AVOption options[] = { 2957 { "joint_stereo", "", OFFSET(joint), AV_OPT_TYPE_INT, {.i64=0},-1, 1, FLAGS, "joint" }, 2958 { "on", "mid/side", 0, AV_OPT_TYPE_CONST, {.i64= 1}, 0, 0, FLAGS, "joint"}, 2959 { "off", "left/right", 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, FLAGS, "joint"}, 2960 { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 0}, 0, 0, FLAGS, "joint"}, 2961 { "optimize_mono", "", OFFSET(optimize_mono), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "opt_mono" }, 2962 { "on", NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "opt_mono"}, 2963 { "off", NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "opt_mono"}, 2964 { NULL }, 2965}; 2966 2967static const AVClass wavpack_encoder_class = { 2968 .class_name = "WavPack encoder", 2969 .item_name = av_default_item_name, 2970 .option = options, 2971 .version = LIBAVUTIL_VERSION_INT, 2972}; 2973 2974AVCodec ff_wavpack_encoder = { 2975 .name = "wavpack", 2976 .long_name = NULL_IF_CONFIG_SMALL("WavPack"), 2977 .type = AVMEDIA_TYPE_AUDIO, 2978 .id = AV_CODEC_ID_WAVPACK, 2979 .priv_data_size = sizeof(WavPackEncodeContext), 2980 .priv_class = &wavpack_encoder_class, 2981 .init = wavpack_encode_init, 2982 .encode2 = wavpack_encode_frame, 2983 .close = wavpack_encode_close, 2984 .capabilities = CODEC_CAP_SMALL_LAST_FRAME, 2985 .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_U8P, 2986 AV_SAMPLE_FMT_S16P, 2987 AV_SAMPLE_FMT_S32P, 2988 AV_SAMPLE_FMT_FLTP, 2989 AV_SAMPLE_FMT_NONE }, 2990}; 2991