00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #define ALT_BITSTREAM_READER_LE
00022 #include "avcodec.h"
00023 #include "get_bits.h"
00024 #include "unary.h"
00025 #include "libavutil/audioconvert.h"
00026
00032 #define WV_MONO 0x00000004
00033 #define WV_JOINT_STEREO 0x00000010
00034 #define WV_FALSE_STEREO 0x40000000
00035
00036 #define WV_HYBRID_MODE 0x00000008
00037 #define WV_HYBRID_SHAPE 0x00000008
00038 #define WV_HYBRID_BITRATE 0x00000200
00039 #define WV_HYBRID_BALANCE 0x00000400
00040
00041 #define WV_FLT_SHIFT_ONES 0x01
00042 #define WV_FLT_SHIFT_SAME 0x02
00043 #define WV_FLT_SHIFT_SENT 0x04
00044 #define WV_FLT_ZERO_SENT 0x08
00045 #define WV_FLT_ZERO_SIGN 0x10
00046
00047 enum WP_ID_Flags{
00048 WP_IDF_MASK = 0x1F,
00049 WP_IDF_IGNORE = 0x20,
00050 WP_IDF_ODD = 0x40,
00051 WP_IDF_LONG = 0x80
00052 };
00053
00054 enum WP_ID{
00055 WP_ID_DUMMY = 0,
00056 WP_ID_ENCINFO,
00057 WP_ID_DECTERMS,
00058 WP_ID_DECWEIGHTS,
00059 WP_ID_DECSAMPLES,
00060 WP_ID_ENTROPY,
00061 WP_ID_HYBRID,
00062 WP_ID_SHAPING,
00063 WP_ID_FLOATINFO,
00064 WP_ID_INT32INFO,
00065 WP_ID_DATA,
00066 WP_ID_CORR,
00067 WP_ID_EXTRABITS,
00068 WP_ID_CHANINFO
00069 };
00070
00071 typedef struct SavedContext {
00072 int offset;
00073 int size;
00074 int bits_used;
00075 uint32_t crc;
00076 } SavedContext;
00077
00078 #define MAX_TERMS 16
00079
00080 typedef struct Decorr {
00081 int delta;
00082 int value;
00083 int weightA;
00084 int weightB;
00085 int samplesA[8];
00086 int samplesB[8];
00087 } Decorr;
00088
00089 typedef struct WvChannel {
00090 int median[3];
00091 int slow_level, error_limit;
00092 int bitrate_acc, bitrate_delta;
00093 } WvChannel;
00094
00095 typedef struct WavpackFrameContext {
00096 AVCodecContext *avctx;
00097 int frame_flags;
00098 int stereo, stereo_in;
00099 int joint;
00100 uint32_t CRC;
00101 GetBitContext gb;
00102 int got_extra_bits;
00103 uint32_t crc_extra_bits;
00104 GetBitContext gb_extra_bits;
00105 int data_size;
00106 int samples;
00107 int terms;
00108 Decorr decorr[MAX_TERMS];
00109 int zero, one, zeroes;
00110 int extra_bits;
00111 int and, or, shift;
00112 int post_shift;
00113 int hybrid, hybrid_bitrate;
00114 int float_flag;
00115 int float_shift;
00116 int float_max_exp;
00117 WvChannel ch[2];
00118 int samples_left;
00119 int max_samples;
00120 int pos;
00121 SavedContext sc, extra_sc;
00122 } WavpackFrameContext;
00123
00124 #define WV_MAX_FRAME_DECODERS 14
00125
00126 typedef struct WavpackContext {
00127 AVCodecContext *avctx;
00128
00129 WavpackFrameContext *fdec[WV_MAX_FRAME_DECODERS];
00130 int fdec_num;
00131
00132 int multichannel;
00133 int mkv_mode;
00134 int block;
00135 int samples;
00136 int samples_left;
00137 int ch_offset;
00138 } WavpackContext;
00139
00140
00141 static const uint8_t wp_exp2_table [256] = {
00142 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
00143 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
00144 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
00145 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
00146 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
00147 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
00148 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
00149 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
00150 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
00151 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
00152 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
00153 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
00154 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
00155 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
00156 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
00157 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
00158 };
00159
00160 static const uint8_t wp_log2_table [] = {
00161 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
00162 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
00163 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
00164 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
00165 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
00166 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
00167 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
00168 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
00169 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
00170 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
00171 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
00172 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
00173 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
00174 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
00175 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
00176 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
00177 };
00178
00179 static av_always_inline int wp_exp2(int16_t val)
00180 {
00181 int res, neg = 0;
00182
00183 if(val < 0){
00184 val = -val;
00185 neg = 1;
00186 }
00187
00188 res = wp_exp2_table[val & 0xFF] | 0x100;
00189 val >>= 8;
00190 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
00191 return neg ? -res : res;
00192 }
00193
00194 static av_always_inline int wp_log2(int32_t val)
00195 {
00196 int bits;
00197
00198 if(!val)
00199 return 0;
00200 if(val == 1)
00201 return 256;
00202 val += val >> 9;
00203 bits = av_log2(val) + 1;
00204 if(bits < 9)
00205 return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF];
00206 else
00207 return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF];
00208 }
00209
00210 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
00211
00212
00213 #define GET_MED(n) ((c->median[n] >> 4) + 1)
00214 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128>>n) - 2) / (128>>n)) * 2
00215 #define INC_MED(n) c->median[n] += ((c->median[n] + (128>>n)) / (128>>n)) * 5
00216
00217
00218 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
00219 if(samples && in){ \
00220 if((samples ^ in) < 0){ \
00221 weight -= delta; \
00222 if(weight < -1024) weight = -1024; \
00223 }else{ \
00224 weight += delta; \
00225 if(weight > 1024) weight = 1024; \
00226 } \
00227 }
00228
00229
00230 static av_always_inline int get_tail(GetBitContext *gb, int k)
00231 {
00232 int p, e, res;
00233
00234 if(k<1)return 0;
00235 p = av_log2(k);
00236 e = (1 << (p + 1)) - k - 1;
00237 res = p ? get_bits(gb, p) : 0;
00238 if(res >= e){
00239 res = (res<<1) - e + get_bits1(gb);
00240 }
00241 return res;
00242 }
00243
00244 static void update_error_limit(WavpackFrameContext *ctx)
00245 {
00246 int i, br[2], sl[2];
00247
00248 for(i = 0; i <= ctx->stereo_in; i++){
00249 ctx->ch[i].bitrate_acc += ctx->ch[i].bitrate_delta;
00250 br[i] = ctx->ch[i].bitrate_acc >> 16;
00251 sl[i] = LEVEL_DECAY(ctx->ch[i].slow_level);
00252 }
00253 if(ctx->stereo_in && ctx->hybrid_bitrate){
00254 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
00255 if(balance > br[0]){
00256 br[1] = br[0] << 1;
00257 br[0] = 0;
00258 }else if(-balance > br[0]){
00259 br[0] <<= 1;
00260 br[1] = 0;
00261 }else{
00262 br[1] = br[0] + balance;
00263 br[0] = br[0] - balance;
00264 }
00265 }
00266 for(i = 0; i <= ctx->stereo_in; i++){
00267 if(ctx->hybrid_bitrate){
00268 if(sl[i] - br[i] > -0x100)
00269 ctx->ch[i].error_limit = wp_exp2(sl[i] - br[i] + 0x100);
00270 else
00271 ctx->ch[i].error_limit = 0;
00272 }else{
00273 ctx->ch[i].error_limit = wp_exp2(br[i]);
00274 }
00275 }
00276 }
00277
00278 static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb, int channel, int *last)
00279 {
00280 int t, t2;
00281 int sign, base, add, ret;
00282 WvChannel *c = &ctx->ch[channel];
00283
00284 *last = 0;
00285
00286 if((ctx->ch[0].median[0] < 2U) && (ctx->ch[1].median[0] < 2U) && !ctx->zero && !ctx->one){
00287 if(ctx->zeroes){
00288 ctx->zeroes--;
00289 if(ctx->zeroes){
00290 c->slow_level -= LEVEL_DECAY(c->slow_level);
00291 return 0;
00292 }
00293 }else{
00294 t = get_unary_0_33(gb);
00295 if(t >= 2) t = get_bits(gb, t - 1) | (1 << (t-1));
00296 ctx->zeroes = t;
00297 if(ctx->zeroes){
00298 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
00299 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
00300 c->slow_level -= LEVEL_DECAY(c->slow_level);
00301 return 0;
00302 }
00303 }
00304 }
00305
00306 if(get_bits_count(gb) >= ctx->data_size){
00307 *last = 1;
00308 return 0;
00309 }
00310
00311 if(ctx->zero){
00312 t = 0;
00313 ctx->zero = 0;
00314 }else{
00315 t = get_unary_0_33(gb);
00316 if(get_bits_count(gb) >= ctx->data_size){
00317 *last = 1;
00318 return 0;
00319 }
00320 if(t == 16) {
00321 t2 = get_unary_0_33(gb);
00322 if(t2 < 2) t += t2;
00323 else t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
00324 }
00325
00326 if(ctx->one){
00327 ctx->one = t&1;
00328 t = (t>>1) + 1;
00329 }else{
00330 ctx->one = t&1;
00331 t >>= 1;
00332 }
00333 ctx->zero = !ctx->one;
00334 }
00335
00336 if(ctx->hybrid && !channel)
00337 update_error_limit(ctx);
00338
00339 if(!t){
00340 base = 0;
00341 add = GET_MED(0) - 1;
00342 DEC_MED(0);
00343 }else if(t == 1){
00344 base = GET_MED(0);
00345 add = GET_MED(1) - 1;
00346 INC_MED(0);
00347 DEC_MED(1);
00348 }else if(t == 2){
00349 base = GET_MED(0) + GET_MED(1);
00350 add = GET_MED(2) - 1;
00351 INC_MED(0);
00352 INC_MED(1);
00353 DEC_MED(2);
00354 }else{
00355 base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
00356 add = GET_MED(2) - 1;
00357 INC_MED(0);
00358 INC_MED(1);
00359 INC_MED(2);
00360 }
00361 if(!c->error_limit){
00362 ret = base + get_tail(gb, add);
00363 }else{
00364 int mid = (base*2 + add + 1) >> 1;
00365 while(add > c->error_limit){
00366 if(get_bits1(gb)){
00367 add -= (mid - base);
00368 base = mid;
00369 }else
00370 add = mid - base - 1;
00371 mid = (base*2 + add + 1) >> 1;
00372 }
00373 ret = mid;
00374 }
00375 sign = get_bits1(gb);
00376 if(ctx->hybrid_bitrate)
00377 c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
00378 return sign ? ~ret : ret;
00379 }
00380
00381 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc, int S)
00382 {
00383 int bit;
00384
00385 if(s->extra_bits){
00386 S <<= s->extra_bits;
00387
00388 if(s->got_extra_bits){
00389 S |= get_bits(&s->gb_extra_bits, s->extra_bits);
00390 *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16);
00391 }
00392 }
00393 bit = (S & s->and) | s->or;
00394 return (((S + bit) << s->shift) - bit) << s->post_shift;
00395 }
00396
00397 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
00398 {
00399 union {
00400 float f;
00401 uint32_t u;
00402 } value;
00403
00404 int sign;
00405 int exp = s->float_max_exp;
00406
00407 if(s->got_extra_bits){
00408 const int max_bits = 1 + 23 + 8 + 1;
00409 const int left_bits = get_bits_left(&s->gb_extra_bits);
00410
00411 if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
00412 return 0.0;
00413 }
00414
00415 if(S){
00416 S <<= s->float_shift;
00417 sign = S < 0;
00418 if(sign)
00419 S = -S;
00420 if(S >= 0x1000000){
00421 if(s->got_extra_bits && get_bits1(&s->gb_extra_bits)){
00422 S = get_bits(&s->gb_extra_bits, 23);
00423 }else{
00424 S = 0;
00425 }
00426 exp = 255;
00427 }else if(exp){
00428 int shift = 23 - av_log2(S);
00429 exp = s->float_max_exp;
00430 if(exp <= shift){
00431 shift = --exp;
00432 }
00433 exp -= shift;
00434
00435 if(shift){
00436 S <<= shift;
00437 if((s->float_flag & WV_FLT_SHIFT_ONES) ||
00438 (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s->gb_extra_bits)) ){
00439 S |= (1 << shift) - 1;
00440 } else if(s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)){
00441 S |= get_bits(&s->gb_extra_bits, shift);
00442 }
00443 }
00444 }else{
00445 exp = s->float_max_exp;
00446 }
00447 S &= 0x7fffff;
00448 }else{
00449 sign = 0;
00450 exp = 0;
00451 if(s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)){
00452 if(get_bits1(&s->gb_extra_bits)){
00453 S = get_bits(&s->gb_extra_bits, 23);
00454 if(s->float_max_exp >= 25)
00455 exp = get_bits(&s->gb_extra_bits, 8);
00456 sign = get_bits1(&s->gb_extra_bits);
00457 }else{
00458 if(s->float_flag & WV_FLT_ZERO_SIGN)
00459 sign = get_bits1(&s->gb_extra_bits);
00460 }
00461 }
00462 }
00463
00464 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
00465
00466 value.u = (sign << 31) | (exp << 23) | S;
00467 return value.f;
00468 }
00469
00470 static void wv_reset_saved_context(WavpackFrameContext *s)
00471 {
00472 s->pos = 0;
00473 s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
00474 }
00475
00476 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
00477 {
00478 int i, j, count = 0;
00479 int last, t;
00480 int A, B, L, L2, R, R2;
00481 int pos = s->pos;
00482 uint32_t crc = s->sc.crc;
00483 uint32_t crc_extra_bits = s->extra_sc.crc;
00484 int16_t *dst16 = dst;
00485 int32_t *dst32 = dst;
00486 float *dstfl = dst;
00487 const int channel_pad = s->avctx->channels - 2;
00488
00489 if(s->samples_left == s->samples)
00490 s->one = s->zero = s->zeroes = 0;
00491 do{
00492 L = wv_get_value(s, gb, 0, &last);
00493 if(last) break;
00494 R = wv_get_value(s, gb, 1, &last);
00495 if(last) break;
00496 for(i = 0; i < s->terms; i++){
00497 t = s->decorr[i].value;
00498 if(t > 0){
00499 if(t > 8){
00500 if(t & 1){
00501 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
00502 B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
00503 }else{
00504 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
00505 B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
00506 }
00507 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
00508 s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
00509 j = 0;
00510 }else{
00511 A = s->decorr[i].samplesA[pos];
00512 B = s->decorr[i].samplesB[pos];
00513 j = (pos + t) & 7;
00514 }
00515 if(type != AV_SAMPLE_FMT_S16){
00516 L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
00517 R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
00518 }else{
00519 L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
00520 R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
00521 }
00522 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
00523 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
00524 s->decorr[i].samplesA[j] = L = L2;
00525 s->decorr[i].samplesB[j] = R = R2;
00526 }else if(t == -1){
00527 if(type != AV_SAMPLE_FMT_S16)
00528 L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
00529 else
00530 L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
00531 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
00532 L = L2;
00533 if(type != AV_SAMPLE_FMT_S16)
00534 R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
00535 else
00536 R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
00537 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
00538 R = R2;
00539 s->decorr[i].samplesA[0] = R;
00540 }else{
00541 if(type != AV_SAMPLE_FMT_S16)
00542 R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
00543 else
00544 R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
00545 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
00546 R = R2;
00547
00548 if(t == -3){
00549 R2 = s->decorr[i].samplesA[0];
00550 s->decorr[i].samplesA[0] = R;
00551 }
00552
00553 if(type != AV_SAMPLE_FMT_S16)
00554 L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
00555 else
00556 L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
00557 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
00558 L = L2;
00559 s->decorr[i].samplesB[0] = L;
00560 }
00561 }
00562 pos = (pos + 1) & 7;
00563 if(s->joint)
00564 L += (R -= (L >> 1));
00565 crc = (crc * 3 + L) * 3 + R;
00566
00567 if(type == AV_SAMPLE_FMT_FLT){
00568 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
00569 *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
00570 dstfl += channel_pad;
00571 } else if(type == AV_SAMPLE_FMT_S32){
00572 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
00573 *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
00574 dst32 += channel_pad;
00575 } else {
00576 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
00577 *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
00578 dst16 += channel_pad;
00579 }
00580 count++;
00581 }while(!last && count < s->max_samples);
00582
00583 s->samples_left -= count;
00584 if(!s->samples_left){
00585 if(crc != s->CRC){
00586 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
00587 return -1;
00588 }
00589 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
00590 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
00591 return -1;
00592 }
00593 wv_reset_saved_context(s);
00594 }else{
00595 s->pos = pos;
00596 s->sc.crc = crc;
00597 s->sc.bits_used = get_bits_count(&s->gb);
00598 if(s->got_extra_bits){
00599 s->extra_sc.crc = crc_extra_bits;
00600 s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
00601 }
00602 }
00603 return count * 2;
00604 }
00605
00606 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
00607 {
00608 int i, j, count = 0;
00609 int last, t;
00610 int A, S, T;
00611 int pos = s->pos;
00612 uint32_t crc = s->sc.crc;
00613 uint32_t crc_extra_bits = s->extra_sc.crc;
00614 int16_t *dst16 = dst;
00615 int32_t *dst32 = dst;
00616 float *dstfl = dst;
00617 const int channel_stride = s->avctx->channels;
00618
00619 if(s->samples_left == s->samples)
00620 s->one = s->zero = s->zeroes = 0;
00621 do{
00622 T = wv_get_value(s, gb, 0, &last);
00623 S = 0;
00624 if(last) break;
00625 for(i = 0; i < s->terms; i++){
00626 t = s->decorr[i].value;
00627 if(t > 8){
00628 if(t & 1)
00629 A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
00630 else
00631 A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
00632 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
00633 j = 0;
00634 }else{
00635 A = s->decorr[i].samplesA[pos];
00636 j = (pos + t) & 7;
00637 }
00638 if(type != AV_SAMPLE_FMT_S16)
00639 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
00640 else
00641 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
00642 if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
00643 s->decorr[i].samplesA[j] = T = S;
00644 }
00645 pos = (pos + 1) & 7;
00646 crc = crc * 3 + S;
00647
00648 if(type == AV_SAMPLE_FMT_FLT){
00649 *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
00650 dstfl += channel_stride;
00651 }else if(type == AV_SAMPLE_FMT_S32){
00652 *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
00653 dst32 += channel_stride;
00654 }else{
00655 *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
00656 dst16 += channel_stride;
00657 }
00658 count++;
00659 }while(!last && count < s->max_samples);
00660
00661 s->samples_left -= count;
00662 if(!s->samples_left){
00663 if(crc != s->CRC){
00664 av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
00665 return -1;
00666 }
00667 if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
00668 av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
00669 return -1;
00670 }
00671 wv_reset_saved_context(s);
00672 }else{
00673 s->pos = pos;
00674 s->sc.crc = crc;
00675 s->sc.bits_used = get_bits_count(&s->gb);
00676 if(s->got_extra_bits){
00677 s->extra_sc.crc = crc_extra_bits;
00678 s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
00679 }
00680 }
00681 return count;
00682 }
00683
00684 static av_cold int wv_alloc_frame_context(WavpackContext *c)
00685 {
00686
00687 if(c->fdec_num == WV_MAX_FRAME_DECODERS)
00688 return -1;
00689
00690 c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
00691 if(!c->fdec[c->fdec_num])
00692 return -1;
00693 c->fdec_num++;
00694 c->fdec[c->fdec_num - 1]->avctx = c->avctx;
00695 wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
00696
00697 return 0;
00698 }
00699
00700 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
00701 {
00702 WavpackContext *s = avctx->priv_data;
00703
00704 s->avctx = avctx;
00705 if(avctx->bits_per_coded_sample <= 16)
00706 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
00707 else
00708 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
00709 if(avctx->channels <= 2 && !avctx->channel_layout)
00710 avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
00711
00712 s->multichannel = avctx->channels > 2;
00713
00714
00715 s->mkv_mode = 0;
00716 if(s->multichannel && avctx->extradata && avctx->extradata_size == 2){
00717 int ver = AV_RL16(avctx->extradata);
00718 if(ver >= 0x402 && ver <= 0x410)
00719 s->mkv_mode = 1;
00720 }
00721
00722 s->fdec_num = 0;
00723
00724 return 0;
00725 }
00726
00727 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
00728 {
00729 WavpackContext *s = avctx->priv_data;
00730 int i;
00731
00732 for(i = 0; i < s->fdec_num; i++)
00733 av_freep(&s->fdec[i]);
00734 s->fdec_num = 0;
00735
00736 return 0;
00737 }
00738
00739 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
00740 void *data, int *data_size,
00741 const uint8_t *buf, int buf_size)
00742 {
00743 WavpackContext *wc = avctx->priv_data;
00744 WavpackFrameContext *s;
00745 void *samples = data;
00746 int samplecount;
00747 int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
00748 int got_hybrid = 0;
00749 const uint8_t* orig_buf = buf;
00750 const uint8_t* buf_end = buf + buf_size;
00751 int i, j, id, size, ssize, weights, t;
00752 int bpp, chan, chmask;
00753
00754 if (buf_size == 0){
00755 *data_size = 0;
00756 return 0;
00757 }
00758
00759 if(block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0){
00760 av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
00761 return -1;
00762 }
00763
00764 s = wc->fdec[block_no];
00765 if(!s){
00766 av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
00767 return -1;
00768 }
00769
00770 if(!s->samples_left){
00771 memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
00772 memset(s->ch, 0, sizeof(s->ch));
00773 s->extra_bits = 0;
00774 s->and = s->or = s->shift = 0;
00775 s->got_extra_bits = 0;
00776 }
00777
00778 if(!wc->mkv_mode){
00779 s->samples = AV_RL32(buf); buf += 4;
00780 if(!s->samples){
00781 *data_size = 0;
00782 return buf_size;
00783 }
00784 }else{
00785 s->samples = wc->samples;
00786 }
00787 s->frame_flags = AV_RL32(buf); buf += 4;
00788 if(s->frame_flags&0x80){
00789 bpp = sizeof(float);
00790 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
00791 } else if((s->frame_flags&0x03) <= 1){
00792 bpp = 2;
00793 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
00794 } else {
00795 bpp = 4;
00796 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
00797 }
00798 samples = (uint8_t*)samples + bpp * wc->ch_offset;
00799
00800 s->stereo = !(s->frame_flags & WV_MONO);
00801 s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
00802 s->joint = s->frame_flags & WV_JOINT_STEREO;
00803 s->hybrid = s->frame_flags & WV_HYBRID_MODE;
00804 s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
00805 s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
00806 s->CRC = AV_RL32(buf); buf += 4;
00807 if(wc->mkv_mode)
00808 buf += 4;
00809
00810 wc->ch_offset += 1 + s->stereo;
00811
00812 s->max_samples = *data_size / (bpp * avctx->channels);
00813 s->max_samples = FFMIN(s->max_samples, s->samples);
00814 if(s->samples_left > 0){
00815 s->max_samples = FFMIN(s->max_samples, s->samples_left);
00816 buf = buf_end;
00817 }
00818
00819
00820 while(buf < buf_end){
00821 id = *buf++;
00822 size = *buf++;
00823 if(id & WP_IDF_LONG) {
00824 size |= (*buf++) << 8;
00825 size |= (*buf++) << 16;
00826 }
00827 size <<= 1;
00828 ssize = size;
00829 if(id & WP_IDF_ODD) size--;
00830 if(size < 0){
00831 av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
00832 break;
00833 }
00834 if(buf + ssize > buf_end){
00835 av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
00836 break;
00837 }
00838 if(id & WP_IDF_IGNORE){
00839 buf += ssize;
00840 continue;
00841 }
00842 switch(id & WP_IDF_MASK){
00843 case WP_ID_DECTERMS:
00844 s->terms = size;
00845 if(s->terms > MAX_TERMS){
00846 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
00847 buf += ssize;
00848 continue;
00849 }
00850 for(i = 0; i < s->terms; i++) {
00851 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
00852 s->decorr[s->terms - i - 1].delta = *buf >> 5;
00853 buf++;
00854 }
00855 got_terms = 1;
00856 break;
00857 case WP_ID_DECWEIGHTS:
00858 if(!got_terms){
00859 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
00860 continue;
00861 }
00862 weights = size >> s->stereo_in;
00863 if(weights > MAX_TERMS || weights > s->terms){
00864 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
00865 buf += ssize;
00866 continue;
00867 }
00868 for(i = 0; i < weights; i++) {
00869 t = (int8_t)(*buf++);
00870 s->decorr[s->terms - i - 1].weightA = t << 3;
00871 if(s->decorr[s->terms - i - 1].weightA > 0)
00872 s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
00873 if(s->stereo_in){
00874 t = (int8_t)(*buf++);
00875 s->decorr[s->terms - i - 1].weightB = t << 3;
00876 if(s->decorr[s->terms - i - 1].weightB > 0)
00877 s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
00878 }
00879 }
00880 got_weights = 1;
00881 break;
00882 case WP_ID_DECSAMPLES:
00883 if(!got_terms){
00884 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
00885 continue;
00886 }
00887 t = 0;
00888 for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
00889 if(s->decorr[i].value > 8){
00890 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
00891 s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
00892 if(s->stereo_in){
00893 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
00894 s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
00895 t += 4;
00896 }
00897 t += 4;
00898 }else if(s->decorr[i].value < 0){
00899 s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
00900 s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
00901 t += 4;
00902 }else{
00903 for(j = 0; j < s->decorr[i].value; j++){
00904 s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
00905 if(s->stereo_in){
00906 s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
00907 }
00908 }
00909 t += s->decorr[i].value * 2 * (s->stereo_in + 1);
00910 }
00911 }
00912 got_samples = 1;
00913 break;
00914 case WP_ID_ENTROPY:
00915 if(size != 6 * (s->stereo_in + 1)){
00916 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
00917 buf += ssize;
00918 continue;
00919 }
00920 for(j = 0; j <= s->stereo_in; j++){
00921 for(i = 0; i < 3; i++){
00922 s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
00923 buf += 2;
00924 }
00925 }
00926 got_entropy = 1;
00927 break;
00928 case WP_ID_HYBRID:
00929 if(s->hybrid_bitrate){
00930 for(i = 0; i <= s->stereo_in; i++){
00931 s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
00932 buf += 2;
00933 size -= 2;
00934 }
00935 }
00936 for(i = 0; i < (s->stereo_in + 1); i++){
00937 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
00938 buf += 2;
00939 size -= 2;
00940 }
00941 if(size > 0){
00942 for(i = 0; i < (s->stereo_in + 1); i++){
00943 s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
00944 buf += 2;
00945 }
00946 }else{
00947 for(i = 0; i < (s->stereo_in + 1); i++)
00948 s->ch[i].bitrate_delta = 0;
00949 }
00950 got_hybrid = 1;
00951 break;
00952 case WP_ID_INT32INFO:
00953 if(size != 4){
00954 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
00955 buf += ssize;
00956 continue;
00957 }
00958 if(buf[0])
00959 s->extra_bits = buf[0];
00960 else if(buf[1])
00961 s->shift = buf[1];
00962 else if(buf[2]){
00963 s->and = s->or = 1;
00964 s->shift = buf[2];
00965 }else if(buf[3]){
00966 s->and = 1;
00967 s->shift = buf[3];
00968 }
00969 buf += 4;
00970 break;
00971 case WP_ID_FLOATINFO:
00972 if(size != 4){
00973 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
00974 buf += ssize;
00975 continue;
00976 }
00977 s->float_flag = buf[0];
00978 s->float_shift = buf[1];
00979 s->float_max_exp = buf[2];
00980 buf += 4;
00981 got_float = 1;
00982 break;
00983 case WP_ID_DATA:
00984 s->sc.offset = buf - orig_buf;
00985 s->sc.size = size * 8;
00986 init_get_bits(&s->gb, buf, size * 8);
00987 s->data_size = size * 8;
00988 buf += size;
00989 got_bs = 1;
00990 break;
00991 case WP_ID_EXTRABITS:
00992 if(size <= 4){
00993 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
00994 buf += size;
00995 continue;
00996 }
00997 s->extra_sc.offset = buf - orig_buf;
00998 s->extra_sc.size = size * 8;
00999 init_get_bits(&s->gb_extra_bits, buf, size * 8);
01000 s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
01001 buf += size;
01002 s->got_extra_bits = 1;
01003 break;
01004 case WP_ID_CHANINFO:
01005 if(size <= 1){
01006 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
01007 return -1;
01008 }
01009 chan = *buf++;
01010 switch(size - 2){
01011 case 0:
01012 chmask = *buf;
01013 break;
01014 case 1:
01015 chmask = AV_RL16(buf);
01016 break;
01017 case 2:
01018 chmask = AV_RL24(buf);
01019 break;
01020 case 3:
01021 chmask = AV_RL32(buf);
01022 break;
01023 case 5:
01024 chan |= (buf[1] & 0xF) << 8;
01025 chmask = AV_RL24(buf + 2);
01026 break;
01027 default:
01028 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n", size);
01029 chan = avctx->channels;
01030 chmask = avctx->channel_layout;
01031 }
01032 if(chan != avctx->channels){
01033 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, decoder believes it's %d channels\n",
01034 chan, avctx->channels);
01035 return -1;
01036 }
01037 if(!avctx->channel_layout)
01038 avctx->channel_layout = chmask;
01039 buf += size - 1;
01040 break;
01041 default:
01042 buf += size;
01043 }
01044 if(id & WP_IDF_ODD) buf++;
01045 }
01046 if(!s->samples_left){
01047 if(!got_terms){
01048 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
01049 return -1;
01050 }
01051 if(!got_weights){
01052 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
01053 return -1;
01054 }
01055 if(!got_samples){
01056 av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
01057 return -1;
01058 }
01059 if(!got_entropy){
01060 av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
01061 return -1;
01062 }
01063 if(s->hybrid && !got_hybrid){
01064 av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
01065 return -1;
01066 }
01067 if(!got_bs){
01068 av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
01069 return -1;
01070 }
01071 if(!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT){
01072 av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
01073 return -1;
01074 }
01075 if(s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT){
01076 const int size = get_bits_left(&s->gb_extra_bits);
01077 const int wanted = s->samples * s->extra_bits << s->stereo_in;
01078 if(size < wanted){
01079 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
01080 s->got_extra_bits = 0;
01081 }
01082 }
01083 s->samples_left = s->samples;
01084 }else{
01085 init_get_bits(&s->gb, orig_buf + s->sc.offset, s->sc.size);
01086 skip_bits_long(&s->gb, s->sc.bits_used);
01087 if(s->got_extra_bits){
01088 init_get_bits(&s->gb_extra_bits, orig_buf + s->extra_sc.offset,
01089 s->extra_sc.size);
01090 skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used);
01091 }
01092 }
01093
01094 if(s->stereo_in){
01095 if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
01096 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
01097 else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
01098 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
01099 else
01100 samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
01101 samplecount >>= 1;
01102 }else{
01103 const int channel_stride = avctx->channels;
01104
01105 if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
01106 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
01107 else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
01108 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
01109 else
01110 samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
01111
01112 if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16){
01113 int16_t *dst = (int16_t*)samples + 1;
01114 int16_t *src = (int16_t*)samples;
01115 int cnt = samplecount;
01116 while(cnt--){
01117 *dst = *src;
01118 src += channel_stride;
01119 dst += channel_stride;
01120 }
01121 }else if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32){
01122 int32_t *dst = (int32_t*)samples + 1;
01123 int32_t *src = (int32_t*)samples;
01124 int cnt = samplecount;
01125 while(cnt--){
01126 *dst = *src;
01127 src += channel_stride;
01128 dst += channel_stride;
01129 }
01130 }else if(s->stereo){
01131 float *dst = (float*)samples + 1;
01132 float *src = (float*)samples;
01133 int cnt = samplecount;
01134 while(cnt--){
01135 *dst = *src;
01136 src += channel_stride;
01137 dst += channel_stride;
01138 }
01139 }
01140 }
01141
01142 wc->samples_left = s->samples_left;
01143
01144 return samplecount * bpp;
01145 }
01146
01147 static int wavpack_decode_frame(AVCodecContext *avctx,
01148 void *data, int *data_size,
01149 AVPacket *avpkt)
01150 {
01151 WavpackContext *s = avctx->priv_data;
01152 const uint8_t *buf = avpkt->data;
01153 int buf_size = avpkt->size;
01154 int frame_size;
01155 int samplecount = 0;
01156
01157 s->block = 0;
01158 s->samples_left = 0;
01159 s->ch_offset = 0;
01160
01161 if(s->mkv_mode){
01162 s->samples = AV_RL32(buf); buf += 4;
01163 }
01164 while(buf_size > 0){
01165 if(!s->multichannel){
01166 frame_size = buf_size;
01167 }else{
01168 if(!s->mkv_mode){
01169 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
01170 }else{
01171 if(buf_size < 12)
01172 break;
01173 frame_size = AV_RL32(buf + 8) + 12;
01174 }
01175 }
01176 if(frame_size < 0 || frame_size > buf_size){
01177 av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d vs. %d bytes left)\n",
01178 s->block, frame_size, buf_size);
01179 return -1;
01180 }
01181 if((samplecount = wavpack_decode_block(avctx, s->block, data,
01182 data_size, buf, frame_size)) < 0)
01183 return -1;
01184 s->block++;
01185 buf += frame_size; buf_size -= frame_size;
01186 }
01187 *data_size = samplecount * avctx->channels;
01188
01189 return s->samples_left > 0 ? 0 : avpkt->size;
01190 }
01191
01192 AVCodec ff_wavpack_decoder = {
01193 "wavpack",
01194 AVMEDIA_TYPE_AUDIO,
01195 CODEC_ID_WAVPACK,
01196 sizeof(WavpackContext),
01197 wavpack_decode_init,
01198 NULL,
01199 wavpack_decode_end,
01200 wavpack_decode_frame,
01201 .capabilities = CODEC_CAP_SUBFRAMES,
01202 .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
01203 };