1/* 2 * WavPack lossless audio decoder 3 * Copyright (c) 2006 Konstantin Shishkov 4 * 5 * This file is part of FFmpeg. 6 * 7 * FFmpeg is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * FFmpeg is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with FFmpeg; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21#define ALT_BITSTREAM_READER_LE 22#include "avcodec.h" 23#include "get_bits.h" 24#include "unary.h" 25 26/** 27 * @file 28 * WavPack lossless audio decoder 29 */ 30 31#define WV_MONO 0x00000004 32#define WV_JOINT_STEREO 0x00000010 33#define WV_FALSE_STEREO 0x40000000 34 35#define WV_HYBRID_MODE 0x00000008 36#define WV_HYBRID_SHAPE 0x00000008 37#define WV_HYBRID_BITRATE 0x00000200 38#define WV_HYBRID_BALANCE 0x00000400 39 40#define WV_FLT_SHIFT_ONES 0x01 41#define WV_FLT_SHIFT_SAME 0x02 42#define WV_FLT_SHIFT_SENT 0x04 43#define WV_FLT_ZERO_SENT 0x08 44#define WV_FLT_ZERO_SIGN 0x10 45 46enum WP_ID_Flags{ 47 WP_IDF_MASK = 0x1F, 48 WP_IDF_IGNORE = 0x20, 49 WP_IDF_ODD = 0x40, 50 WP_IDF_LONG = 0x80 51}; 52 53enum WP_ID{ 54 WP_ID_DUMMY = 0, 55 WP_ID_ENCINFO, 56 WP_ID_DECTERMS, 57 WP_ID_DECWEIGHTS, 58 WP_ID_DECSAMPLES, 59 WP_ID_ENTROPY, 60 WP_ID_HYBRID, 61 WP_ID_SHAPING, 62 WP_ID_FLOATINFO, 63 WP_ID_INT32INFO, 64 WP_ID_DATA, 65 WP_ID_CORR, 66 WP_ID_EXTRABITS, 67 WP_ID_CHANINFO 68}; 69 70typedef struct SavedContext { 71 int offset; 72 int size; 73 int bits_used; 74 uint32_t crc; 75} SavedContext; 76 77#define MAX_TERMS 16 78 79typedef struct Decorr { 80 int delta; 81 int value; 82 int weightA; 83 int weightB; 84 int samplesA[8]; 85 int samplesB[8]; 86} Decorr; 87 88typedef struct WvChannel { 89 int median[3]; 90 int slow_level, error_limit; 91 int bitrate_acc, bitrate_delta; 92} WvChannel; 93 94typedef struct WavpackContext { 95 AVCodecContext *avctx; 96 int frame_flags; 97 int stereo, stereo_in; 98 int joint; 99 uint32_t CRC; 100 GetBitContext gb; 101 int got_extra_bits; 102 uint32_t crc_extra_bits; 103 GetBitContext gb_extra_bits; 104 int data_size; // in bits 105 int samples; 106 int terms; 107 Decorr decorr[MAX_TERMS]; 108 int zero, one, zeroes; 109 int extra_bits; 110 int and, or, shift; 111 int post_shift; 112 int hybrid, hybrid_bitrate; 113 int float_flag; 114 int float_shift; 115 int float_max_exp; 116 WvChannel ch[2]; 117 int samples_left; 118 int max_samples; 119 int pos; 120 SavedContext sc, extra_sc; 121} WavpackContext; 122 123// exponent table copied from WavPack source 124static const uint8_t wp_exp2_table [256] = { 125 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b, 126 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16, 127 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23, 128 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 129 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d, 130 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b, 131 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 132 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 133 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 134 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a, 135 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 136 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 137 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 138 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4, 139 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9, 140 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff 141}; 142 143static const uint8_t wp_log2_table [] = { 144 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15, 145 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a, 146 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e, 147 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 148 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 149 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75, 150 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 151 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 152 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 153 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2, 154 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0, 155 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce, 156 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb, 157 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7, 158 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 159 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff 160}; 161 162static av_always_inline int wp_exp2(int16_t val) 163{ 164 int res, neg = 0; 165 166 if(val < 0){ 167 val = -val; 168 neg = 1; 169 } 170 171 res = wp_exp2_table[val & 0xFF] | 0x100; 172 val >>= 8; 173 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val)); 174 return neg ? -res : res; 175} 176 177static av_always_inline int wp_log2(int32_t val) 178{ 179 int bits; 180 181 if(!val) 182 return 0; 183 if(val == 1) 184 return 256; 185 val += val >> 9; 186 bits = av_log2(val) + 1; 187 if(bits < 9) 188 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF]; 189 else 190 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF]; 191} 192 193#define LEVEL_DECAY(a) ((a + 0x80) >> 8) 194 195// macros for manipulating median values 196#define GET_MED(n) ((c->median[n] >> 4) + 1) 197#define DEC_MED(n) c->median[n] -= ((c->median[n] + (128>>n) - 2) / (128>>n)) * 2 198#define INC_MED(n) c->median[n] += ((c->median[n] + (128>>n)) / (128>>n)) * 5 199 200// macros for applying weight 201#define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \ 202 if(samples && in){ \ 203 if((samples ^ in) < 0){ \ 204 weight -= delta; \ 205 if(weight < -1024) weight = -1024; \ 206 }else{ \ 207 weight += delta; \ 208 if(weight > 1024) weight = 1024; \ 209 } \ 210 } 211 212 213static av_always_inline int get_tail(GetBitContext *gb, int k) 214{ 215 int p, e, res; 216 217 if(k<1)return 0; 218 p = av_log2(k); 219 e = (1 << (p + 1)) - k - 1; 220 res = p ? get_bits(gb, p) : 0; 221 if(res >= e){ 222 res = (res<<1) - e + get_bits1(gb); 223 } 224 return res; 225} 226 227static void update_error_limit(WavpackContext *ctx) 228{ 229 int i, br[2], sl[2]; 230 231 for(i = 0; i <= ctx->stereo_in; i++){ 232 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta; 233 br[i] = ctx->ch[i].bitrate_acc >> 16; 234 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level); 235 } 236 if(ctx->stereo_in && ctx->hybrid_bitrate){ 237 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1; 238 if(balance > br[0]){ 239 br[1] = br[0] << 1; 240 br[0] = 0; 241 }else if(-balance > br[0]){ 242 br[0] <<= 1; 243 br[1] = 0; 244 }else{ 245 br[1] = br[0] + balance; 246 br[0] = br[0] - balance; 247 } 248 } 249 for(i = 0; i <= ctx->stereo_in; i++){ 250 if(ctx->hybrid_bitrate){ 251 if(sl[i] - br[i] > -0x100) 252 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100); 253 else 254 ctx->ch[i].error_limit = 0; 255 }else{ 256 ctx->ch[i].error_limit = wp_exp2(br[i]); 257 } 258 } 259} 260 261static int wv_get_value(WavpackContext *ctx, GetBitContext *gb, int channel, int *last) 262{ 263 int t, t2; 264 int sign, base, add, ret; 265 WvChannel *c = &ctx->ch[channel]; 266 267 *last = 0; 268 269 if((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) && !ctx->zero && !ctx->one){ 270 if(ctx->zeroes){ 271 ctx->zeroes--; 272 if(ctx->zeroes){ 273 c->slow_level -= LEVEL_DECAY(c->slow_level); 274 return 0; 275 } 276 }else{ 277 t = get_unary_0_33(gb); 278 if(t >= 2) t = get_bits(gb, t - 1) | (1 << (t-1)); 279 ctx->zeroes = t; 280 if(ctx->zeroes){ 281 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median)); 282 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median)); 283 c->slow_level -= LEVEL_DECAY(c->slow_level); 284 return 0; 285 } 286 } 287 } 288 289 if(get_bits_count(gb) >= ctx->data_size){ 290 *last = 1; 291 return 0; 292 } 293 294 if(ctx->zero){ 295 t = 0; 296 ctx->zero = 0; 297 }else{ 298 t = get_unary_0_33(gb); 299 if(get_bits_count(gb) >= ctx->data_size){ 300 *last = 1; 301 return 0; 302 } 303 if(t == 16) { 304 t2 = get_unary_0_33(gb); 305 if(t2 < 2) t += t2; 306 else t += get_bits(gb, t2 - 1) | (1 << (t2 - 1)); 307 } 308 309 if(ctx->one){ 310 ctx->one = t&1; 311 t = (t>>1) + 1; 312 }else{ 313 ctx->one = t&1; 314 t >>= 1; 315 } 316 ctx->zero = !ctx->one; 317 } 318 319 if(ctx->hybrid && !channel) 320 update_error_limit(ctx); 321 322 if(!t){ 323 base = 0; 324 add = GET_MED(0) - 1; 325 DEC_MED(0); 326 }else if(t == 1){ 327 base = GET_MED(0); 328 add = GET_MED(1) - 1; 329 INC_MED(0); 330 DEC_MED(1); 331 }else if(t == 2){ 332 base = GET_MED(0) + GET_MED(1); 333 add = GET_MED(2) - 1; 334 INC_MED(0); 335 INC_MED(1); 336 DEC_MED(2); 337 }else{ 338 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2); 339 add = GET_MED(2) - 1; 340 INC_MED(0); 341 INC_MED(1); 342 INC_MED(2); 343 } 344 if(!c->error_limit){ 345 ret = base + get_tail(gb, add); 346 }else{ 347 int mid = (base*2 + add + 1) >> 1; 348 while(add > c->error_limit){ 349 if(get_bits1(gb)){ 350 add -= (mid - base); 351 base = mid; 352 }else 353 add = mid - base - 1; 354 mid = (base*2 + add + 1) >> 1; 355 } 356 ret = mid; 357 } 358 sign = get_bits1(gb); 359 if(ctx->hybrid_bitrate) 360 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level); 361 return sign ? ~ret : ret; 362} 363 364static inline int wv_get_value_integer(WavpackContext *s, uint32_t *crc, int S) 365{ 366 int bit; 367 368 if(s->extra_bits){ 369 S <<= s->extra_bits; 370 371 if(s->got_extra_bits){ 372 S |= get_bits(&s->gb_extra_bits, s->extra_bits); 373 *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16); 374 } 375 } 376 bit = (S & s->and) | s->or; 377 return (((S + bit) << s->shift) - bit) << s->post_shift; 378} 379 380static float wv_get_value_float(WavpackContext *s, uint32_t *crc, int S) 381{ 382 union { 383 float f; 384 uint32_t u; 385 } value; 386 387 int sign; 388 int exp = s->float_max_exp; 389 390 if(s->got_extra_bits){ 391 const int max_bits = 1 + 23 + 8 + 1; 392 const int left_bits = get_bits_left(&s->gb_extra_bits); 393 394 if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits) 395 return 0.0; 396 } 397 398 if(S){ 399 S <<= s->float_shift; 400 sign = S < 0; 401 if(sign) 402 S = -S; 403 if(S >= 0x1000000){ 404 if(s->got_extra_bits && get_bits1(&s->gb_extra_bits)){ 405 S = get_bits(&s->gb_extra_bits, 23); 406 }else{ 407 S = 0; 408 } 409 exp = 255; 410 }else if(exp){ 411 int shift = 23 - av_log2(S); 412 exp = s->float_max_exp; 413 if(exp <= shift){ 414 shift = --exp; 415 } 416 exp -= shift; 417 418 if(shift){ 419 S <<= shift; 420 if((s->float_flag & WV_FLT_SHIFT_ONES) || 421 (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s->gb_extra_bits)) ){ 422 S |= (1 << shift) - 1; 423 } else if(s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)){ 424 S |= get_bits(&s->gb_extra_bits, shift); 425 } 426 } 427 }else{ 428 exp = s->float_max_exp; 429 } 430 S &= 0x7fffff; 431 }else{ 432 sign = 0; 433 exp = 0; 434 if(s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)){ 435 if(get_bits1(&s->gb_extra_bits)){ 436 S = get_bits(&s->gb_extra_bits, 23); 437 if(s->float_max_exp >= 25) 438 exp = get_bits(&s->gb_extra_bits, 8); 439 sign = get_bits1(&s->gb_extra_bits); 440 }else{ 441 if(s->float_flag & WV_FLT_ZERO_SIGN) 442 sign = get_bits1(&s->gb_extra_bits); 443 } 444 } 445 } 446 447 *crc = *crc * 27 + S * 9 + exp * 3 + sign; 448 449 value.u = (sign << 31) | (exp << 23) | S; 450 return value.f; 451} 452 453static void wv_reset_saved_context(WavpackContext *s) 454{ 455 s->pos = 0; 456 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF; 457} 458 459static inline int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, void *dst, const int type) 460{ 461 int i, j, count = 0; 462 int last, t; 463 int A, B, L, L2, R, R2; 464 int pos = s->pos; 465 uint32_t crc = s->sc.crc; 466 uint32_t crc_extra_bits = s->extra_sc.crc; 467 int16_t *dst16 = dst; 468 int32_t *dst32 = dst; 469 float *dstfl = dst; 470 471 if(s->samples_left == s->samples) 472 s->one = s->zero = s->zeroes = 0; 473 do{ 474 L = wv_get_value(s, gb, 0, &last); 475 if(last) break; 476 R = wv_get_value(s, gb, 1, &last); 477 if(last) break; 478 for(i = 0; i < s->terms; i++){ 479 t = s->decorr[i].value; 480 if(t > 0){ 481 if(t > 8){ 482 if(t & 1){ 483 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]; 484 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]; 485 }else{ 486 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1; 487 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1; 488 } 489 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0]; 490 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0]; 491 j = 0; 492 }else{ 493 A = s->decorr[i].samplesA[pos]; 494 B = s->decorr[i].samplesB[pos]; 495 j = (pos + t) & 7; 496 } 497 if(type != SAMPLE_FMT_S16){ 498 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10); 499 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10); 500 }else{ 501 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10); 502 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10); 503 } 504 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta; 505 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta; 506 s->decorr[i].samplesA[j] = L = L2; 507 s->decorr[i].samplesB[j] = R = R2; 508 }else if(t == -1){ 509 if(type != SAMPLE_FMT_S16) 510 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10); 511 else 512 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10); 513 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L); 514 L = L2; 515 if(type != SAMPLE_FMT_S16) 516 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10); 517 else 518 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10); 519 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R); 520 R = R2; 521 s->decorr[i].samplesA[0] = R; 522 }else{ 523 if(type != SAMPLE_FMT_S16) 524 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10); 525 else 526 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10); 527 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R); 528 R = R2; 529 530 if(t == -3){ 531 R2 = s->decorr[i].samplesA[0]; 532 s->decorr[i].samplesA[0] = R; 533 } 534 535 if(type != SAMPLE_FMT_S16) 536 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10); 537 else 538 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10); 539 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L); 540 L = L2; 541 s->decorr[i].samplesB[0] = L; 542 } 543 } 544 pos = (pos + 1) & 7; 545 if(s->joint) 546 L += (R -= (L >> 1)); 547 crc = (crc * 3 + L) * 3 + R; 548 549 if(type == SAMPLE_FMT_FLT){ 550 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L); 551 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R); 552 } else if(type == SAMPLE_FMT_S32){ 553 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L); 554 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R); 555 } else { 556 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L); 557 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R); 558 } 559 count++; 560 }while(!last && count < s->max_samples); 561 562 s->samples_left -= count; 563 if(!s->samples_left){ 564 if(crc != s->CRC){ 565 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n"); 566 return -1; 567 } 568 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){ 569 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n"); 570 return -1; 571 } 572 wv_reset_saved_context(s); 573 }else{ 574 s->pos = pos; 575 s->sc.crc = crc; 576 s->sc.bits_used = get_bits_count(&s->gb); 577 if(s->got_extra_bits){ 578 s->extra_sc.crc = crc_extra_bits; 579 s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits); 580 } 581 } 582 return count * 2; 583} 584 585static inline int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, void *dst, const int type) 586{ 587 int i, j, count = 0; 588 int last, t; 589 int A, S, T; 590 int pos = s->pos; 591 uint32_t crc = s->sc.crc; 592 uint32_t crc_extra_bits = s->extra_sc.crc; 593 int16_t *dst16 = dst; 594 int32_t *dst32 = dst; 595 float *dstfl = dst; 596 597 if(s->samples_left == s->samples) 598 s->one = s->zero = s->zeroes = 0; 599 do{ 600 T = wv_get_value(s, gb, 0, &last); 601 S = 0; 602 if(last) break; 603 for(i = 0; i < s->terms; i++){ 604 t = s->decorr[i].value; 605 if(t > 8){ 606 if(t & 1) 607 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]; 608 else 609 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1; 610 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0]; 611 j = 0; 612 }else{ 613 A = s->decorr[i].samplesA[pos]; 614 j = (pos + t) & 7; 615 } 616 if(type != SAMPLE_FMT_S16) 617 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10); 618 else 619 S = T + ((s->decorr[i].weightA * A + 512) >> 10); 620 if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta; 621 s->decorr[i].samplesA[j] = T = S; 622 } 623 pos = (pos + 1) & 7; 624 crc = crc * 3 + S; 625 626 if(type == SAMPLE_FMT_FLT) 627 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, S); 628 else if(type == SAMPLE_FMT_S32) 629 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, S); 630 else 631 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S); 632 count++; 633 }while(!last && count < s->samples); 634 635 s->samples_left -= count; 636 if(!s->samples_left){ 637 if(crc != s->CRC){ 638 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n"); 639 return -1; 640 } 641 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){ 642 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n"); 643 return -1; 644 } 645 wv_reset_saved_context(s); 646 }else{ 647 s->pos = pos; 648 s->sc.crc = crc; 649 s->sc.bits_used = get_bits_count(&s->gb); 650 if(s->got_extra_bits){ 651 s->extra_sc.crc = crc_extra_bits; 652 s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits); 653 } 654 } 655 return count; 656} 657 658static av_cold int wavpack_decode_init(AVCodecContext *avctx) 659{ 660 WavpackContext *s = avctx->priv_data; 661 662 s->avctx = avctx; 663 s->stereo = (avctx->channels == 2); 664 if(avctx->bits_per_coded_sample <= 16) 665 avctx->sample_fmt = SAMPLE_FMT_S16; 666 else 667 avctx->sample_fmt = SAMPLE_FMT_S32; 668 avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO; 669 670 wv_reset_saved_context(s); 671 672 return 0; 673} 674 675static int wavpack_decode_frame(AVCodecContext *avctx, 676 void *data, int *data_size, 677 AVPacket *avpkt) 678{ 679 const uint8_t *buf = avpkt->data; 680 int buf_size = avpkt->size; 681 WavpackContext *s = avctx->priv_data; 682 void *samples = data; 683 int samplecount; 684 int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0; 685 int got_hybrid = 0; 686 const uint8_t* buf_end = buf + buf_size; 687 int i, j, id, size, ssize, weights, t; 688 int bpp; 689 690 if (buf_size == 0){ 691 *data_size = 0; 692 return 0; 693 } 694 695 if(!s->samples_left){ 696 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr)); 697 memset(s->ch, 0, sizeof(s->ch)); 698 s->extra_bits = 0; 699 s->and = s->or = s->shift = 0; 700 s->got_extra_bits = 0; 701 } 702 703 s->samples = AV_RL32(buf); buf += 4; 704 if(!s->samples){ 705 *data_size = 0; 706 return buf_size; 707 } 708 s->frame_flags = AV_RL32(buf); buf += 4; 709 if(s->frame_flags&0x80){ 710 bpp = sizeof(float); 711 avctx->sample_fmt = SAMPLE_FMT_FLT; 712 } else if((s->frame_flags&0x03) <= 1){ 713 bpp = 2; 714 avctx->sample_fmt = SAMPLE_FMT_S16; 715 } else { 716 bpp = 4; 717 avctx->sample_fmt = SAMPLE_FMT_S32; 718 } 719 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo; 720 s->joint = s->frame_flags & WV_JOINT_STEREO; 721 s->hybrid = s->frame_flags & WV_HYBRID_MODE; 722 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE; 723 s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f); 724 s->CRC = AV_RL32(buf); buf += 4; 725 726 s->max_samples = *data_size / (bpp * avctx->channels); 727 s->max_samples = FFMIN(s->max_samples, s->samples); 728 if(s->samples_left > 0){ 729 s->max_samples = FFMIN(s->max_samples, s->samples_left); 730 buf = buf_end; 731 } 732 733 // parse metadata blocks 734 while(buf < buf_end){ 735 id = *buf++; 736 size = *buf++; 737 if(id & WP_IDF_LONG) { 738 size |= (*buf++) << 8; 739 size |= (*buf++) << 16; 740 } 741 size <<= 1; // size is specified in words 742 ssize = size; 743 if(id & WP_IDF_ODD) size--; 744 if(size < 0){ 745 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size); 746 break; 747 } 748 if(buf + ssize > buf_end){ 749 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size); 750 break; 751 } 752 if(id & WP_IDF_IGNORE){ 753 buf += ssize; 754 continue; 755 } 756 switch(id & WP_IDF_MASK){ 757 case WP_ID_DECTERMS: 758 s->terms = size; 759 if(s->terms > MAX_TERMS){ 760 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n"); 761 buf += ssize; 762 continue; 763 } 764 for(i = 0; i < s->terms; i++) { 765 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5; 766 s->decorr[s->terms - i - 1].delta = *buf >> 5; 767 buf++; 768 } 769 got_terms = 1; 770 break; 771 case WP_ID_DECWEIGHTS: 772 if(!got_terms){ 773 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n"); 774 continue; 775 } 776 weights = size >> s->stereo_in; 777 if(weights > MAX_TERMS || weights > s->terms){ 778 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n"); 779 buf += ssize; 780 continue; 781 } 782 for(i = 0; i < weights; i++) { 783 t = (int8_t)(*buf++); 784 s->decorr[s->terms - i - 1].weightA = t << 3; 785 if(s->decorr[s->terms - i - 1].weightA > 0) 786 s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7; 787 if(s->stereo_in){ 788 t = (int8_t)(*buf++); 789 s->decorr[s->terms - i - 1].weightB = t << 3; 790 if(s->decorr[s->terms - i - 1].weightB > 0) 791 s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7; 792 } 793 } 794 got_weights = 1; 795 break; 796 case WP_ID_DECSAMPLES: 797 if(!got_terms){ 798 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n"); 799 continue; 800 } 801 t = 0; 802 for(i = s->terms - 1; (i >= 0) && (t < size); i--) { 803 if(s->decorr[i].value > 8){ 804 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2; 805 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2; 806 if(s->stereo_in){ 807 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2; 808 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2; 809 t += 4; 810 } 811 t += 4; 812 }else if(s->decorr[i].value < 0){ 813 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2; 814 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2; 815 t += 4; 816 }else{ 817 for(j = 0; j < s->decorr[i].value; j++){ 818 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2; 819 if(s->stereo_in){ 820 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2; 821 } 822 } 823 t += s->decorr[i].value * 2 * (s->stereo_in + 1); 824 } 825 } 826 got_samples = 1; 827 break; 828 case WP_ID_ENTROPY: 829 if(size != 6 * (s->stereo_in + 1)){ 830 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size); 831 buf += ssize; 832 continue; 833 } 834 for(j = 0; j <= s->stereo_in; j++){ 835 for(i = 0; i < 3; i++){ 836 s->ch[j].median[i] = wp_exp2(AV_RL16(buf)); 837 buf += 2; 838 } 839 } 840 got_entropy = 1; 841 break; 842 case WP_ID_HYBRID: 843 if(s->hybrid_bitrate){ 844 for(i = 0; i <= s->stereo_in; i++){ 845 s->ch[i].slow_level = wp_exp2(AV_RL16(buf)); 846 buf += 2; 847 size -= 2; 848 } 849 } 850 for(i = 0; i < (s->stereo_in + 1); i++){ 851 s->ch[i].bitrate_acc = AV_RL16(buf) << 16; 852 buf += 2; 853 size -= 2; 854 } 855 if(size > 0){ 856 for(i = 0; i < (s->stereo_in + 1); i++){ 857 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf)); 858 buf += 2; 859 } 860 }else{ 861 for(i = 0; i < (s->stereo_in + 1); i++) 862 s->ch[i].bitrate_delta = 0; 863 } 864 got_hybrid = 1; 865 break; 866 case WP_ID_INT32INFO: 867 if(size != 4){ 868 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf); 869 buf += ssize; 870 continue; 871 } 872 if(buf[0]) 873 s->extra_bits = buf[0]; 874 else if(buf[1]) 875 s->shift = buf[1]; 876 else if(buf[2]){ 877 s->and = s->or = 1; 878 s->shift = buf[2]; 879 }else if(buf[3]){ 880 s->and = 1; 881 s->shift = buf[3]; 882 } 883 buf += 4; 884 break; 885 case WP_ID_FLOATINFO: 886 if(size != 4){ 887 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size); 888 buf += ssize; 889 continue; 890 } 891 s->float_flag = buf[0]; 892 s->float_shift = buf[1]; 893 s->float_max_exp = buf[2]; 894 buf += 4; 895 got_float = 1; 896 break; 897 case WP_ID_DATA: 898 s->sc.offset = buf - avpkt->data; 899 s->sc.size = size * 8; 900 init_get_bits(&s->gb, buf, size * 8); 901 s->data_size = size * 8; 902 buf += size; 903 got_bs = 1; 904 break; 905 case WP_ID_EXTRABITS: 906 if(size <= 4){ 907 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size); 908 buf += size; 909 continue; 910 } 911 s->extra_sc.offset = buf - avpkt->data; 912 s->extra_sc.size = size * 8; 913 init_get_bits(&s->gb_extra_bits, buf, size * 8); 914 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32); 915 buf += size; 916 s->got_extra_bits = 1; 917 break; 918 default: 919 buf += size; 920 } 921 if(id & WP_IDF_ODD) buf++; 922 } 923 if(!s->samples_left){ 924 if(!got_terms){ 925 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n"); 926 return -1; 927 } 928 if(!got_weights){ 929 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n"); 930 return -1; 931 } 932 if(!got_samples){ 933 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n"); 934 return -1; 935 } 936 if(!got_entropy){ 937 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n"); 938 return -1; 939 } 940 if(s->hybrid && !got_hybrid){ 941 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n"); 942 return -1; 943 } 944 if(!got_bs){ 945 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n"); 946 return -1; 947 } 948 if(!got_float && avctx->sample_fmt == SAMPLE_FMT_FLT){ 949 av_log(avctx, AV_LOG_ERROR, "Float information not found\n"); 950 return -1; 951 } 952 if(s->got_extra_bits && avctx->sample_fmt != SAMPLE_FMT_FLT){ 953 const int size = get_bits_left(&s->gb_extra_bits); 954 const int wanted = s->samples * s->extra_bits << s->stereo_in; 955 if(size < wanted){ 956 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n"); 957 s->got_extra_bits = 0; 958 } 959 } 960 s->samples_left = s->samples; 961 }else{ 962 init_get_bits(&s->gb, avpkt->data + s->sc.offset, s->sc.size); 963 skip_bits_long(&s->gb, s->sc.bits_used); 964 if(s->got_extra_bits){ 965 init_get_bits(&s->gb_extra_bits, avpkt->data + s->extra_sc.offset, 966 s->extra_sc.size); 967 skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used); 968 } 969 } 970 971 if(s->stereo_in){ 972 if(avctx->sample_fmt == SAMPLE_FMT_S16) 973 samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S16); 974 else if(avctx->sample_fmt == SAMPLE_FMT_S32) 975 samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S32); 976 else 977 samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_FLT); 978 979 }else{ 980 if(avctx->sample_fmt == SAMPLE_FMT_S16) 981 samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_S16); 982 else if(avctx->sample_fmt == SAMPLE_FMT_S32) 983 samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_S32); 984 else 985 samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_FLT); 986 987 if(s->stereo && avctx->sample_fmt == SAMPLE_FMT_S16){ 988 int16_t *dst = (int16_t*)samples + samplecount * 2; 989 int16_t *src = (int16_t*)samples + samplecount; 990 int cnt = samplecount; 991 while(cnt--){ 992 *--dst = *--src; 993 *--dst = *src; 994 } 995 samplecount *= 2; 996 }else if(s->stereo && avctx->sample_fmt == SAMPLE_FMT_S32){ 997 int32_t *dst = (int32_t*)samples + samplecount * 2; 998 int32_t *src = (int32_t*)samples + samplecount; 999 int cnt = samplecount; 1000 while(cnt--){ 1001 *--dst = *--src; 1002 *--dst = *src; 1003 } 1004 samplecount *= 2; 1005 }else if(s->stereo){ 1006 float *dst = (float*)samples + samplecount * 2; 1007 float *src = (float*)samples + samplecount; 1008 int cnt = samplecount; 1009 while(cnt--){ 1010 *--dst = *--src; 1011 *--dst = *src; 1012 } 1013 samplecount *= 2; 1014 } 1015 } 1016 *data_size = samplecount * bpp; 1017 1018 return s->samples_left > 0 ? 0 : buf_size; 1019} 1020 1021AVCodec wavpack_decoder = { 1022 "wavpack", 1023 AVMEDIA_TYPE_AUDIO, 1024 CODEC_ID_WAVPACK, 1025 sizeof(WavpackContext), 1026 wavpack_decode_init, 1027 NULL, 1028 NULL, 1029 wavpack_decode_frame, 1030 .capabilities = CODEC_CAP_SUBFRAMES, 1031 .long_name = NULL_IF_CONFIG_SMALL("WavPack"), 1032}; 1033