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 "bitstream.h" 24#include "unary.h" 25 26/** 27 * @file libavcodec/wavpack.c 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 40enum WP_ID_Flags{ 41 WP_IDF_MASK = 0x1F, 42 WP_IDF_IGNORE = 0x20, 43 WP_IDF_ODD = 0x40, 44 WP_IDF_LONG = 0x80 45}; 46 47enum WP_ID{ 48 WP_ID_DUMMY = 0, 49 WP_ID_ENCINFO, 50 WP_ID_DECTERMS, 51 WP_ID_DECWEIGHTS, 52 WP_ID_DECSAMPLES, 53 WP_ID_ENTROPY, 54 WP_ID_HYBRID, 55 WP_ID_SHAPING, 56 WP_ID_FLOATINFO, 57 WP_ID_INT32INFO, 58 WP_ID_DATA, 59 WP_ID_CORR, 60 WP_ID_FLT, 61 WP_ID_CHANINFO 62}; 63 64#define MAX_TERMS 16 65 66typedef struct Decorr { 67 int delta; 68 int value; 69 int weightA; 70 int weightB; 71 int samplesA[8]; 72 int samplesB[8]; 73} Decorr; 74 75typedef struct WvChannel { 76 int median[3]; 77 int slow_level, error_limit; 78 int bitrate_acc, bitrate_delta; 79} WvChannel; 80 81typedef struct WavpackContext { 82 AVCodecContext *avctx; 83 int frame_flags; 84 int stereo, stereo_in; 85 int joint; 86 uint32_t CRC; 87 GetBitContext gb; 88 int data_size; // in bits 89 int samples; 90 int terms; 91 Decorr decorr[MAX_TERMS]; 92 int zero, one, zeroes; 93 int and, or, shift; 94 int hybrid, hybrid_bitrate; 95 WvChannel ch[2]; 96} WavpackContext; 97 98// exponent table copied from WavPack source 99static const uint8_t wp_exp2_table [256] = { 100 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b, 101 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16, 102 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23, 103 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 104 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d, 105 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b, 106 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 107 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 108 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 109 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a, 110 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 111 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 112 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 113 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4, 114 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9, 115 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff 116}; 117 118static const uint8_t wp_log2_table [] = { 119 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15, 120 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a, 121 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e, 122 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 123 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 124 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75, 125 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 126 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 127 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 128 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2, 129 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0, 130 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce, 131 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb, 132 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7, 133 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 134 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff 135}; 136 137static av_always_inline int wp_exp2(int16_t val) 138{ 139 int res, neg = 0; 140 141 if(val < 0){ 142 val = -val; 143 neg = 1; 144 } 145 146 res = wp_exp2_table[val & 0xFF] | 0x100; 147 val >>= 8; 148 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val)); 149 return neg ? -res : res; 150} 151 152static av_always_inline int wp_log2(int32_t val) 153{ 154 int bits; 155 156 if(!val) 157 return 0; 158 if(val == 1) 159 return 256; 160 val += val >> 9; 161 bits = av_log2(val) + 1; 162 if(bits < 9) 163 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF]; 164 else 165 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF]; 166} 167 168#define LEVEL_DECAY(a) ((a + 0x80) >> 8) 169 170// macros for manipulating median values 171#define GET_MED(n) ((c->median[n] >> 4) + 1) 172#define DEC_MED(n) c->median[n] -= ((c->median[n] + (128>>n) - 2) / (128>>n)) * 2 173#define INC_MED(n) c->median[n] += ((c->median[n] + (128>>n)) / (128>>n)) * 5 174 175// macros for applying weight 176#define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \ 177 if(samples && in){ \ 178 if((samples ^ in) < 0){ \ 179 weight -= delta; \ 180 if(weight < -1024) weight = -1024; \ 181 }else{ \ 182 weight += delta; \ 183 if(weight > 1024) weight = 1024; \ 184 } \ 185 } 186 187 188static av_always_inline int get_tail(GetBitContext *gb, int k) 189{ 190 int p, e, res; 191 192 if(k<1)return 0; 193 p = av_log2(k); 194 e = (1 << (p + 1)) - k - 1; 195 res = p ? get_bits(gb, p) : 0; 196 if(res >= e){ 197 res = (res<<1) - e + get_bits1(gb); 198 } 199 return res; 200} 201 202static void update_error_limit(WavpackContext *ctx) 203{ 204 int i, br[2], sl[2]; 205 206 for(i = 0; i <= ctx->stereo_in; i++){ 207 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta; 208 br[i] = ctx->ch[i].bitrate_acc >> 16; 209 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level); 210 } 211 if(ctx->stereo_in && ctx->hybrid_bitrate){ 212 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1; 213 if(balance > br[0]){ 214 br[1] = br[0] << 1; 215 br[0] = 0; 216 }else if(-balance > br[0]){ 217 br[0] <<= 1; 218 br[1] = 0; 219 }else{ 220 br[1] = br[0] + balance; 221 br[0] = br[0] - balance; 222 } 223 } 224 for(i = 0; i <= ctx->stereo_in; i++){ 225 if(ctx->hybrid_bitrate){ 226 if(sl[i] - br[i] > -0x100) 227 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100); 228 else 229 ctx->ch[i].error_limit = 0; 230 }else{ 231 ctx->ch[i].error_limit = wp_exp2(br[i]); 232 } 233 } 234} 235 236static int wv_get_value(WavpackContext *ctx, GetBitContext *gb, int channel, int *last) 237{ 238 int t, t2; 239 int sign, base, add, ret; 240 WvChannel *c = &ctx->ch[channel]; 241 242 *last = 0; 243 244 if((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) && !ctx->zero && !ctx->one){ 245 if(ctx->zeroes){ 246 ctx->zeroes--; 247 if(ctx->zeroes){ 248 c->slow_level -= LEVEL_DECAY(c->slow_level); 249 return 0; 250 } 251 }else{ 252 t = get_unary_0_33(gb); 253 if(t >= 2) t = get_bits(gb, t - 1) | (1 << (t-1)); 254 ctx->zeroes = t; 255 if(ctx->zeroes){ 256 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median)); 257 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median)); 258 c->slow_level -= LEVEL_DECAY(c->slow_level); 259 return 0; 260 } 261 } 262 } 263 264 if(get_bits_count(gb) >= ctx->data_size){ 265 *last = 1; 266 return 0; 267 } 268 269 if(ctx->zero){ 270 t = 0; 271 ctx->zero = 0; 272 }else{ 273 t = get_unary_0_33(gb); 274 if(get_bits_count(gb) >= ctx->data_size){ 275 *last = 1; 276 return 0; 277 } 278 if(t == 16) { 279 t2 = get_unary_0_33(gb); 280 if(t2 < 2) t += t2; 281 else t += get_bits(gb, t2 - 1) | (1 << (t2 - 1)); 282 } 283 284 if(ctx->one){ 285 ctx->one = t&1; 286 t = (t>>1) + 1; 287 }else{ 288 ctx->one = t&1; 289 t >>= 1; 290 } 291 ctx->zero = !ctx->one; 292 } 293 294 if(ctx->hybrid && !channel) 295 update_error_limit(ctx); 296 297 if(!t){ 298 base = 0; 299 add = GET_MED(0) - 1; 300 DEC_MED(0); 301 }else if(t == 1){ 302 base = GET_MED(0); 303 add = GET_MED(1) - 1; 304 INC_MED(0); 305 DEC_MED(1); 306 }else if(t == 2){ 307 base = GET_MED(0) + GET_MED(1); 308 add = GET_MED(2) - 1; 309 INC_MED(0); 310 INC_MED(1); 311 DEC_MED(2); 312 }else{ 313 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2); 314 add = GET_MED(2) - 1; 315 INC_MED(0); 316 INC_MED(1); 317 INC_MED(2); 318 } 319 if(!c->error_limit){ 320 ret = base + get_tail(gb, add); 321 }else{ 322 int mid = (base*2 + add + 1) >> 1; 323 while(add > c->error_limit){ 324 if(get_bits1(gb)){ 325 add -= (mid - base); 326 base = mid; 327 }else 328 add = mid - base - 1; 329 mid = (base*2 + add + 1) >> 1; 330 } 331 ret = mid; 332 } 333 sign = get_bits1(gb); 334 if(ctx->hybrid_bitrate) 335 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level); 336 return sign ? ~ret : ret; 337} 338 339static int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, int16_t *dst) 340{ 341 int i, j, count = 0; 342 int last, t; 343 int A, B, L, L2, R, R2, bit; 344 int pos = 0; 345 uint32_t crc = 0xFFFFFFFF; 346 347 s->one = s->zero = s->zeroes = 0; 348 do{ 349 L = wv_get_value(s, gb, 0, &last); 350 if(last) break; 351 R = wv_get_value(s, gb, 1, &last); 352 if(last) break; 353 for(i = 0; i < s->terms; i++){ 354 t = s->decorr[i].value; 355 j = 0; 356 if(t > 0){ 357 if(t > 8){ 358 if(t & 1){ 359 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]; 360 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]; 361 }else{ 362 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1; 363 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1; 364 } 365 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0]; 366 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0]; 367 j = 0; 368 }else{ 369 A = s->decorr[i].samplesA[pos]; 370 B = s->decorr[i].samplesB[pos]; 371 j = (pos + t) & 7; 372 } 373 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10); 374 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10); 375 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta; 376 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta; 377 s->decorr[i].samplesA[j] = L = L2; 378 s->decorr[i].samplesB[j] = R = R2; 379 }else if(t == -1){ 380 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10); 381 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L); 382 L = L2; 383 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10); 384 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R); 385 R = R2; 386 s->decorr[i].samplesA[0] = R; 387 }else{ 388 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10); 389 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R); 390 R = R2; 391 392 if(t == -3){ 393 R2 = s->decorr[i].samplesA[0]; 394 s->decorr[i].samplesA[0] = R; 395 } 396 397 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10); 398 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L); 399 L = L2; 400 s->decorr[i].samplesB[0] = L; 401 } 402 } 403 pos = (pos + 1) & 7; 404 if(s->joint) 405 L += (R -= (L >> 1)); 406 crc = (crc * 3 + L) * 3 + R; 407 bit = (L & s->and) | s->or; 408 *dst++ = ((L + bit) << s->shift) - bit; 409 bit = (R & s->and) | s->or; 410 *dst++ = ((R + bit) << s->shift) - bit; 411 count++; 412 }while(!last && count < s->samples); 413 414 if(crc != s->CRC){ 415 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n"); 416 return -1; 417 } 418 return count * 2; 419} 420 421static int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, int16_t *dst) 422{ 423 int i, j, count = 0; 424 int last, t; 425 int A, S, T, bit; 426 int pos = 0; 427 uint32_t crc = 0xFFFFFFFF; 428 429 s->one = s->zero = s->zeroes = 0; 430 do{ 431 T = wv_get_value(s, gb, 0, &last); 432 S = 0; 433 if(last) break; 434 for(i = 0; i < s->terms; i++){ 435 t = s->decorr[i].value; 436 if(t > 8){ 437 if(t & 1) 438 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]; 439 else 440 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1; 441 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0]; 442 j = 0; 443 }else{ 444 A = s->decorr[i].samplesA[pos]; 445 j = (pos + t) & 7; 446 } 447 S = T + ((s->decorr[i].weightA * A + 512) >> 10); 448 if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta; 449 s->decorr[i].samplesA[j] = T = S; 450 } 451 pos = (pos + 1) & 7; 452 crc = crc * 3 + S; 453 bit = (S & s->and) | s->or; 454 *dst++ = ((S + bit) << s->shift) - bit; 455 count++; 456 }while(!last && count < s->samples); 457 458 if(crc != s->CRC){ 459 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n"); 460 return -1; 461 } 462 return count; 463} 464 465static av_cold int wavpack_decode_init(AVCodecContext *avctx) 466{ 467 WavpackContext *s = avctx->priv_data; 468 469 s->avctx = avctx; 470 s->stereo = (avctx->channels == 2); 471 avctx->sample_fmt = SAMPLE_FMT_S16; 472 avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO; 473 474 return 0; 475} 476 477static int wavpack_decode_frame(AVCodecContext *avctx, 478 void *data, int *data_size, 479 const uint8_t *buf, int buf_size) 480{ 481 WavpackContext *s = avctx->priv_data; 482 int16_t *samples = data; 483 int samplecount; 484 int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0; 485 int got_hybrid = 0; 486 const uint8_t* buf_end = buf + buf_size; 487 int i, j, id, size, ssize, weights, t; 488 489 if (buf_size == 0){ 490 *data_size = 0; 491 return 0; 492 } 493 494 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr)); 495 memset(s->ch, 0, sizeof(s->ch)); 496 s->and = s->or = s->shift = 0; 497 498 s->samples = AV_RL32(buf); buf += 4; 499 if(!s->samples){ 500 *data_size = 0; 501 return buf_size; 502 } 503 /* should not happen but who knows */ 504 if(s->samples * 2 * avctx->channels > *data_size){ 505 av_log(avctx, AV_LOG_ERROR, "Packet size is too big to be handled in lavc!\n"); 506 return -1; 507 } 508 s->frame_flags = AV_RL32(buf); buf += 4; 509 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo; 510 s->joint = s->frame_flags & WV_JOINT_STEREO; 511 s->hybrid = s->frame_flags & WV_HYBRID_MODE; 512 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE; 513 s->CRC = AV_RL32(buf); buf += 4; 514 // parse metadata blocks 515 while(buf < buf_end){ 516 id = *buf++; 517 size = *buf++; 518 if(id & WP_IDF_LONG) { 519 size |= (*buf++) << 8; 520 size |= (*buf++) << 16; 521 } 522 size <<= 1; // size is specified in words 523 ssize = size; 524 if(id & WP_IDF_ODD) size--; 525 if(size < 0){ 526 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size); 527 break; 528 } 529 if(buf + ssize > buf_end){ 530 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size); 531 break; 532 } 533 if(id & WP_IDF_IGNORE){ 534 buf += ssize; 535 continue; 536 } 537 switch(id & WP_IDF_MASK){ 538 case WP_ID_DECTERMS: 539 s->terms = size; 540 if(s->terms > MAX_TERMS){ 541 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n"); 542 buf += ssize; 543 continue; 544 } 545 for(i = 0; i < s->terms; i++) { 546 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5; 547 s->decorr[s->terms - i - 1].delta = *buf >> 5; 548 buf++; 549 } 550 got_terms = 1; 551 break; 552 case WP_ID_DECWEIGHTS: 553 if(!got_terms){ 554 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n"); 555 continue; 556 } 557 weights = size >> s->stereo_in; 558 if(weights > MAX_TERMS || weights > s->terms){ 559 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n"); 560 buf += ssize; 561 continue; 562 } 563 for(i = 0; i < weights; i++) { 564 t = (int8_t)(*buf++); 565 s->decorr[s->terms - i - 1].weightA = t << 3; 566 if(s->decorr[s->terms - i - 1].weightA > 0) 567 s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7; 568 if(s->stereo_in){ 569 t = (int8_t)(*buf++); 570 s->decorr[s->terms - i - 1].weightB = t << 3; 571 if(s->decorr[s->terms - i - 1].weightB > 0) 572 s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7; 573 } 574 } 575 got_weights = 1; 576 break; 577 case WP_ID_DECSAMPLES: 578 if(!got_terms){ 579 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n"); 580 continue; 581 } 582 t = 0; 583 for(i = s->terms - 1; (i >= 0) && (t < size); i--) { 584 if(s->decorr[i].value > 8){ 585 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2; 586 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2; 587 if(s->stereo_in){ 588 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2; 589 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2; 590 t += 4; 591 } 592 t += 4; 593 }else if(s->decorr[i].value < 0){ 594 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2; 595 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2; 596 t += 4; 597 }else{ 598 for(j = 0; j < s->decorr[i].value; j++){ 599 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2; 600 if(s->stereo_in){ 601 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2; 602 } 603 } 604 t += s->decorr[i].value * 2 * (s->stereo_in + 1); 605 } 606 } 607 got_samples = 1; 608 break; 609 case WP_ID_ENTROPY: 610 if(size != 6 * (s->stereo_in + 1)){ 611 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size); 612 buf += ssize; 613 continue; 614 } 615 for(j = 0; j <= s->stereo_in; j++){ 616 for(i = 0; i < 3; i++){ 617 s->ch[j].median[i] = wp_exp2(AV_RL16(buf)); 618 buf += 2; 619 } 620 } 621 got_entropy = 1; 622 break; 623 case WP_ID_HYBRID: 624 if(s->hybrid_bitrate){ 625 for(i = 0; i <= s->stereo_in; i++){ 626 s->ch[i].slow_level = wp_exp2(AV_RL16(buf)); 627 buf += 2; 628 size -= 2; 629 } 630 } 631 for(i = 0; i < (s->stereo_in + 1); i++){ 632 s->ch[i].bitrate_acc = AV_RL16(buf) << 16; 633 buf += 2; 634 size -= 2; 635 } 636 if(size > 0){ 637 for(i = 0; i < (s->stereo_in + 1); i++){ 638 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf)); 639 buf += 2; 640 } 641 }else{ 642 for(i = 0; i < (s->stereo_in + 1); i++) 643 s->ch[i].bitrate_delta = 0; 644 } 645 got_hybrid = 1; 646 break; 647 case WP_ID_INT32INFO: 648 if(size != 4 || *buf){ 649 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf); 650 buf += ssize; 651 continue; 652 } 653 if(buf[1]) 654 s->shift = buf[1]; 655 else if(buf[2]){ 656 s->and = s->or = 1; 657 s->shift = buf[2]; 658 }else if(buf[3]){ 659 s->and = 1; 660 s->shift = buf[3]; 661 } 662 buf += 4; 663 break; 664 case WP_ID_DATA: 665 init_get_bits(&s->gb, buf, size * 8); 666 s->data_size = size * 8; 667 buf += size; 668 got_bs = 1; 669 break; 670 default: 671 buf += size; 672 } 673 if(id & WP_IDF_ODD) buf++; 674 } 675 if(!got_terms){ 676 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n"); 677 return -1; 678 } 679 if(!got_weights){ 680 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n"); 681 return -1; 682 } 683 if(!got_samples){ 684 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n"); 685 return -1; 686 } 687 if(!got_entropy){ 688 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n"); 689 return -1; 690 } 691 if(s->hybrid && !got_hybrid){ 692 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n"); 693 return -1; 694 } 695 if(!got_bs){ 696 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n"); 697 return -1; 698 } 699 700 if(s->stereo_in) 701 samplecount = wv_unpack_stereo(s, &s->gb, samples); 702 else{ 703 samplecount = wv_unpack_mono(s, &s->gb, samples); 704 if(s->stereo){ 705 int16_t *dst = samples + samplecount * 2; 706 int16_t *src = samples + samplecount; 707 int cnt = samplecount; 708 while(cnt--){ 709 *--dst = *--src; 710 *--dst = *src; 711 } 712 samplecount *= 2; 713 } 714 } 715 *data_size = samplecount * 2; 716 717 return buf_size; 718} 719 720AVCodec wavpack_decoder = { 721 "wavpack", 722 CODEC_TYPE_AUDIO, 723 CODEC_ID_WAVPACK, 724 sizeof(WavpackContext), 725 wavpack_decode_init, 726 NULL, 727 NULL, 728 wavpack_decode_frame, 729 .long_name = NULL_IF_CONFIG_SMALL("WavPack"), 730}; 731