• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

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) t = get_bits(gb, t - 1) | (1 << (t-1));
00279             ctx->zeroes = t;
00280             if(ctx->zeroes){
00281                 memset(ctx->ch[0].median, 0, sizeof(ctx->ch[0].median));
00282                 memset(ctx->ch[1].median, 0, sizeof(ctx->ch[1].median));
00283                 c->slow_level -= LEVEL_DECAY(c->slow_level);
00284                 return 0;
00285             }
00286         }
00287     }
00288 
00289     if(get_bits_count(gb) >= ctx->data_size){
00290         *last = 1;
00291         return 0;
00292     }
00293 
00294     if(ctx->zero){
00295         t = 0;
00296         ctx->zero = 0;
00297     }else{
00298         t = get_unary_0_33(gb);
00299         if(get_bits_count(gb) >= ctx->data_size){
00300             *last = 1;
00301             return 0;
00302         }
00303         if(t == 16) {
00304             t2 = get_unary_0_33(gb);
00305             if(t2 < 2) t += t2;
00306             else t += get_bits(gb, t2 - 1) | (1 << (t2 - 1));
00307         }
00308 
00309         if(ctx->one){
00310             ctx->one = t&1;
00311             t = (t>>1) + 1;
00312         }else{
00313             ctx->one = t&1;
00314             t >>= 1;
00315         }
00316         ctx->zero = !ctx->one;
00317     }
00318 
00319     if(ctx->hybrid && !channel)
00320         update_error_limit(ctx);
00321 
00322     if(!t){
00323         base = 0;
00324         add = GET_MED(0) - 1;
00325         DEC_MED(0);
00326     }else if(t == 1){
00327         base = GET_MED(0);
00328         add = GET_MED(1) - 1;
00329         INC_MED(0);
00330         DEC_MED(1);
00331     }else if(t == 2){
00332         base = GET_MED(0) + GET_MED(1);
00333         add = GET_MED(2) - 1;
00334         INC_MED(0);
00335         INC_MED(1);
00336         DEC_MED(2);
00337     }else{
00338         base = GET_MED(0) + GET_MED(1) + GET_MED(2) * (t - 2);
00339         add = GET_MED(2) - 1;
00340         INC_MED(0);
00341         INC_MED(1);
00342         INC_MED(2);
00343     }
00344     if(!c->error_limit){
00345         ret = base + get_tail(gb, add);
00346     }else{
00347         int mid = (base*2 + add + 1) >> 1;
00348         while(add > c->error_limit){
00349             if(get_bits1(gb)){
00350                 add -= (mid - base);
00351                 base = mid;
00352             }else
00353                 add = mid - base - 1;
00354             mid = (base*2 + add + 1) >> 1;
00355         }
00356         ret = mid;
00357     }
00358     sign = get_bits1(gb);
00359     if(ctx->hybrid_bitrate)
00360         c->slow_level += wp_log2(ret) - LEVEL_DECAY(c->slow_level);
00361     return sign ? ~ret : ret;
00362 }
00363 
00364 static inline int wv_get_value_integer(WavpackContext *s, uint32_t *crc, int S)
00365 {
00366     int bit;
00367 
00368     if(s->extra_bits){
00369         S <<= s->extra_bits;
00370 
00371         if(s->got_extra_bits){
00372             S |= get_bits(&s->gb_extra_bits, s->extra_bits);
00373             *crc = *crc * 9 + (S&0xffff) * 3 + ((unsigned)S>>16);
00374         }
00375     }
00376     bit = (S & s->and) | s->or;
00377     return (((S + bit) << s->shift) - bit) << s->post_shift;
00378 }
00379 
00380 static float wv_get_value_float(WavpackContext *s, uint32_t *crc, int S)
00381 {
00382     union {
00383         float    f;
00384         uint32_t u;
00385     } value;
00386 
00387     int sign;
00388     int exp = s->float_max_exp;
00389 
00390     if(s->got_extra_bits){
00391         const int max_bits = 1 + 23 + 8 + 1;
00392         const int left_bits = get_bits_left(&s->gb_extra_bits);
00393 
00394         if(left_bits + 8 * FF_INPUT_BUFFER_PADDING_SIZE < max_bits)
00395             return 0.0;
00396     }
00397 
00398     if(S){
00399         S <<= s->float_shift;
00400         sign = S < 0;
00401         if(sign)
00402             S = -S;
00403         if(S >= 0x1000000){
00404             if(s->got_extra_bits && get_bits1(&s->gb_extra_bits)){
00405                 S = get_bits(&s->gb_extra_bits, 23);
00406             }else{
00407                 S = 0;
00408             }
00409             exp = 255;
00410         }else if(exp){
00411             int shift = 23 - av_log2(S);
00412             exp = s->float_max_exp;
00413             if(exp <= shift){
00414                 shift = --exp;
00415             }
00416             exp -= shift;
00417 
00418             if(shift){
00419                 S <<= shift;
00420                 if((s->float_flag & WV_FLT_SHIFT_ONES) ||
00421                    (s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SAME) && get_bits1(&s->gb_extra_bits)) ){
00422                     S |= (1 << shift) - 1;
00423                 } else if(s->got_extra_bits && (s->float_flag & WV_FLT_SHIFT_SENT)){
00424                     S |= get_bits(&s->gb_extra_bits, shift);
00425                 }
00426             }
00427         }else{
00428             exp = s->float_max_exp;
00429         }
00430         S &= 0x7fffff;
00431     }else{
00432         sign = 0;
00433         exp = 0;
00434         if(s->got_extra_bits && (s->float_flag & WV_FLT_ZERO_SENT)){
00435             if(get_bits1(&s->gb_extra_bits)){
00436                 S = get_bits(&s->gb_extra_bits, 23);
00437                 if(s->float_max_exp >= 25)
00438                     exp = get_bits(&s->gb_extra_bits, 8);
00439                 sign = get_bits1(&s->gb_extra_bits);
00440             }else{
00441                 if(s->float_flag & WV_FLT_ZERO_SIGN)
00442                     sign = get_bits1(&s->gb_extra_bits);
00443             }
00444         }
00445     }
00446 
00447     *crc = *crc * 27 + S * 9 + exp * 3 + sign;
00448 
00449     value.u = (sign << 31) | (exp << 23) | S;
00450     return value.f;
00451 }
00452 
00453 static void wv_reset_saved_context(WavpackContext *s)
00454 {
00455     s->pos = 0;
00456     s->sc.crc = s->extra_sc.crc = 0xFFFFFFFF;
00457 }
00458 
00459 static inline int wv_unpack_stereo(WavpackContext *s, GetBitContext *gb, void *dst, const int type)
00460 {
00461     int i, j, count = 0;
00462     int last, t;
00463     int A, B, L, L2, R, R2;
00464     int pos = s->pos;
00465     uint32_t crc = s->sc.crc;
00466     uint32_t crc_extra_bits = s->extra_sc.crc;
00467     int16_t *dst16 = dst;
00468     int32_t *dst32 = dst;
00469     float   *dstfl = dst;
00470 
00471     if(s->samples_left == s->samples)
00472         s->one = s->zero = s->zeroes = 0;
00473     do{
00474         L = wv_get_value(s, gb, 0, &last);
00475         if(last) break;
00476         R = wv_get_value(s, gb, 1, &last);
00477         if(last) break;
00478         for(i = 0; i < s->terms; i++){
00479             t = s->decorr[i].value;
00480             if(t > 0){
00481                 if(t > 8){
00482                     if(t & 1){
00483                         A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
00484                         B = 2 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1];
00485                     }else{
00486                         A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
00487                         B = (3 * s->decorr[i].samplesB[0] - s->decorr[i].samplesB[1]) >> 1;
00488                     }
00489                     s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
00490                     s->decorr[i].samplesB[1] = s->decorr[i].samplesB[0];
00491                     j = 0;
00492                 }else{
00493                     A = s->decorr[i].samplesA[pos];
00494                     B = s->decorr[i].samplesB[pos];
00495                     j = (pos + t) & 7;
00496                 }
00497                 if(type != SAMPLE_FMT_S16){
00498                     L2 = L + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
00499                     R2 = R + ((s->decorr[i].weightB * (int64_t)B + 512) >> 10);
00500                 }else{
00501                     L2 = L + ((s->decorr[i].weightA * A + 512) >> 10);
00502                     R2 = R + ((s->decorr[i].weightB * B + 512) >> 10);
00503                 }
00504                 if(A && L) s->decorr[i].weightA -= ((((L ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
00505                 if(B && R) s->decorr[i].weightB -= ((((R ^ B) >> 30) & 2) - 1) * s->decorr[i].delta;
00506                 s->decorr[i].samplesA[j] = L = L2;
00507                 s->decorr[i].samplesB[j] = R = R2;
00508             }else if(t == -1){
00509                 if(type != SAMPLE_FMT_S16)
00510                     L2 = L + ((s->decorr[i].weightA * (int64_t)s->decorr[i].samplesA[0] + 512) >> 10);
00511                 else
00512                     L2 = L + ((s->decorr[i].weightA * s->decorr[i].samplesA[0] + 512) >> 10);
00513                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, s->decorr[i].samplesA[0], L);
00514                 L = L2;
00515                 if(type != SAMPLE_FMT_S16)
00516                     R2 = R + ((s->decorr[i].weightB * (int64_t)L2 + 512) >> 10);
00517                 else
00518                     R2 = R + ((s->decorr[i].weightB * L2 + 512) >> 10);
00519                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, L2, R);
00520                 R = R2;
00521                 s->decorr[i].samplesA[0] = R;
00522             }else{
00523                 if(type != SAMPLE_FMT_S16)
00524                     R2 = R + ((s->decorr[i].weightB * (int64_t)s->decorr[i].samplesB[0] + 512) >> 10);
00525                 else
00526                     R2 = R + ((s->decorr[i].weightB * s->decorr[i].samplesB[0] + 512) >> 10);
00527                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightB, s->decorr[i].delta, s->decorr[i].samplesB[0], R);
00528                 R = R2;
00529 
00530                 if(t == -3){
00531                     R2 = s->decorr[i].samplesA[0];
00532                     s->decorr[i].samplesA[0] = R;
00533                 }
00534 
00535                 if(type != SAMPLE_FMT_S16)
00536                     L2 = L + ((s->decorr[i].weightA * (int64_t)R2 + 512) >> 10);
00537                 else
00538                     L2 = L + ((s->decorr[i].weightA * R2 + 512) >> 10);
00539                 UPDATE_WEIGHT_CLIP(s->decorr[i].weightA, s->decorr[i].delta, R2, L);
00540                 L = L2;
00541                 s->decorr[i].samplesB[0] = L;
00542             }
00543         }
00544         pos = (pos + 1) & 7;
00545         if(s->joint)
00546             L += (R -= (L >> 1));
00547         crc = (crc * 3 + L) * 3 + R;
00548 
00549         if(type == SAMPLE_FMT_FLT){
00550             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, L);
00551             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, R);
00552         } else if(type == SAMPLE_FMT_S32){
00553             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, L);
00554             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, R);
00555         } else {
00556             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, L);
00557             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, R);
00558         }
00559         count++;
00560     }while(!last && count < s->max_samples);
00561 
00562     s->samples_left -= count;
00563     if(!s->samples_left){
00564         if(crc != s->CRC){
00565             av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
00566             return -1;
00567         }
00568         if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
00569             av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
00570             return -1;
00571         }
00572         wv_reset_saved_context(s);
00573     }else{
00574         s->pos = pos;
00575         s->sc.crc = crc;
00576         s->sc.bits_used = get_bits_count(&s->gb);
00577         if(s->got_extra_bits){
00578             s->extra_sc.crc = crc_extra_bits;
00579             s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
00580         }
00581     }
00582     return count * 2;
00583 }
00584 
00585 static inline int wv_unpack_mono(WavpackContext *s, GetBitContext *gb, void *dst, const int type)
00586 {
00587     int i, j, count = 0;
00588     int last, t;
00589     int A, S, T;
00590     int pos = s->pos;
00591     uint32_t crc = s->sc.crc;
00592     uint32_t crc_extra_bits = s->extra_sc.crc;
00593     int16_t *dst16 = dst;
00594     int32_t *dst32 = dst;
00595     float   *dstfl = dst;
00596 
00597     if(s->samples_left == s->samples)
00598         s->one = s->zero = s->zeroes = 0;
00599     do{
00600         T = wv_get_value(s, gb, 0, &last);
00601         S = 0;
00602         if(last) break;
00603         for(i = 0; i < s->terms; i++){
00604             t = s->decorr[i].value;
00605             if(t > 8){
00606                 if(t & 1)
00607                     A = 2 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1];
00608                 else
00609                     A = (3 * s->decorr[i].samplesA[0] - s->decorr[i].samplesA[1]) >> 1;
00610                 s->decorr[i].samplesA[1] = s->decorr[i].samplesA[0];
00611                 j = 0;
00612             }else{
00613                 A = s->decorr[i].samplesA[pos];
00614                 j = (pos + t) & 7;
00615             }
00616             if(type != SAMPLE_FMT_S16)
00617                 S = T + ((s->decorr[i].weightA * (int64_t)A + 512) >> 10);
00618             else
00619                 S = T + ((s->decorr[i].weightA * A + 512) >> 10);
00620             if(A && T) s->decorr[i].weightA -= ((((T ^ A) >> 30) & 2) - 1) * s->decorr[i].delta;
00621             s->decorr[i].samplesA[j] = T = S;
00622         }
00623         pos = (pos + 1) & 7;
00624         crc = crc * 3 + S;
00625 
00626         if(type == SAMPLE_FMT_FLT)
00627             *dstfl++ = wv_get_value_float(s, &crc_extra_bits, S);
00628         else if(type == SAMPLE_FMT_S32)
00629             *dst32++ = wv_get_value_integer(s, &crc_extra_bits, S);
00630         else
00631             *dst16++ = wv_get_value_integer(s, &crc_extra_bits, S);
00632         count++;
00633     }while(!last && count < s->samples);
00634 
00635     s->samples_left -= count;
00636     if(!s->samples_left){
00637         if(crc != s->CRC){
00638             av_log(s->avctx, AV_LOG_ERROR, "CRC error\n");
00639             return -1;
00640         }
00641         if(s->got_extra_bits && crc_extra_bits != s->crc_extra_bits){
00642             av_log(s->avctx, AV_LOG_ERROR, "Extra bits CRC error\n");
00643             return -1;
00644         }
00645         wv_reset_saved_context(s);
00646     }else{
00647         s->pos = pos;
00648         s->sc.crc = crc;
00649         s->sc.bits_used = get_bits_count(&s->gb);
00650         if(s->got_extra_bits){
00651             s->extra_sc.crc = crc_extra_bits;
00652             s->extra_sc.bits_used = get_bits_count(&s->gb_extra_bits);
00653         }
00654     }
00655     return count;
00656 }
00657 
00658 static av_cold int wavpack_decode_init(AVCodecContext *avctx)
00659 {
00660     WavpackContext *s = avctx->priv_data;
00661 
00662     s->avctx = avctx;
00663     s->stereo = (avctx->channels == 2);
00664     if(avctx->bits_per_coded_sample <= 16)
00665         avctx->sample_fmt = SAMPLE_FMT_S16;
00666     else
00667         avctx->sample_fmt = SAMPLE_FMT_S32;
00668     avctx->channel_layout = (avctx->channels==2) ? CH_LAYOUT_STEREO : CH_LAYOUT_MONO;
00669 
00670     wv_reset_saved_context(s);
00671 
00672     return 0;
00673 }
00674 
00675 static int wavpack_decode_frame(AVCodecContext *avctx,
00676                             void *data, int *data_size,
00677                             AVPacket *avpkt)
00678 {
00679     const uint8_t *buf = avpkt->data;
00680     int buf_size = avpkt->size;
00681     WavpackContext *s = avctx->priv_data;
00682     void *samples = data;
00683     int samplecount;
00684     int got_terms = 0, got_weights = 0, got_samples = 0, got_entropy = 0, got_bs = 0, got_float = 0;
00685     int got_hybrid = 0;
00686     const uint8_t* buf_end = buf + buf_size;
00687     int i, j, id, size, ssize, weights, t;
00688     int bpp;
00689 
00690     if (buf_size == 0){
00691         *data_size = 0;
00692         return 0;
00693     }
00694 
00695     if(!s->samples_left){
00696         memset(s->decorr, 0, MAX_TERMS * sizeof(Decorr));
00697         memset(s->ch, 0, sizeof(s->ch));
00698         s->extra_bits = 0;
00699         s->and = s->or = s->shift = 0;
00700         s->got_extra_bits = 0;
00701     }
00702 
00703     s->samples = AV_RL32(buf); buf += 4;
00704     if(!s->samples){
00705         *data_size = 0;
00706         return buf_size;
00707     }
00708     s->frame_flags = AV_RL32(buf); buf += 4;
00709     if(s->frame_flags&0x80){
00710         bpp = sizeof(float);
00711         avctx->sample_fmt = SAMPLE_FMT_FLT;
00712     } else if((s->frame_flags&0x03) <= 1){
00713         bpp = 2;
00714         avctx->sample_fmt = SAMPLE_FMT_S16;
00715     } else {
00716         bpp = 4;
00717         avctx->sample_fmt = SAMPLE_FMT_S32;
00718     }
00719     s->stereo_in = (s->frame_flags & WV_FALSE_STEREO) ? 0 : s->stereo;
00720     s->joint = s->frame_flags & WV_JOINT_STEREO;
00721     s->hybrid = s->frame_flags & WV_HYBRID_MODE;
00722     s->hybrid_bitrate = s->frame_flags & WV_HYBRID_BITRATE;
00723     s->post_shift = 8 * (bpp-1-(s->frame_flags&0x03)) + ((s->frame_flags >> 13) & 0x1f);
00724     s->CRC = AV_RL32(buf); buf += 4;
00725 
00726     s->max_samples = *data_size / (bpp * avctx->channels);
00727     s->max_samples = FFMIN(s->max_samples, s->samples);
00728     if(s->samples_left > 0){
00729         s->max_samples = FFMIN(s->max_samples, s->samples_left);
00730         buf = buf_end;
00731     }
00732 
00733     // parse metadata blocks
00734     while(buf < buf_end){
00735         id = *buf++;
00736         size = *buf++;
00737         if(id & WP_IDF_LONG) {
00738             size |= (*buf++) << 8;
00739             size |= (*buf++) << 16;
00740         }
00741         size <<= 1; // size is specified in words
00742         ssize = size;
00743         if(id & WP_IDF_ODD) size--;
00744         if(size < 0){
00745             av_log(avctx, AV_LOG_ERROR, "Got incorrect block %02X with size %i\n", id, size);
00746             break;
00747         }
00748         if(buf + ssize > buf_end){
00749             av_log(avctx, AV_LOG_ERROR, "Block size %i is out of bounds\n", size);
00750             break;
00751         }
00752         if(id & WP_IDF_IGNORE){
00753             buf += ssize;
00754             continue;
00755         }
00756         switch(id & WP_IDF_MASK){
00757         case WP_ID_DECTERMS:
00758             s->terms = size;
00759             if(s->terms > MAX_TERMS){
00760                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation terms\n");
00761                 buf += ssize;
00762                 continue;
00763             }
00764             for(i = 0; i < s->terms; i++) {
00765                 s->decorr[s->terms - i - 1].value = (*buf & 0x1F) - 5;
00766                 s->decorr[s->terms - i - 1].delta = *buf >> 5;
00767                 buf++;
00768             }
00769             got_terms = 1;
00770             break;
00771         case WP_ID_DECWEIGHTS:
00772             if(!got_terms){
00773                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
00774                 continue;
00775             }
00776             weights = size >> s->stereo_in;
00777             if(weights > MAX_TERMS || weights > s->terms){
00778                 av_log(avctx, AV_LOG_ERROR, "Too many decorrelation weights\n");
00779                 buf += ssize;
00780                 continue;
00781             }
00782             for(i = 0; i < weights; i++) {
00783                 t = (int8_t)(*buf++);
00784                 s->decorr[s->terms - i - 1].weightA = t << 3;
00785                 if(s->decorr[s->terms - i - 1].weightA > 0)
00786                     s->decorr[s->terms - i - 1].weightA += (s->decorr[s->terms - i - 1].weightA + 64) >> 7;
00787                 if(s->stereo_in){
00788                     t = (int8_t)(*buf++);
00789                     s->decorr[s->terms - i - 1].weightB = t << 3;
00790                     if(s->decorr[s->terms - i - 1].weightB > 0)
00791                         s->decorr[s->terms - i - 1].weightB += (s->decorr[s->terms - i - 1].weightB + 64) >> 7;
00792                 }
00793             }
00794             got_weights = 1;
00795             break;
00796         case WP_ID_DECSAMPLES:
00797             if(!got_terms){
00798                 av_log(avctx, AV_LOG_ERROR, "No decorrelation terms met\n");
00799                 continue;
00800             }
00801             t = 0;
00802             for(i = s->terms - 1; (i >= 0) && (t < size); i--) {
00803                 if(s->decorr[i].value > 8){
00804                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
00805                     s->decorr[i].samplesA[1] = wp_exp2(AV_RL16(buf)); buf += 2;
00806                     if(s->stereo_in){
00807                         s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
00808                         s->decorr[i].samplesB[1] = wp_exp2(AV_RL16(buf)); buf += 2;
00809                         t += 4;
00810                     }
00811                     t += 4;
00812                 }else if(s->decorr[i].value < 0){
00813                     s->decorr[i].samplesA[0] = wp_exp2(AV_RL16(buf)); buf += 2;
00814                     s->decorr[i].samplesB[0] = wp_exp2(AV_RL16(buf)); buf += 2;
00815                     t += 4;
00816                 }else{
00817                     for(j = 0; j < s->decorr[i].value; j++){
00818                         s->decorr[i].samplesA[j] = wp_exp2(AV_RL16(buf)); buf += 2;
00819                         if(s->stereo_in){
00820                             s->decorr[i].samplesB[j] = wp_exp2(AV_RL16(buf)); buf += 2;
00821                         }
00822                     }
00823                     t += s->decorr[i].value * 2 * (s->stereo_in + 1);
00824                 }
00825             }
00826             got_samples = 1;
00827             break;
00828         case WP_ID_ENTROPY:
00829             if(size != 6 * (s->stereo_in + 1)){
00830                 av_log(avctx, AV_LOG_ERROR, "Entropy vars size should be %i, got %i", 6 * (s->stereo_in + 1), size);
00831                 buf += ssize;
00832                 continue;
00833             }
00834             for(j = 0; j <= s->stereo_in; j++){
00835                 for(i = 0; i < 3; i++){
00836                     s->ch[j].median[i] = wp_exp2(AV_RL16(buf));
00837                     buf += 2;
00838                 }
00839             }
00840             got_entropy = 1;
00841             break;
00842         case WP_ID_HYBRID:
00843             if(s->hybrid_bitrate){
00844                 for(i = 0; i <= s->stereo_in; i++){
00845                     s->ch[i].slow_level = wp_exp2(AV_RL16(buf));
00846                     buf += 2;
00847                     size -= 2;
00848                 }
00849             }
00850             for(i = 0; i < (s->stereo_in + 1); i++){
00851                 s->ch[i].bitrate_acc = AV_RL16(buf) << 16;
00852                 buf += 2;
00853                 size -= 2;
00854             }
00855             if(size > 0){
00856                 for(i = 0; i < (s->stereo_in + 1); i++){
00857                     s->ch[i].bitrate_delta = wp_exp2((int16_t)AV_RL16(buf));
00858                     buf += 2;
00859                 }
00860             }else{
00861                 for(i = 0; i < (s->stereo_in + 1); i++)
00862                     s->ch[i].bitrate_delta = 0;
00863             }
00864             got_hybrid = 1;
00865             break;
00866         case WP_ID_INT32INFO:
00867             if(size != 4){
00868                 av_log(avctx, AV_LOG_ERROR, "Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
00869                 buf += ssize;
00870                 continue;
00871             }
00872             if(buf[0])
00873                 s->extra_bits = buf[0];
00874             else if(buf[1])
00875                 s->shift = buf[1];
00876             else if(buf[2]){
00877                 s->and = s->or = 1;
00878                 s->shift = buf[2];
00879             }else if(buf[3]){
00880                 s->and = 1;
00881                 s->shift = buf[3];
00882             }
00883             buf += 4;
00884             break;
00885         case WP_ID_FLOATINFO:
00886             if(size != 4){
00887                 av_log(avctx, AV_LOG_ERROR, "Invalid FLOATINFO, size = %i\n", size);
00888                 buf += ssize;
00889                 continue;
00890             }
00891             s->float_flag = buf[0];
00892             s->float_shift = buf[1];
00893             s->float_max_exp = buf[2];
00894             buf += 4;
00895             got_float = 1;
00896             break;
00897         case WP_ID_DATA:
00898             s->sc.offset = buf - avpkt->data;
00899             s->sc.size   = size * 8;
00900             init_get_bits(&s->gb, buf, size * 8);
00901             s->data_size = size * 8;
00902             buf += size;
00903             got_bs = 1;
00904             break;
00905         case WP_ID_EXTRABITS:
00906             if(size <= 4){
00907                 av_log(avctx, AV_LOG_ERROR, "Invalid EXTRABITS, size = %i\n", size);
00908                 buf += size;
00909                 continue;
00910             }
00911             s->extra_sc.offset = buf - avpkt->data;
00912             s->extra_sc.size   = size * 8;
00913             init_get_bits(&s->gb_extra_bits, buf, size * 8);
00914             s->crc_extra_bits = get_bits_long(&s->gb_extra_bits, 32);
00915             buf += size;
00916             s->got_extra_bits = 1;
00917             break;
00918         default:
00919             buf += size;
00920         }
00921         if(id & WP_IDF_ODD) buf++;
00922     }
00923     if(!s->samples_left){
00924         if(!got_terms){
00925             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation terms\n");
00926             return -1;
00927         }
00928         if(!got_weights){
00929             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation weights\n");
00930             return -1;
00931         }
00932         if(!got_samples){
00933             av_log(avctx, AV_LOG_ERROR, "No block with decorrelation samples\n");
00934             return -1;
00935         }
00936         if(!got_entropy){
00937             av_log(avctx, AV_LOG_ERROR, "No block with entropy info\n");
00938             return -1;
00939         }
00940         if(s->hybrid && !got_hybrid){
00941             av_log(avctx, AV_LOG_ERROR, "Hybrid config not found\n");
00942             return -1;
00943         }
00944         if(!got_bs){
00945             av_log(avctx, AV_LOG_ERROR, "Packed samples not found\n");
00946             return -1;
00947         }
00948         if(!got_float && avctx->sample_fmt == SAMPLE_FMT_FLT){
00949             av_log(avctx, AV_LOG_ERROR, "Float information not found\n");
00950             return -1;
00951         }
00952         if(s->got_extra_bits && avctx->sample_fmt != SAMPLE_FMT_FLT){
00953             const int size = get_bits_left(&s->gb_extra_bits);
00954             const int wanted = s->samples * s->extra_bits << s->stereo_in;
00955             if(size < wanted){
00956                 av_log(avctx, AV_LOG_ERROR, "Too small EXTRABITS\n");
00957                 s->got_extra_bits = 0;
00958             }
00959         }
00960         s->samples_left = s->samples;
00961     }else{
00962         init_get_bits(&s->gb, avpkt->data + s->sc.offset, s->sc.size);
00963         skip_bits_long(&s->gb, s->sc.bits_used);
00964         if(s->got_extra_bits){
00965             init_get_bits(&s->gb_extra_bits, avpkt->data + s->extra_sc.offset,
00966                           s->extra_sc.size);
00967             skip_bits_long(&s->gb_extra_bits, s->extra_sc.bits_used);
00968         }
00969     }
00970 
00971     if(s->stereo_in){
00972         if(avctx->sample_fmt == SAMPLE_FMT_S16)
00973             samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S16);
00974         else if(avctx->sample_fmt == SAMPLE_FMT_S32)
00975             samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_S32);
00976         else
00977             samplecount = wv_unpack_stereo(s, &s->gb, samples, SAMPLE_FMT_FLT);
00978 
00979     }else{
00980         if(avctx->sample_fmt == SAMPLE_FMT_S16)
00981             samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_S16);
00982         else if(avctx->sample_fmt == SAMPLE_FMT_S32)
00983             samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_S32);
00984         else
00985             samplecount = wv_unpack_mono(s, &s->gb, samples, SAMPLE_FMT_FLT);
00986 
00987         if(s->stereo && avctx->sample_fmt == SAMPLE_FMT_S16){
00988             int16_t *dst = (int16_t*)samples + samplecount * 2;
00989             int16_t *src = (int16_t*)samples + samplecount;
00990             int cnt = samplecount;
00991             while(cnt--){
00992                 *--dst = *--src;
00993                 *--dst = *src;
00994             }
00995             samplecount *= 2;
00996         }else if(s->stereo && avctx->sample_fmt == SAMPLE_FMT_S32){
00997             int32_t *dst = (int32_t*)samples + samplecount * 2;
00998             int32_t *src = (int32_t*)samples + samplecount;
00999             int cnt = samplecount;
01000             while(cnt--){
01001                 *--dst = *--src;
01002                 *--dst = *src;
01003             }
01004             samplecount *= 2;
01005         }else if(s->stereo){
01006             float *dst = (float*)samples + samplecount * 2;
01007             float *src = (float*)samples + samplecount;
01008             int cnt = samplecount;
01009             while(cnt--){
01010                 *--dst = *--src;
01011                 *--dst = *src;
01012             }
01013             samplecount *= 2;
01014         }
01015     }
01016     *data_size = samplecount * bpp;
01017 
01018     return s->samples_left > 0 ? 0 : buf_size;
01019 }
01020 
01021 AVCodec wavpack_decoder = {
01022     "wavpack",
01023     AVMEDIA_TYPE_AUDIO,
01024     CODEC_ID_WAVPACK,
01025     sizeof(WavpackContext),
01026     wavpack_decode_init,
01027     NULL,
01028     NULL,
01029     wavpack_decode_frame,
01030     .capabilities = CODEC_CAP_SUBFRAMES,
01031     .long_name = NULL_IF_CONFIG_SMALL("WavPack"),
01032 };

Generated on Fri Sep 16 2011 17:17:46 for FFmpeg by  doxygen 1.7.1