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