Libav

libavcodec/wavpack.c

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