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