Mercurial > libavcodec.hg
annotate wavpack.c @ 11352:6e0af2cfdcfe libavcodec
Do MC and IDCT in coding (hilbert) order
This increases the slice size to 64 pixels, due to having to decode an
entire chroma superblock row per slice.
This can be up to 6% slower depending on clip and CPU, but is necessary
for future optimizations that gain significantly more than was lost.
author | conrad |
---|---|
date | Wed, 03 Mar 2010 23:27:40 +0000 |
parents | 4a0b77af9d9c |
children | 8a4984c5cacc |
rev | line source |
---|---|
3764 | 1 /* |
2 * WavPack lossless audio decoder | |
3 * Copyright (c) 2006 Konstantin Shishkov | |
4 * | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3782
diff
changeset
|
5 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3782
diff
changeset
|
6 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3782
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
3764 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3782
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
3764 | 11 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3782
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
3764 | 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 | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3782
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
3764 | 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
20 */ | |
21 #define ALT_BITSTREAM_READER_LE | |
22 #include "avcodec.h" | |
9428 | 23 #include "get_bits.h" |
5605 | 24 #include "unary.h" |
3764 | 25 |
26 /** | |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
8607
diff
changeset
|
27 * @file libavcodec/wavpack.c |
3764 | 28 * WavPack lossless audio decoder |
29 */ | |
30 | |
8607 | 31 #define WV_MONO 0x00000004 |
5538 | 32 #define WV_JOINT_STEREO 0x00000010 |
5539
1c67999f81c8
Support for WavPack version 0x410 (false stereo chunks)
kostya
parents:
5538
diff
changeset
|
33 #define WV_FALSE_STEREO 0x40000000 |
3764 | 34 |
8607 | 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 | |
9610
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
40 #define WV_FLT_SHIFT_ONES 0x01 |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
41 #define WV_FLT_SHIFT_SAME 0x02 |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
42 #define WV_FLT_SHIFT_SENT 0x04 |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
43 #define WV_FLT_ZERO_SENT 0x08 |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
44 #define WV_FLT_ZERO_SIGN 0x10 |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
45 |
3764 | 46 enum 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 | |
53 enum 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, | |
9589
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
66 WP_ID_EXTRABITS, |
3764 | 67 WP_ID_CHANINFO |
68 }; | |
69 | |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
70 typedef struct SavedContext { |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
71 int offset; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
72 int size; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
73 int bits_used; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
74 uint32_t crc; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
75 } SavedContext; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
76 |
3764 | 77 #define MAX_TERMS 16 |
78 | |
79 typedef 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 | |
8607 | 88 typedef struct WvChannel { |
89 int median[3]; | |
90 int slow_level, error_limit; | |
91 int bitrate_acc, bitrate_delta; | |
92 } WvChannel; | |
93 | |
3764 | 94 typedef struct WavpackContext { |
95 AVCodecContext *avctx; | |
8607 | 96 int frame_flags; |
5539
1c67999f81c8
Support for WavPack version 0x410 (false stereo chunks)
kostya
parents:
5538
diff
changeset
|
97 int stereo, stereo_in; |
3764 | 98 int joint; |
99 uint32_t CRC; | |
100 GetBitContext gb; | |
9589
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
101 int got_extra_bits; |
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
102 uint32_t crc_extra_bits; |
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
103 GetBitContext gb_extra_bits; |
3764 | 104 int data_size; // in bits |
105 int samples; | |
106 int terms; | |
107 Decorr decorr[MAX_TERMS]; | |
108 int zero, one, zeroes; | |
9589
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
109 int extra_bits; |
5482
bba203d5c5e7
Add the handling of the INT32INFO block to the WavPack decoder.
kostya
parents:
4690
diff
changeset
|
110 int and, or, shift; |
9542 | 111 int post_shift; |
8607 | 112 int hybrid, hybrid_bitrate; |
9610
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
113 int float_flag; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
114 int float_shift; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
115 int float_max_exp; |
8607 | 116 WvChannel ch[2]; |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
117 int samples_left; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
118 int max_samples; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
119 int pos; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
120 SavedContext sc, extra_sc; |
3764 | 121 } WavpackContext; |
122 | |
123 // exponent table copied from WavPack source | |
124 static 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 | |
8607 | 143 static 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 | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4021
diff
changeset
|
162 static av_always_inline int wp_exp2(int16_t val) |
3764 | 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 | |
8607 | 177 static 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 | |
3764 | 195 // macros for manipulating median values |
8607 | 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 | |
3764 | 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 | |
4283
d6f83e2f8804
rename always_inline to av_always_inline and move to common.h
mru
parents:
4021
diff
changeset
|
213 static av_always_inline int get_tail(GetBitContext *gb, int k) |
3764 | 214 { |
215 int p, e, res; | |
216 | |
4421 | 217 if(k<1)return 0; |
218 p = av_log2(k); | |
3764 | 219 e = (1 << (p + 1)) - k - 1; |
3782 | 220 res = p ? get_bits(gb, p) : 0; |
3764 | 221 if(res >= e){ |
222 res = (res<<1) - e + get_bits1(gb); | |
223 } | |
224 return res; | |
225 } | |
226 | |
8607 | 227 static 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 | |
261 static int wv_get_value(WavpackContext *ctx, GetBitContext *gb, int channel, int *last) | |
3764 | 262 { |
263 int t, t2; | |
264 int sign, base, add, ret; | |
8607 | 265 WvChannel *c = &ctx->ch[channel]; |
3764 | 266 |
267 *last = 0; | |
268 | |
8607 | 269 if((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) && !ctx->zero && !ctx->one){ |
3764 | 270 if(ctx->zeroes){ |
271 ctx->zeroes--; | |
8607 | 272 if(ctx->zeroes){ |
273 c->slow_level -= LEVEL_DECAY(c->slow_level); | |
3764 | 274 return 0; |
8607 | 275 } |
3764 | 276 }else{ |
5607 | 277 t = get_unary_0_33(gb); |
3764 | 278 if(t >= 2) t = get_bits(gb, t - 1) | (1 << (t-1)); |
279 ctx->zeroes = t; | |
280 if(ctx->zeroes){ | |
8607 | 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); | |
3764 | 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{ | |
5607 | 298 t = get_unary_0_33(gb); |
3764 | 299 if(get_bits_count(gb) >= ctx->data_size){ |
300 *last = 1; | |
301 return 0; | |
302 } | |
303 if(t == 16) { | |
5607 | 304 t2 = get_unary_0_33(gb); |
3764 | 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 | |
8607 | 319 if(ctx->hybrid && !channel) |
320 update_error_limit(ctx); | |
321 | |
3764 | 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 } | |
8607 | 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 } | |
3764 | 358 sign = get_bits1(gb); |
8607 | 359 if(ctx->hybrid_bitrate) |
360 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level); | |
3764 | 361 return sign ? ~ret : ret; |
362 } | |
363 | |
9597
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
364 static inline int wv_get_value_integer(WavpackContext *s, uint32_t *crc, int S) |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
365 { |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
366 int bit; |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
367 |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
368 if(s->extra_bits){ |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
369 S <<= s->extra_bits; |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
370 |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
371 if(s->got_extra_bits){ |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
372 S |= get_bits(&s->gb_extra_bits, s->extra_bits); |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
373 *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16); |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
374 } |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
375 } |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
376 bit = (S & s->and) | s->or; |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
377 return (((S + bit) << s->shift) - bit) << s->post_shift; |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
378 } |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
379 |
9610
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
380 static float wv_get_value_float(WavpackContext *s, uint32_t *crc, int S) |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
381 { |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
382 union { |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
383 float f; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
384 uint32_t u; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
385 } value; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
386 |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
387 int sign; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
388 int exp = s->float_max_exp; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
389 |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
390 if(s->got_extra_bits){ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
391 const int max_bits = 1 + 23 + 8 + 1; |
10535
95f3daa991a2
Use get_bits_left() instead of size_in_bits - get_bits_count().
rbultje
parents:
10180
diff
changeset
|
392 const int left_bits = get_bits_left(&s->gb_extra_bits); |
9610
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
393 |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
394 if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits) |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
395 return 0.0; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
396 } |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
397 |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
398 if(S){ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
399 S <<= s->float_shift; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
400 sign = S < 0; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
401 if(sign) |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
402 S = -S; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
403 if(S >= 0x1000000){ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
404 if(s->got_extra_bits && get_bits1(&s->gb_extra_bits)){ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
405 S = get_bits(&s->gb_extra_bits, 23); |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
406 }else{ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
407 S = 0; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
408 } |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
409 exp = 255; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
410 }else if(exp){ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
411 int shift = 23 - av_log2(S); |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
412 exp = s->float_max_exp; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
413 if(exp <= shift){ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
414 shift = --exp; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
415 } |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
416 exp -= shift; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
417 |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
418 if(shift){ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
419 S <<= shift; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
420 if((s->float_flag & WV_FLT_SHIFT_ONES) || |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
421 (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s->gb_extra_bits)) ){ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
422 S |= (1 << shift) - 1; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
423 } else if(s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)){ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
424 S |= get_bits(&s->gb_extra_bits, shift); |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
425 } |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
426 } |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
427 }else{ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
428 exp = s->float_max_exp; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
429 } |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
430 S &= 0x7fffff; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
431 }else{ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
432 sign = 0; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
433 exp = 0; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
434 if(s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)){ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
435 if(get_bits1(&s->gb_extra_bits)){ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
436 S = get_bits(&s->gb_extra_bits, 23); |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
437 if(s->float_max_exp >= 25) |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
438 exp = get_bits(&s->gb_extra_bits, 8); |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
439 sign = get_bits1(&s->gb_extra_bits); |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
440 }else{ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
441 if(s->float_flag & WV_FLT_ZERO_SIGN) |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
442 sign = get_bits1(&s->gb_extra_bits); |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
443 } |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
444 } |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
445 } |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
446 |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
447 *crc = *crc * 27 + S * 9 + exp * 3 + sign; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
448 |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
449 value.u = (sign << 31) | (exp << 23) | S; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
450 return value.f; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
451 } |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
452 |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
453 static void wv_reset_saved_context(WavpackContext *s) |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
454 { |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
455 s->pos = 0; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
456 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
457 } |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
458 |
9609
71c0f08bd41d
Prepare WavPack decoder to support floating point output.
kostya
parents:
9597
diff
changeset
|
459 static inline int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, void *dst, const int type) |
3764 | 460 { |
461 int i, j, count = 0; | |
462 int last, t; | |
9597
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
463 int A, B, L, L2, R, R2; |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
464 int pos = s->pos; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
465 uint32_t crc = s->sc.crc; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
466 uint32_t crc_extra_bits = s->extra_sc.crc; |
9549
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
467 int16_t *dst16 = dst; |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
468 int32_t *dst32 = dst; |
9610
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
469 float *dstfl = dst; |
3764 | 470 |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
471 if(s->samples_left == s->samples) |
11212 | 472 s->one = s->zero = s->zeroes = 0; |
3764 | 473 do{ |
8607 | 474 L = wv_get_value(s, gb, 0, &last); |
3764 | 475 if(last) break; |
8607 | 476 R = wv_get_value(s, gb, 1, &last); |
3764 | 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 } | |
9609
71c0f08bd41d
Prepare WavPack decoder to support floating point output.
kostya
parents:
9597
diff
changeset
|
497 if(type != SAMPLE_FMT_S16){ |
9549
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
498 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10); |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
499 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10); |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
500 }else{ |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
501 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10); |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
502 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10); |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
503 } |
3764 | 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){ | |
9609
71c0f08bd41d
Prepare WavPack decoder to support floating point output.
kostya
parents:
9597
diff
changeset
|
509 if(type != SAMPLE_FMT_S16) |
9549
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
510 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10); |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
511 else |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
512 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10); |
3764 | 513 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L); |
514 L = L2; | |
9609
71c0f08bd41d
Prepare WavPack decoder to support floating point output.
kostya
parents:
9597
diff
changeset
|
515 if(type != SAMPLE_FMT_S16) |
9549
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
516 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10); |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
517 else |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
518 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10); |
3764 | 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{ | |
9609
71c0f08bd41d
Prepare WavPack decoder to support floating point output.
kostya
parents:
9597
diff
changeset
|
523 if(type != SAMPLE_FMT_S16) |
9549
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
524 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10); |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
525 else |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
526 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10); |
3764 | 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 | |
9609
71c0f08bd41d
Prepare WavPack decoder to support floating point output.
kostya
parents:
9597
diff
changeset
|
535 if(type != SAMPLE_FMT_S16) |
9549
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
536 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10); |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
537 else |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
538 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10); |
3764 | 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; | |
9589
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
548 |
9610
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
549 if(type == SAMPLE_FMT_FLT){ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
550 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L); |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
551 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R); |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
552 } else if(type == SAMPLE_FMT_S32){ |
9597
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
553 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L); |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
554 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R); |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
555 } else { |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
556 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L); |
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
557 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R); |
9589
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
558 } |
3764 | 559 count++; |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
560 }while(!last && count < s->max_samples); |
3764 | 561 |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
562 s->samples_left -= count; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
563 if(!s->samples_left){ |
11212 | 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); | |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
573 }else{ |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
574 s->pos = pos; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
575 s->sc.crc = crc; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
576 s->sc.bits_used = get_bits_count(&s->gb); |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
577 if(s->got_extra_bits){ |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
578 s->extra_sc.crc = crc_extra_bits; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
579 s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits); |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
580 } |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
581 } |
3764 | 582 return count * 2; |
583 } | |
584 | |
9609
71c0f08bd41d
Prepare WavPack decoder to support floating point output.
kostya
parents:
9597
diff
changeset
|
585 static inline int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, void *dst, const int type) |
3764 | 586 { |
587 int i, j, count = 0; | |
588 int last, t; | |
9597
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
589 int A, S, T; |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
590 int pos = s->pos; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
591 uint32_t crc = s->sc.crc; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
592 uint32_t crc_extra_bits = s->extra_sc.crc; |
9549
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
593 int16_t *dst16 = dst; |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
594 int32_t *dst32 = dst; |
9610
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
595 float *dstfl = dst; |
3764 | 596 |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
597 if(s->samples_left == s->samples) |
11212 | 598 s->one = s->zero = s->zeroes = 0; |
3764 | 599 do{ |
8607 | 600 T = wv_get_value(s, gb, 0, &last); |
3764 | 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 } | |
9609
71c0f08bd41d
Prepare WavPack decoder to support floating point output.
kostya
parents:
9597
diff
changeset
|
616 if(type != SAMPLE_FMT_S16) |
9549
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
617 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10); |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
618 else |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
619 S = T + ((s->decorr[i].weightA * A + 512) >> 10); |
3764 | 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; | |
9589
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
625 |
9610
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
626 if(type == SAMPLE_FMT_FLT) |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
627 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, S); |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
628 else if(type == SAMPLE_FMT_S32) |
9597
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
629 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, S); |
9549
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
630 else |
9597
b60289b3e29a
Factorize out integer sample value decoding for WavPack.
kostya
parents:
9592
diff
changeset
|
631 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S); |
9543 | 632 count++; |
633 }while(!last && count < s->samples); | |
634 | |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
635 s->samples_left -= count; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
636 if(!s->samples_left){ |
11212 | 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); | |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
646 }else{ |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
647 s->pos = pos; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
648 s->sc.crc = crc; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
649 s->sc.bits_used = get_bits_count(&s->gb); |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
650 if(s->got_extra_bits){ |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
651 s->extra_sc.crc = crc_extra_bits; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
652 s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits); |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
653 } |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
654 } |
9543 | 655 return count; |
656 } | |
657 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6294
diff
changeset
|
658 static av_cold int wavpack_decode_init(AVCodecContext *avctx) |
3764 | 659 { |
660 WavpackContext *s = avctx->priv_data; | |
661 | |
662 s->avctx = avctx; | |
663 s->stereo = (avctx->channels == 2); | |
9543 | 664 if(avctx->bits_per_coded_sample <= 16) |
665 avctx->sample_fmt = SAMPLE_FMT_S16; | |
666 else | |
667 avctx->sample_fmt = SAMPLE_FMT_S32; | |
8174
f11197441364
Add channel layout to several audio decoders I maintain
kostya
parents:
7451
diff
changeset
|
668 avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO; |
3764 | 669 |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
670 wv_reset_saved_context(s); |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
671 |
3764 | 672 return 0; |
673 } | |
674 | |
675 static int wavpack_decode_frame(AVCodecContext *avctx, | |
676 void *data, int *data_size, | |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
677 AVPacket *avpkt) |
3764 | 678 { |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
679 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
680 int buf_size = avpkt->size; |
3764 | 681 WavpackContext *s = avctx->priv_data; |
9549
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
682 void *samples = data; |
3764 | 683 int samplecount; |
9610
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
684 int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0; |
8607 | 685 int got_hybrid = 0; |
6294 | 686 const uint8_t* buf_end = buf + buf_size; |
3764 | 687 int i, j, id, size, ssize, weights, t; |
9566
9a3fddd31092
Correctly update output sample format in wavpack decoder.
kostya
parents:
9549
diff
changeset
|
688 int bpp; |
3764 | 689 |
4690 | 690 if (buf_size == 0){ |
691 *data_size = 0; | |
692 return 0; | |
693 } | |
3764 | 694 |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
695 if(!s->samples_left){ |
11212 | 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; | |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
701 } |
3764 | 702 |
4364 | 703 s->samples = AV_RL32(buf); buf += 4; |
4690 | 704 if(!s->samples){ |
705 *data_size = 0; | |
706 return buf_size; | |
707 } | |
9566
9a3fddd31092
Correctly update output sample format in wavpack decoder.
kostya
parents:
9549
diff
changeset
|
708 s->frame_flags = AV_RL32(buf); buf += 4; |
9610
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
709 if(s->frame_flags&0x80){ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
710 bpp = sizeof(float); |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
711 avctx->sample_fmt = SAMPLE_FMT_FLT; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
712 } else if((s->frame_flags&0x03) <= 1){ |
9566
9a3fddd31092
Correctly update output sample format in wavpack decoder.
kostya
parents:
9549
diff
changeset
|
713 bpp = 2; |
9a3fddd31092
Correctly update output sample format in wavpack decoder.
kostya
parents:
9549
diff
changeset
|
714 avctx->sample_fmt = SAMPLE_FMT_S16; |
9a3fddd31092
Correctly update output sample format in wavpack decoder.
kostya
parents:
9549
diff
changeset
|
715 } else { |
9a3fddd31092
Correctly update output sample format in wavpack decoder.
kostya
parents:
9549
diff
changeset
|
716 bpp = 4; |
9a3fddd31092
Correctly update output sample format in wavpack decoder.
kostya
parents:
9549
diff
changeset
|
717 avctx->sample_fmt = SAMPLE_FMT_S32; |
4017 | 718 } |
8607 | 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; | |
9543 | 723 s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f); |
4364 | 724 s->CRC = AV_RL32(buf); buf += 4; |
9566
9a3fddd31092
Correctly update output sample format in wavpack decoder.
kostya
parents:
9549
diff
changeset
|
725 |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
726 s->max_samples = *data_size / (bpp * avctx->channels); |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
727 s->max_samples = FFMIN(s->max_samples, s->samples); |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
728 if(s->samples_left > 0){ |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
729 s->max_samples = FFMIN(s->max_samples, s->samples_left); |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
730 buf = buf_end; |
9566
9a3fddd31092
Correctly update output sample format in wavpack decoder.
kostya
parents:
9549
diff
changeset
|
731 } |
9a3fddd31092
Correctly update output sample format in wavpack decoder.
kostya
parents:
9549
diff
changeset
|
732 |
3764 | 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 } | |
5539
1c67999f81c8
Support for WavPack version 0x410 (false stereo chunks)
kostya
parents:
5538
diff
changeset
|
776 weights = size >> s->stereo_in; |
3764 | 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; | |
5539
1c67999f81c8
Support for WavPack version 0x410 (false stereo chunks)
kostya
parents:
5538
diff
changeset
|
787 if(s->stereo_in){ |
3764 | 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){ | |
4364 | 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; | |
5539
1c67999f81c8
Support for WavPack version 0x410 (false stereo chunks)
kostya
parents:
5538
diff
changeset
|
806 if(s->stereo_in){ |
4364 | 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; | |
3764 | 809 t += 4; |
810 } | |
811 t += 4; | |
812 }else if(s->decorr[i].value < 0){ | |
4364 | 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; | |
3764 | 815 t += 4; |
816 }else{ | |
817 for(j = 0; j < s->decorr[i].value; j++){ | |
4364 | 818 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2; |
5539
1c67999f81c8
Support for WavPack version 0x410 (false stereo chunks)
kostya
parents:
5538
diff
changeset
|
819 if(s->stereo_in){ |
4364 | 820 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2; |
3764 | 821 } |
822 } | |
5539
1c67999f81c8
Support for WavPack version 0x410 (false stereo chunks)
kostya
parents:
5538
diff
changeset
|
823 t += s->decorr[i].value * 2 * (s->stereo_in + 1); |
3764 | 824 } |
825 } | |
826 got_samples = 1; | |
827 break; | |
828 case WP_ID_ENTROPY: | |
5539
1c67999f81c8
Support for WavPack version 0x410 (false stereo chunks)
kostya
parents:
5538
diff
changeset
|
829 if(size != 6 * (s->stereo_in + 1)){ |
1c67999f81c8
Support for WavPack version 0x410 (false stereo chunks)
kostya
parents:
5538
diff
changeset
|
830 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size); |
3764 | 831 buf += ssize; |
832 continue; | |
833 } | |
8607 | 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 } | |
3764 | 839 } |
840 got_entropy = 1; | |
841 break; | |
8607 | 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; | |
5482
bba203d5c5e7
Add the handling of the INT32INFO block to the WavPack decoder.
kostya
parents:
4690
diff
changeset
|
866 case WP_ID_INT32INFO: |
9544
e5afd314bd14
Handle WavPack INT32INFO chunks with nonzero post shift
kostya
parents:
9543
diff
changeset
|
867 if(size != 4){ |
5482
bba203d5c5e7
Add the handling of the INT32INFO block to the WavPack decoder.
kostya
parents:
4690
diff
changeset
|
868 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf); |
bba203d5c5e7
Add the handling of the INT32INFO block to the WavPack decoder.
kostya
parents:
4690
diff
changeset
|
869 buf += ssize; |
bba203d5c5e7
Add the handling of the INT32INFO block to the WavPack decoder.
kostya
parents:
4690
diff
changeset
|
870 continue; |
bba203d5c5e7
Add the handling of the INT32INFO block to the WavPack decoder.
kostya
parents:
4690
diff
changeset
|
871 } |
9544
e5afd314bd14
Handle WavPack INT32INFO chunks with nonzero post shift
kostya
parents:
9543
diff
changeset
|
872 if(buf[0]) |
9589
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
873 s->extra_bits = buf[0]; |
9544
e5afd314bd14
Handle WavPack INT32INFO chunks with nonzero post shift
kostya
parents:
9543
diff
changeset
|
874 else if(buf[1]) |
5482
bba203d5c5e7
Add the handling of the INT32INFO block to the WavPack decoder.
kostya
parents:
4690
diff
changeset
|
875 s->shift = buf[1]; |
bba203d5c5e7
Add the handling of the INT32INFO block to the WavPack decoder.
kostya
parents:
4690
diff
changeset
|
876 else if(buf[2]){ |
bba203d5c5e7
Add the handling of the INT32INFO block to the WavPack decoder.
kostya
parents:
4690
diff
changeset
|
877 s->and = s->or = 1; |
bba203d5c5e7
Add the handling of the INT32INFO block to the WavPack decoder.
kostya
parents:
4690
diff
changeset
|
878 s->shift = buf[2]; |
bba203d5c5e7
Add the handling of the INT32INFO block to the WavPack decoder.
kostya
parents:
4690
diff
changeset
|
879 }else if(buf[3]){ |
bba203d5c5e7
Add the handling of the INT32INFO block to the WavPack decoder.
kostya
parents:
4690
diff
changeset
|
880 s->and = 1; |
bba203d5c5e7
Add the handling of the INT32INFO block to the WavPack decoder.
kostya
parents:
4690
diff
changeset
|
881 s->shift = buf[3]; |
bba203d5c5e7
Add the handling of the INT32INFO block to the WavPack decoder.
kostya
parents:
4690
diff
changeset
|
882 } |
bba203d5c5e7
Add the handling of the INT32INFO block to the WavPack decoder.
kostya
parents:
4690
diff
changeset
|
883 buf += 4; |
bba203d5c5e7
Add the handling of the INT32INFO block to the WavPack decoder.
kostya
parents:
4690
diff
changeset
|
884 break; |
9610
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
885 case WP_ID_FLOATINFO: |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
886 if(size != 4){ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
887 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size); |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
888 buf += ssize; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
889 continue; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
890 } |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
891 s->float_flag = buf[0]; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
892 s->float_shift = buf[1]; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
893 s->float_max_exp = buf[2]; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
894 buf += 4; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
895 got_float = 1; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
896 break; |
3764 | 897 case WP_ID_DATA: |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
898 s->sc.offset = buf - avpkt->data; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
899 s->sc.size = size * 8; |
3764 | 900 init_get_bits(&s->gb, buf, size * 8); |
901 s->data_size = size * 8; | |
902 buf += size; | |
903 got_bs = 1; | |
904 break; | |
9589
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
905 case WP_ID_EXTRABITS: |
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
906 if(size <= 4){ |
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
907 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size); |
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
908 buf += size; |
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
909 continue; |
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
910 } |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
911 s->extra_sc.offset = buf - avpkt->data; |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
912 s->extra_sc.size = size * 8; |
9589
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
913 init_get_bits(&s->gb_extra_bits, buf, size * 8); |
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
914 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32); |
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
915 buf += size; |
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
916 s->got_extra_bits = 1; |
3f7496cd7cab
Decode extended bitstream for high-precision WavPack files.
kostya
parents:
9566
diff
changeset
|
917 break; |
3764 | 918 default: |
919 buf += size; | |
920 } | |
921 if(id & WP_IDF_ODD) buf++; | |
922 } | |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
923 if(!s->samples_left){ |
11212 | 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; | |
9592 | 939 } |
11212 | 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; | |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
961 }else{ |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
962 init_get_bits(&s->gb, avpkt->data + s->sc.offset, s->sc.size); |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
963 skip_bits_long(&s->gb, s->sc.bits_used); |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
964 if(s->got_extra_bits){ |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
965 init_get_bits(&s->gb_extra_bits, avpkt->data + s->extra_sc.offset, |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
966 s->extra_sc.size); |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
967 skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used); |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
968 } |
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
969 } |
3764 | 970 |
9543 | 971 if(s->stereo_in){ |
9609
71c0f08bd41d
Prepare WavPack decoder to support floating point output.
kostya
parents:
9597
diff
changeset
|
972 if(avctx->sample_fmt == SAMPLE_FMT_S16) |
71c0f08bd41d
Prepare WavPack decoder to support floating point output.
kostya
parents:
9597
diff
changeset
|
973 samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S16); |
9610
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
974 else if(avctx->sample_fmt == SAMPLE_FMT_S32) |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
975 samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S32); |
9543 | 976 else |
9610
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
977 samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_FLT); |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
978 |
9543 | 979 }else{ |
9609
71c0f08bd41d
Prepare WavPack decoder to support floating point output.
kostya
parents:
9597
diff
changeset
|
980 if(avctx->sample_fmt == SAMPLE_FMT_S16) |
71c0f08bd41d
Prepare WavPack decoder to support floating point output.
kostya
parents:
9597
diff
changeset
|
981 samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_S16); |
9610
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
982 else if(avctx->sample_fmt == SAMPLE_FMT_S32) |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
983 samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_S32); |
9543 | 984 else |
9610
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
985 samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_FLT); |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
986 |
9609
71c0f08bd41d
Prepare WavPack decoder to support floating point output.
kostya
parents:
9597
diff
changeset
|
987 if(s->stereo && avctx->sample_fmt == SAMPLE_FMT_S16){ |
9549
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
988 int16_t *dst = (int16_t*)samples + samplecount * 2; |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
989 int16_t *src = (int16_t*)samples + samplecount; |
5539
1c67999f81c8
Support for WavPack version 0x410 (false stereo chunks)
kostya
parents:
5538
diff
changeset
|
990 int cnt = samplecount; |
1c67999f81c8
Support for WavPack version 0x410 (false stereo chunks)
kostya
parents:
5538
diff
changeset
|
991 while(cnt--){ |
1c67999f81c8
Support for WavPack version 0x410 (false stereo chunks)
kostya
parents:
5538
diff
changeset
|
992 *--dst = *--src; |
1c67999f81c8
Support for WavPack version 0x410 (false stereo chunks)
kostya
parents:
5538
diff
changeset
|
993 *--dst = *src; |
1c67999f81c8
Support for WavPack version 0x410 (false stereo chunks)
kostya
parents:
5538
diff
changeset
|
994 } |
1c67999f81c8
Support for WavPack version 0x410 (false stereo chunks)
kostya
parents:
5538
diff
changeset
|
995 samplecount *= 2; |
9610
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
996 }else if(s->stereo && avctx->sample_fmt == SAMPLE_FMT_S32){ |
9549
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
997 int32_t *dst = (int32_t*)samples + samplecount * 2; |
7a51c0815b28
Merge decoding functions for all bitdepths in WavPack decoder
kostya
parents:
9544
diff
changeset
|
998 int32_t *src = (int32_t*)samples + samplecount; |
9543 | 999 int cnt = samplecount; |
1000 while(cnt--){ | |
1001 *--dst = *--src; | |
1002 *--dst = *src; | |
1003 } | |
1004 samplecount *= 2; | |
9610
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
1005 }else if(s->stereo){ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
1006 float *dst = (float*)samples + samplecount * 2; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
1007 float *src = (float*)samples + samplecount; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
1008 int cnt = samplecount; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
1009 while(cnt--){ |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
1010 *--dst = *--src; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
1011 *--dst = *src; |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
1012 } |
ad0e96494f1e
Add floating point audio decoding to WavPack decoder.
kostya
parents:
9609
diff
changeset
|
1013 samplecount *= 2; |
5539
1c67999f81c8
Support for WavPack version 0x410 (false stereo chunks)
kostya
parents:
5538
diff
changeset
|
1014 } |
1c67999f81c8
Support for WavPack version 0x410 (false stereo chunks)
kostya
parents:
5538
diff
changeset
|
1015 } |
9543 | 1016 *data_size = samplecount * bpp; |
3764 | 1017 |
11211
dfeaae916502
Since WavPack chunk can contain more samples than FFmpeg is guaranteed to
kostya
parents:
10535
diff
changeset
|
1018 return s->samples_left > 0 ? 0 : buf_size; |
3764 | 1019 } |
1020 | |
1021 AVCodec wavpack_decoder = { | |
1022 "wavpack", | |
1023 CODEC_TYPE_AUDIO, | |
1024 CODEC_ID_WAVPACK, | |
1025 sizeof(WavpackContext), | |
1026 wavpack_decode_init, | |
1027 NULL, | |
5941 | 1028 NULL, |
3764 | 1029 wavpack_decode_frame, |
10180
a514a601bf26
Add CODEC_CAP_SUBFRAMES for codecs that output multiple subframes
faust3
parents:
9610
diff
changeset
|
1030 .capabilities = CODEC_CAP_SUBFRAMES, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6710
diff
changeset
|
1031 .long_name = NULL_IF_CONFIG_SMALL("WavPack"), |
3764 | 1032 }; |