FFmpeg: libavcodec/wavpack.c Source File

00001 /*
00002  * WavPack lossless audio decoder
00003  * Copyright (c) 2006,2011 Konstantin Shishkov
00004  *
00005  * This file is part of FFmpeg.
00006  *
00007  * FFmpeg is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * FFmpeg is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with FFmpeg; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
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; // in bits
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 // exponent table copied from WavPack source
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 // macros for manipulating median values
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 // macros for applying weight
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){
00296                 if(get_bits_left(gb) < t-1)
00297                     goto error;
00298                 t = get_bits(gb, t - 1) | (1 << (t-1));
00299             }else{
00300                 if(get_bits_left(gb) < 0)
00301                     goto error;
00302             }
00303             ctx->zeroes = t;
00304             if(ctx->zeroes){
00305                 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
00306                 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
00307                 c->slow_level -= LEVEL_DECAY(c->slow_level);
00308                 return 0;
00309             }
00310         }
00311     }
00312 
00313     if(ctx->zero){
00314         t = 0;
00315         ctx->zero = 0;
00316     }else{
00317         t = get_unary_0_33(gb);
00318         if(get_bits_left(gb) < 0)
00319             goto error;
00320         if(t == 16) {
00321             t2 = get_unary_0_33(gb);
00322             if(t2 < 2){
00323                 if(get_bits_left(gb) < 0)
00324                     goto error;
00325                 t += t2;
00326             }else{
00327                 if(get_bits_left(gb) < t2 - 1)
00328                     goto error;
00329                 t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
00330             }
00331         }
00332 
00333         if(ctx->one){
00334             ctx->one = t&1;
00335             t = (t>>1) + 1;
00336         }else{
00337             ctx->one = t&1;
00338             t >>= 1;
00339         }
00340         ctx->zero = !ctx->one;
00341     }
00342 
00343     if(ctx->hybrid && !channel)
00344         update_error_limit(ctx);
00345 
00346     if(!t){
00347         base = 0;
00348         add = GET_MED(0) - 1;
00349         DEC_MED(0);
00350     }else if(t == 1){
00351         base = GET_MED(0);
00352         add = GET_MED(1) - 1;
00353         INC_MED(0);
00354         DEC_MED(1);
00355     }else if(t == 2){
00356         base = GET_MED(0) + GET_MED(1);
00357         add = GET_MED(2) - 1;
00358         INC_MED(0);
00359         INC_MED(1);
00360         DEC_MED(2);
00361     }else{
00362         base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
00363         add = GET_MED(2) - 1;
00364         INC_MED(0);
00365         INC_MED(1);
00366         INC_MED(2);
00367     }
00368     if(!c->error_limit){
00369         ret = base + get_tail(gb, add);
00370         if (get_bits_left(gb) <= 0)
00371             goto error;
00372     }else{
00373         int mid = (base*2 + add + 1) >> 1;
00374         while(add > c->error_limit){
00375             if(get_bits_left(gb) <= 0)
00376                 goto error;
00377             if(get_bits1(gb)){
00378                 add -= (mid - base);
00379                 base = mid;
00380             }else
00381                 add = mid - base - 1;
00382             mid = (base*2 + add + 1) >> 1;
00383         }
00384         ret = mid;
00385     }
00386     sign = get_bits1(gb);
00387     if(ctx->hybrid_bitrate)
00388         c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
00389     return sign ? ~ret : ret;
00390 
00391 error:
00392     *last = 1;
00393     return 0;
00394 }
00395 
00396 static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc, int S)
00397 {
00398     int bit;
00399 
00400     if(s->extra_bits){
00401         S <<= s->extra_bits;
00402 
00403         if(s->got_extra_bits && get_bits_left(&s->gb_extra_bits) >= s->extra_bits){
00404             S |= get_bits(&s->gb_extra_bits, s->extra_bits);
00405             *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16);
00406         }
00407     }
00408     bit = (S & s->and) | s->or;
00409     return (((S + bit) << s->shift) - bit) << s->post_shift;
00410 }
00411 
00412 static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
00413 {
00414     union {
00415         float    f;
00416         uint32_t u;
00417     } value;
00418 
00419     int sign;
00420     int exp = s->float_max_exp;
00421 
00422     if(s->got_extra_bits){
00423         const int max_bits = 1 + 23 + 8 + 1;
00424         const int left_bits = get_bits_left(&s->gb_extra_bits);
00425 
00426         if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
00427             return 0.0;
00428     }
00429 
00430     if(S){
00431         S <<= s->float_shift;
00432         sign = S < 0;
00433         if(sign)
00434             S = -S;
00435         if(S >= 0x1000000){
00436             if(s->got_extra_bits && get_bits1(&s->gb_extra_bits)){
00437                 S = get_bits(&s->gb_extra_bits, 23);
00438             }else{
00439                 S = 0;
00440             }
00441             exp = 255;
00442         }else if(exp){
00443             int shift = 23 - av_log2(S);
00444             exp = s->float_max_exp;
00445             if(exp <= shift){
00446                 shift = --exp;
00447             }
00448             exp -= shift;
00449 
00450             if(shift){
00451                 S <<= shift;
00452                 if((s->float_flag & WV_FLT_SHIFT_ONES) ||
00453                    (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s->gb_extra_bits)) ){
00454                     S |= (1 << shift) - 1;
00455                 } else if(s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)){
00456                     S |= get_bits(&s->gb_extra_bits, shift);
00457                 }
00458             }
00459         }else{
00460             exp = s->float_max_exp;
00461         }
00462         S &= 0x7fffff;
00463     }else{
00464         sign = 0;
00465         exp = 0;
00466         if(s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)){
00467             if(get_bits1(&s->gb_extra_bits)){
00468                 S = get_bits(&s->gb_extra_bits, 23);
00469                 if(s->float_max_exp >= 25)
00470                     exp = get_bits(&s->gb_extra_bits, 8);
00471                 sign = get_bits1(&s->gb_extra_bits);
00472             }else{
00473                 if(s->float_flag & WV_FLT_ZERO_SIGN)
00474                     sign = get_bits1(&s->gb_extra_bits);
00475             }
00476         }
00477     }
00478 
00479     *crc = *crc * 27 + S * 9 + exp * 3 + sign;
00480 
00481     value.u = (sign << 31) | (exp << 23) | S;
00482     return value.f;
00483 }
00484 
00485 static void wv_reset_saved_context(WavpackFrameContext *s)
00486 {
00487     s->pos = 0;
00488     s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
00489 }
00490 
00491 static inline int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
00492 {
00493     int i, j, count = 0;
00494     int last, t;
00495     int A, B, L, L2, R, R2;
00496     int pos = s->pos;
00497     uint32_t crc = s->sc.crc;
00498     uint32_t crc_extra_bits = s->extra_sc.crc;
00499     int16_t *dst16 = dst;
00500     int32_t *dst32 = dst;
00501     float   *dstfl = dst;
00502     const int channel_pad = s->avctx->channels - 2;
00503 
00504     if(s->samples_left == s->samples)
00505         s->one = s->zero = s->zeroes = 0;
00506     do{
00507         L = wv_get_value(s, gb, 0, &last);
00508         if(last) break;
00509         R = wv_get_value(s, gb, 1, &last);
00510         if(last) break;
00511         for(i = 0; i < s->terms; i++){
00512             t = s->decorr[i].value;
00513             if(t > 0){
00514                 if(t > 8){
00515                     if(t & 1){
00516                         A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
00517                         B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
00518                     }else{
00519                         A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
00520                         B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
00521                     }
00522                     s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
00523                     s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
00524                     j = 0;
00525                 }else{
00526                     A = s->decorr[i].samplesA[pos];
00527                     B = s->decorr[i].samplesB[pos];
00528                     j = (pos + t) & 7;
00529                 }
00530                 if(type != AV_SAMPLE_FMT_S16){
00531                     L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
00532                     R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
00533                 }else{
00534                     L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
00535                     R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
00536                 }
00537                 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
00538                 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
00539                 s->decorr[i].samplesA[j] = L = L2;
00540                 s->decorr[i].samplesB[j] = R = R2;
00541             }else if(t == -1){
00542                 if(type != AV_SAMPLE_FMT_S16)
00543                     L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
00544                 else
00545                     L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
00546                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
00547                 L = L2;
00548                 if(type != AV_SAMPLE_FMT_S16)
00549                     R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
00550                 else
00551                     R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
00552                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
00553                 R = R2;
00554                 s->decorr[i].samplesA[0] = R;
00555             }else{
00556                 if(type != AV_SAMPLE_FMT_S16)
00557                     R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
00558                 else
00559                     R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
00560                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
00561                 R = R2;
00562 
00563                 if(t == -3){
00564                     R2 = s->decorr[i].samplesA[0];
00565                     s->decorr[i].samplesA[0] = R;
00566                 }
00567 
00568                 if(type != AV_SAMPLE_FMT_S16)
00569                     L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
00570                 else
00571                     L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
00572                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
00573                 L = L2;
00574                 s->decorr[i].samplesB[0] = L;
00575             }
00576         }
00577         pos = (pos + 1) & 7;
00578         if(s->joint)
00579             L += (R -= (L >> 1));
00580         crc = (crc * 3 + L) * 3 + R;
00581 
00582         if(type == AV_SAMPLE_FMT_FLT){
00583             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
00584             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
00585             dstfl += channel_pad;
00586         } else if(type == AV_SAMPLE_FMT_S32){
00587             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
00588             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
00589             dst32 += channel_pad;
00590         } else {
00591             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
00592             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
00593             dst16 += channel_pad;
00594         }
00595         count++;
00596     }while(!last && count < s->max_samples);
00597 
00598     if (last)
00599         s->samples_left = 0;
00600     else
00601         s->samples_left -= count;
00602     if(!s->samples_left){
00603         if(crc != s->CRC){
00604             av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
00605             return -1;
00606         }
00607         if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
00608             av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
00609             return -1;
00610         }
00611         wv_reset_saved_context(s);
00612     }else{
00613         s->pos = pos;
00614         s->sc.crc = crc;
00615         s->sc.bits_used = get_bits_count(&s->gb);
00616         if(s->got_extra_bits){
00617             s->extra_sc.crc = crc_extra_bits;
00618             s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
00619         }
00620     }
00621     return count * 2;
00622 }
00623 
00624 static inline int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
00625 {
00626     int i, j, count = 0;
00627     int last, t;
00628     int A, S, T;
00629     int pos = s->pos;
00630     uint32_t crc = s->sc.crc;
00631     uint32_t crc_extra_bits = s->extra_sc.crc;
00632     int16_t *dst16 = dst;
00633     int32_t *dst32 = dst;
00634     float   *dstfl = dst;
00635     const int channel_stride = s->avctx->channels;
00636 
00637     if(s->samples_left == s->samples)
00638         s->one = s->zero = s->zeroes = 0;
00639     do{
00640         T = wv_get_value(s, gb, 0, &last);
00641         S = 0;
00642         if(last) break;
00643         for(i = 0; i < s->terms; i++){
00644             t = s->decorr[i].value;
00645             if(t > 8){
00646                 if(t & 1)
00647                     A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
00648                 else
00649                     A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
00650                 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
00651                 j = 0;
00652             }else{
00653                 A = s->decorr[i].samplesA[pos];
00654                 j = (pos + t) & 7;
00655             }
00656             if(type != AV_SAMPLE_FMT_S16)
00657                 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
00658             else
00659                 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
00660             if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
00661             s->decorr[i].samplesA[j] = T = S;
00662         }
00663         pos = (pos + 1) & 7;
00664         crc = crc * 3 + S;
00665 
00666         if(type == AV_SAMPLE_FMT_FLT){
00667             *dstfl = wv_get_value_float(s, &crc_extra_bits, S);
00668             dstfl += channel_stride;
00669         }else if(type == AV_SAMPLE_FMT_S32){
00670             *dst32 = wv_get_value_integer(s, &crc_extra_bits, S);
00671             dst32 += channel_stride;
00672         }else{
00673             *dst16 = wv_get_value_integer(s, &crc_extra_bits, S);
00674             dst16 += channel_stride;
00675         }
00676         count++;
00677     }while(!last && count < s->max_samples);
00678 
00679     if (last)
00680         s->samples_left = 0;
00681     else
00682         s->samples_left -= count;
00683     if(!s->samples_left){
00684         if(crc != s->CRC){
00685             av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
00686             return -1;
00687         }
00688         if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
00689             av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
00690             return -1;
00691         }
00692         wv_reset_saved_context(s);
00693     }else{
00694         s->pos = pos;
00695         s->sc.crc = crc;
00696         s->sc.bits_used = get_bits_count(&s->gb);
00697         if(s->got_extra_bits){
00698             s->extra_sc.crc = crc_extra_bits;
00699             s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
00700         }
00701     }
00702     return count;
00703 }
00704 
00705 static av_cold int wv_alloc_frame_context(WavpackContext *c)
00706 {
00707 
00708     if(c->fdec_num == WV_MAX_FRAME_DECODERS)
00709         return -1;
00710 
00711     c->fdec[c->fdec_num] = av_mallocz(sizeof(**c->fdec));
00712     if(!c->fdec[c->fdec_num])
00713         return -1;
00714     c->fdec_num++;
00715     c->fdec[c->fdec_num - 1]->avctx = c->avctx;
00716     wv_reset_saved_context(c->fdec[c->fdec_num - 1]);
00717 
00718     return 0;
00719 }
00720 
00721 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
00722 {
00723     WavpackContext *s = avctx->priv_data;
00724 
00725     s->avctx = avctx;
00726     if(avctx->bits_per_coded_sample <= 16)
00727         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
00728     else
00729         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
00730     if(avctx->channels <= 2 && !avctx->channel_layout)
00731         avctx->channel_layout = (avctx->channels==2) ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
00732 
00733     s->multichannel = avctx->channels > 2;
00734     /* lavf demuxer does not provide extradata, Matroska stores 0x403
00735        there, use this to detect decoding mode for multichannel */
00736     s->mkv_mode = 0;
00737     if(s->multichannel && avctx->extradata && avctx->extradata_size == 2){
00738         int ver = AV_RL16(avctx->extradata);
00739         if(ver >= 0x402 && ver <= 0x410)
00740             s->mkv_mode = 1;
00741     }
00742 
00743     s->fdec_num = 0;
00744 
00745     return 0;
00746 }
00747 
00748 static av_cold int wavpack_decode_end(AVCodecContext *avctx)
00749 {
00750     WavpackContext *s = avctx->priv_data;
00751     int i;
00752 
00753     for(i = 0; i < s->fdec_num; i++)
00754         av_freep(&s->fdec[i]);
00755     s->fdec_num = 0;
00756 
00757     return 0;
00758 }
00759 
00760 static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
00761                                 void *data, int *data_size,
00762                                 const uint8_t *buf, int buf_size)
00763 {
00764     WavpackContext *wc = avctx->priv_data;
00765     WavpackFrameContext *s;
00766     void *samples = data;
00767     int samplecount;
00768     int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
00769     int got_hybrid = 0;
00770     const uint8_t* orig_buf = buf;
00771     const uint8_t* buf_end = buf + buf_size;
00772     int i, j, id, size, ssize, weights, t;
00773     int bpp, chan, chmask;
00774 
00775     if (buf_size == 0){
00776         *data_size = 0;
00777         return 0;
00778     }
00779 
00780     if(block_no >= wc->fdec_num && wv_alloc_frame_context(wc) < 0){
00781         av_log(avctx, AV_LOG_ERROR, "Error creating frame decode context\n");
00782         return -1;
00783     }
00784 
00785     s = wc->fdec[block_no];
00786     if(!s){
00787         av_log(avctx, AV_LOG_ERROR, "Context for block %d is not present\n", block_no);
00788         return -1;
00789     }
00790 
00791     if(!s->samples_left){
00792         memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
00793         memset(s->ch, 0, sizeof(s->ch));
00794         s->extra_bits = 0;
00795         s->and = s->or = s->shift = 0;
00796         s->got_extra_bits = 0;
00797     }
00798 
00799     if(!wc->mkv_mode){
00800         s->samples = AV_RL32(buf); buf += 4;
00801         if(!s->samples){
00802             *data_size = 0;
00803             return 0;
00804         }
00805     }else{
00806         s->samples = wc->samples;
00807     }
00808     s->frame_flags = AV_RL32(buf); buf += 4;
00809     if(s->frame_flags&0x80){
00810         bpp = sizeof(float);
00811         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
00812     } else if((s->frame_flags&0x03) <= 1){
00813         bpp = 2;
00814         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
00815     } else {
00816         bpp = 4;
00817         avctx->sample_fmt = AV_SAMPLE_FMT_S32;
00818     }
00819     samples = (uint8_t*)samples + bpp * wc->ch_offset;
00820 
00821     s->stereo = !(s->frame_flags & WV_MONO);
00822     s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
00823     s->joint = s->frame_flags & WV_JOINT_STEREO;
00824     s->hybrid = s->frame_flags & WV_HYBRID_MODE;
00825     s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
00826     s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
00827     s->CRC = AV_RL32(buf); buf += 4;
00828     if(wc->mkv_mode)
00829         buf += 4; //skip block size;
00830 
00831     wc->ch_offset += 1 + s->stereo;
00832 
00833     s->max_samples = *data_size / (bpp * avctx->channels);
00834     s->max_samples = FFMIN(s->max_samples, s->samples);
00835     if(s->samples_left > 0){
00836         s->max_samples = FFMIN(s->max_samples, s->samples_left);
00837         buf = buf_end;
00838     }
00839 
00840     // parse metadata blocks
00841     while(buf < buf_end){
00842         id = *buf++;
00843         size = *buf++;
00844         if(id & WP_IDF_LONG) {
00845             size |= (*buf++) << 8;
00846             size |= (*buf++) << 16;
00847         }
00848         size <<= 1; // size is specified in words
00849         ssize = size;
00850         if(id & WP_IDF_ODD) size--;
00851         if(size < 0){
00852             av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
00853             break;
00854         }
00855         if(buf + ssize > buf_end){
00856             av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
00857             break;
00858         }
00859         if(id & WP_IDF_IGNORE){
00860             buf += ssize;
00861             continue;
00862         }
00863         switch(id & WP_IDF_MASK){
00864         case WP_ID_DECTERMS:
00865             if(size > MAX_TERMS){
00866                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
00867                 s->terms = 0;
00868                 buf += ssize;
00869                 continue;
00870             }
00871             s->terms = size;
00872             for(i = 0; i < s->terms; i++) {
00873                 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
00874                 s->decorr[s->terms - i - 1].delta = *buf >> 5;
00875                 buf++;
00876             }
00877             got_terms = 1;
00878             break;
00879         case WP_ID_DECWEIGHTS:
00880             if(!got_terms){
00881                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
00882                 continue;
00883             }
00884             weights = size >> s->stereo_in;
00885             if(weights > MAX_TERMS || weights > s->terms){
00886                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
00887                 buf += ssize;
00888                 continue;
00889             }
00890             for(i = 0; i < weights; i++) {
00891                 t = (int8_t)(*buf++);
00892                 s->decorr[s->terms - i - 1].weightA = t << 3;
00893                 if(s->decorr[s->terms - i - 1].weightA > 0)
00894                     s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
00895                 if(s->stereo_in){
00896                     t = (int8_t)(*buf++);
00897                     s->decorr[s->terms - i - 1].weightB = t << 3;
00898                     if(s->decorr[s->terms - i - 1].weightB > 0)
00899                         s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
00900                 }
00901             }
00902             got_weights = 1;
00903             break;
00904         case WP_ID_DECSAMPLES:
00905             if(!got_terms){
00906                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
00907                 continue;
00908             }
00909             t = 0;
00910             for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
00911                 if(s->decorr[i].value > 8){
00912                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
00913                     s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
00914                     if(s->stereo_in){
00915                         s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
00916                         s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
00917                         t += 4;
00918                     }
00919                     t += 4;
00920                 }else if(s->decorr[i].value < 0){
00921                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
00922                     s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
00923                     t += 4;
00924                 }else{
00925                     for(j = 0; j < s->decorr[i].value; j++){
00926                         s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
00927                         if(s->stereo_in){
00928                             s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
00929                         }
00930                     }
00931                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);
00932                 }
00933             }
00934             got_samples = 1;
00935             break;
00936         case WP_ID_ENTROPY:
00937             if(size != 6 * (s->stereo_in + 1)){
00938                 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
00939                 buf += ssize;
00940                 continue;
00941             }
00942             for(j = 0; j <= s->stereo_in; j++){
00943                 for(i = 0; i < 3; i++){
00944                     s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
00945                     buf += 2;
00946                 }
00947             }
00948             got_entropy = 1;
00949             break;
00950         case WP_ID_HYBRID:
00951             if(s->hybrid_bitrate){
00952                 for(i = 0; i <= s->stereo_in; i++){
00953                     s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
00954                     buf += 2;
00955                     size -= 2;
00956                 }
00957             }
00958             for(i = 0; i < (s->stereo_in + 1); i++){
00959                 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
00960                 buf += 2;
00961                 size -= 2;
00962             }
00963             if(size > 0){
00964                 for(i = 0; i < (s->stereo_in + 1); i++){
00965                     s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
00966                     buf += 2;
00967                 }
00968             }else{
00969                 for(i = 0; i < (s->stereo_in + 1); i++)
00970                     s->ch[i].bitrate_delta = 0;
00971             }
00972             got_hybrid = 1;
00973             break;
00974         case WP_ID_INT32INFO:
00975             if(size != 4){
00976                 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
00977                 buf += ssize;
00978                 continue;
00979             }
00980             if(buf[0])
00981                 s->extra_bits = buf[0];
00982             else if(buf[1])
00983                 s->shift = buf[1];
00984             else if(buf[2]){
00985                 s->and = s->or = 1;
00986                 s->shift = buf[2];
00987             }else if(buf[3]){
00988                 s->and = 1;
00989                 s->shift = buf[3];
00990             }
00991             buf += 4;
00992             break;
00993         case WP_ID_FLOATINFO:
00994             if(size != 4){
00995                 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
00996                 buf += ssize;
00997                 continue;
00998             }
00999             s->float_flag = buf[0];
01000             s->float_shift = buf[1];
01001             s->float_max_exp = buf[2];
01002             buf += 4;
01003             got_float = 1;
01004             break;
01005         case WP_ID_DATA:
01006             s->sc.offset = buf - orig_buf;
01007             s->sc.size   = size * 8;
01008             init_get_bits(&s->gb, buf, size * 8);
01009             s->data_size = size * 8;
01010             buf += size;
01011             got_bs = 1;
01012             break;
01013         case WP_ID_EXTRABITS:
01014             if(size <= 4){
01015                 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
01016                 buf += size;
01017                 continue;
01018             }
01019             s->extra_sc.offset = buf - orig_buf;
01020             s->extra_sc.size   = size * 8;
01021             init_get_bits(&s->gb_extra_bits, buf, size * 8);
01022             s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
01023             buf += size;
01024             s->got_extra_bits = 1;
01025             break;
01026         case WP_ID_CHANINFO:
01027             if(size <= 1){
01028                 av_log(avctx, AV_LOG_ERROR, "Insufficient channel information\n");
01029                 return -1;
01030             }
01031             chan = *buf++;
01032             switch(size - 2){
01033             case 0:
01034                 chmask = *buf;
01035                 break;
01036             case 1:
01037                 chmask = AV_RL16(buf);
01038                 break;
01039             case 2:
01040                 chmask = AV_RL24(buf);
01041                 break;
01042             case 3:
01043                 chmask = AV_RL32(buf);
01044                 break;
01045             case 5:
01046                 chan |= (buf[1] & 0xF) << 8;
01047                 chmask = AV_RL24(buf + 2);
01048                 break;
01049             default:
01050                 av_log(avctx, AV_LOG_ERROR, "Invalid channel info size %d\n", size);
01051                 chan = avctx->channels;
01052                 chmask = avctx->channel_layout;
01053             }
01054             if(chan != avctx->channels){
01055                 av_log(avctx, AV_LOG_ERROR, "Block reports total %d channels, decoder believes it's %d channels\n",
01056                        chan, avctx->channels);
01057                 return -1;
01058             }
01059             if(!avctx->channel_layout)
01060                 avctx->channel_layout = chmask;
01061             buf += size - 1;
01062             break;
01063         default:
01064             buf += size;
01065         }
01066         if(id & WP_IDF_ODD) buf++;
01067     }
01068     if(!s->samples_left){
01069         if(!got_terms){
01070             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
01071             return -1;
01072         }
01073         if(!got_weights){
01074             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
01075             return -1;
01076         }
01077         if(!got_samples){
01078             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
01079             return -1;
01080         }
01081         if(!got_entropy){
01082             av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
01083             return -1;
01084         }
01085         if(s->hybrid && !got_hybrid){
01086             av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
01087             return -1;
01088         }
01089         if(!got_bs){
01090             av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
01091             return -1;
01092         }
01093         if(!got_float && avctx->sample_fmt == AV_SAMPLE_FMT_FLT){
01094             av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
01095             return -1;
01096         }
01097         if(s->got_extra_bits && avctx->sample_fmt != AV_SAMPLE_FMT_FLT){
01098             const int size = get_bits_left(&s->gb_extra_bits);
01099             const int wanted = s->samples * s->extra_bits << s->stereo_in;
01100             if(size < wanted){
01101                 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
01102                 s->got_extra_bits = 0;
01103             }
01104         }
01105         s->samples_left = s->samples;
01106     }else{
01107         init_get_bits(&s->gb, orig_buf + s->sc.offset, s->sc.size);
01108         skip_bits_long(&s->gb, s->sc.bits_used);
01109         if(s->got_extra_bits){
01110             init_get_bits(&s->gb_extra_bits, orig_buf + s->extra_sc.offset,
01111                           s->extra_sc.size);
01112             skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used);
01113         }
01114     }
01115 
01116     if(s->stereo_in){
01117         if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
01118             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
01119         else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
01120             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
01121         else
01122             samplecount = wv_unpack_stereo(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
01123 
01124         if (samplecount < 0)
01125             return -1;
01126 
01127         samplecount >>= 1;
01128     }else{
01129         const int channel_stride = avctx->channels;
01130 
01131         if(avctx->sample_fmt == AV_SAMPLE_FMT_S16)
01132             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S16);
01133         else if(avctx->sample_fmt == AV_SAMPLE_FMT_S32)
01134             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_S32);
01135         else
01136             samplecount = wv_unpack_mono(s, &s->gb, samples, AV_SAMPLE_FMT_FLT);
01137 
01138         if (samplecount < 0)
01139             return -1;
01140 
01141         if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S16){
01142             int16_t *dst = (int16_t*)samples + 1;
01143             int16_t *src = (int16_t*)samples;
01144             int cnt = samplecount;
01145             while(cnt--){
01146                 *dst = *src;
01147                 src += channel_stride;
01148                 dst += channel_stride;
01149             }
01150         }else if(s->stereo && avctx->sample_fmt == AV_SAMPLE_FMT_S32){
01151             int32_t *dst = (int32_t*)samples + 1;
01152             int32_t *src = (int32_t*)samples;
01153             int cnt = samplecount;
01154             while(cnt--){
01155                 *dst = *src;
01156                 src += channel_stride;
01157                 dst += channel_stride;
01158             }
01159         }else if(s->stereo){
01160             float *dst = (float*)samples + 1;
01161             float *src = (float*)samples;
01162             int cnt = samplecount;
01163             while(cnt--){
01164                 *dst = *src;
01165                 src += channel_stride;
01166                 dst += channel_stride;
01167             }
01168         }
01169     }
01170 
01171     wc->samples_left = s->samples_left;
01172 
01173     return samplecount * bpp;
01174 }
01175 
01176 static void wavpack_decode_flush(AVCodecContext *avctx)
01177 {
01178     WavpackContext *s = avctx->priv_data;
01179     int i;
01180 
01181     for (i = 0; i < s->fdec_num; i++)
01182         wv_reset_saved_context(s->fdec[i]);
01183 }
01184 
01185 static int wavpack_decode_frame(AVCodecContext *avctx,
01186                             void *data, int *data_size,
01187                             AVPacket *avpkt)
01188 {
01189     WavpackContext *s = avctx->priv_data;
01190     const uint8_t *buf = avpkt->data;
01191     int buf_size = avpkt->size;
01192     int frame_size;
01193     int samplecount = 0;
01194 
01195     s->block = 0;
01196     s->samples_left = 0;
01197     s->ch_offset = 0;
01198 
01199     if(s->mkv_mode){
01200         s->samples = AV_RL32(buf); buf += 4;
01201     }
01202     while(buf_size > 0){
01203         if(!s->multichannel){
01204             frame_size = buf_size;
01205         }else{
01206             if(!s->mkv_mode){
01207                 frame_size = AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
01208             }else{
01209                 if(buf_size < 12) //MKV files can have zero flags after last block
01210                     break;
01211                 frame_size = AV_RL32(buf + 8) + 12;
01212             }
01213         }
01214         if(frame_size < 0 || frame_size > buf_size){
01215             av_log(avctx, AV_LOG_ERROR, "Block %d has invalid size (size %d vs. %d bytes left)\n",
01216                    s->block, frame_size, buf_size);
01217             wavpack_decode_flush(avctx);
01218             return -1;
01219         }
01220         if((samplecount = wavpack_decode_block(avctx, s->block, data,
01221                                                data_size, buf, frame_size)) < 0) {
01222             wavpack_decode_flush(avctx);
01223             return -1;
01224         }
01225         s->block++;
01226         buf += frame_size; buf_size -= frame_size;
01227     }
01228     *data_size = samplecount * avctx->channels;
01229 
01230     return s->samples_left > 0 ? 0 : avpkt->size;
01231 }
01232 
01233 AVCodec ff_wavpack_decoder = {
01234     "wavpack",
01235     AVMEDIA_TYPE_AUDIO,
01236     CODEC_ID_WAVPACK,
01237     sizeof(WavpackContext),
01238     wavpack_decode_init,
01239     NULL,
01240     wavpack_decode_end,
01241     wavpack_decode_frame,
01242     .capabilities = CODEC_CAP_SUBFRAMES,
01243     .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
01244 };