diff --git a/doc/general.texi b/doc/general.texi index 0e8e410fcd..b755c187ab 100644 --- a/doc/general.texi +++ b/doc/general.texi @@ -924,8 +924,7 @@ following image formats are supported: @tab A native but very primitive encoder exists. @item Voxware MetaSound @tab @tab X @tab imperfect and incomplete support -@item WavPack @tab E @tab X - @tab supported through external library libwavpack +@item WavPack @tab X @tab X @item Westwood Audio (SND1) @tab @tab X @item Windows Media Audio 1 @tab X @tab X @item Windows Media Audio 2 @tab X @tab X diff --git a/libavcodec/Makefile b/libavcodec/Makefile index e9ba2fa239..ce3cbf913c 100644 --- a/libavcodec/Makefile +++ b/libavcodec/Makefile @@ -473,6 +473,7 @@ OBJS-$(CONFIG_VP8_DECODER) += vp8.o vp8dsp.o vp56rac.o OBJS-$(CONFIG_VPLAYER_DECODER) += textdec.o ass.o OBJS-$(CONFIG_VQA_DECODER) += vqavideo.o OBJS-$(CONFIG_WAVPACK_DECODER) += wavpack.o +OBJS-$(CONFIG_WAVPACK_ENCODER) += wavpackenc.o OBJS-$(CONFIG_WEBP_DECODER) += vp8.o vp8dsp.o vp56rac.o OBJS-$(CONFIG_WEBVTT_DECODER) += webvttdec.o OBJS-$(CONFIG_WMALOSSLESS_DECODER) += wmalosslessdec.o wma_common.o diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c index 57329b5fe8..afedb5454e 100644 --- a/libavcodec/allcodecs.c +++ b/libavcodec/allcodecs.c @@ -365,7 +365,7 @@ void avcodec_register_all(void) REGISTER_DECODER(TWINVQ, twinvq); REGISTER_DECODER(VMDAUDIO, vmdaudio); REGISTER_ENCDEC (VORBIS, vorbis); - REGISTER_DECODER(WAVPACK, wavpack); + REGISTER_ENCDEC (WAVPACK, wavpack); REGISTER_DECODER(WMALOSSLESS, wmalossless); REGISTER_DECODER(WMAPRO, wmapro); REGISTER_ENCDEC (WMAV1, wmav1); diff --git a/libavcodec/version.h b/libavcodec/version.h index e31fea206e..553f5f21ec 100644 --- a/libavcodec/version.h +++ b/libavcodec/version.h @@ -29,7 +29,7 @@ #include "libavutil/avutil.h" #define LIBAVCODEC_VERSION_MAJOR 55 -#define LIBAVCODEC_VERSION_MINOR 27 +#define LIBAVCODEC_VERSION_MINOR 28 #define LIBAVCODEC_VERSION_MICRO 100 #define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \ diff --git a/libavcodec/wavpack.c b/libavcodec/wavpack.c index 47f598a6fe..ac03c16c6a 100644 --- a/libavcodec/wavpack.c +++ b/libavcodec/wavpack.c @@ -28,60 +28,13 @@ #include "thread.h" #include "unary.h" #include "bytestream.h" +#include "wavpack.h" /** * @file * WavPack lossless audio decoder */ -#define WV_HEADER_SIZE 32 - -#define WV_MONO 0x00000004 -#define WV_JOINT_STEREO 0x00000010 -#define WV_FALSE_STEREO 0x40000000 - -#define WV_HYBRID_MODE 0x00000008 -#define WV_HYBRID_SHAPE 0x00000008 -#define WV_HYBRID_BITRATE 0x00000200 -#define WV_HYBRID_BALANCE 0x00000400 -#define WV_INITIAL_BLOCK 0x00000800 -#define WV_FINAL_BLOCK 0x00001000 - -#define WV_SINGLE_BLOCK (WV_INITIAL_BLOCK | WV_FINAL_BLOCK) - -#define WV_FLT_SHIFT_ONES 0x01 -#define WV_FLT_SHIFT_SAME 0x02 -#define WV_FLT_SHIFT_SENT 0x04 -#define WV_FLT_ZERO_SENT 0x08 -#define WV_FLT_ZERO_SIGN 0x10 - -#define WV_MAX_SAMPLES 131072 - -enum WP_ID_Flags { - WP_IDF_MASK = 0x3F, - WP_IDF_IGNORE = 0x20, - WP_IDF_ODD = 0x40, - WP_IDF_LONG = 0x80 -}; - -enum WP_ID { - WP_ID_DUMMY = 0, - WP_ID_ENCINFO, - WP_ID_DECTERMS, - WP_ID_DECWEIGHTS, - WP_ID_DECSAMPLES, - WP_ID_ENTROPY, - WP_ID_HYBRID, - WP_ID_SHAPING, - WP_ID_FLOATINFO, - WP_ID_INT32INFO, - WP_ID_DATA, - WP_ID_CORR, - WP_ID_EXTRABITS, - WP_ID_CHANINFO, - WP_ID_SAMPLE_RATE = 0x27, -}; - typedef struct SavedContext { int offset; int size; @@ -89,23 +42,6 @@ typedef struct SavedContext { uint32_t crc; } SavedContext; -#define MAX_TERMS 16 - -typedef struct Decorr { - int delta; - int value; - int weightA; - int weightB; - int samplesA[8]; - int samplesB[8]; -} Decorr; - -typedef struct WvChannel { - int median[3]; - int slow_level, error_limit; - int bitrate_acc, bitrate_delta; -} WvChannel; - typedef struct WavpackFrameContext { AVCodecContext *avctx; int frame_flags; @@ -147,102 +83,8 @@ typedef struct WavpackContext { int ch_offset; } WavpackContext; -static const int wv_rates[16] = { - 6000, 8000, 9600, 11025, 12000, 16000, 22050, 24000, - 32000, 44100, 48000, 64000, 88200, 96000, 192000, 0 -}; - -// exponent table copied from WavPack source -static const uint8_t wp_exp2_table[256] = { - 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b, - 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16, - 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23, - 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, - 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d, - 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b, - 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, - 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, - 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, - 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a, - 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, - 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, - 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, - 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4, - 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9, - 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff -}; - -static const uint8_t wp_log2_table [] = { - 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15, - 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a, - 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e, - 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51, - 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, - 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75, - 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, - 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, - 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, - 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2, - 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0, - 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce, - 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb, - 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7, - 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, - 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff -}; - -static av_always_inline int wp_exp2(int16_t val) -{ - int res, neg = 0; - - if (val < 0) { - val = -val; - neg = 1; - } - - res = wp_exp2_table[val & 0xFF] | 0x100; - val >>= 8; - res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val)); - return neg ? -res : res; -} - -static av_always_inline int wp_log2(int32_t val) -{ - int bits; - - if (!val) - return 0; - if (val == 1) - return 256; - val += val >> 9; - bits = av_log2(val) + 1; - if (bits < 9) - return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF]; - else - return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF]; -} - #define LEVEL_DECAY(a) ((a + 0x80) >> 8) -// macros for manipulating median values -#define GET_MED(n) ((c->median[n] >> 4) + 1) -#define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> n) - 2) / (128 >> n)) * 2 -#define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> n) ) / (128 >> n)) * 5 - -// macros for applying weight -#define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \ - if (samples && in) { \ - if ((samples ^ in) < 0) { \ - weight -= delta; \ - if (weight < -1024) \ - weight = -1024; \ - } else { \ - weight += delta; \ - if (weight > 1024) \ - weight = 1024; \ - } \ - } - static av_always_inline int get_tail(GetBitContext *gb, int k) { int p, e, res; diff --git a/libavcodec/wavpack.h b/libavcodec/wavpack.h new file mode 100644 index 0000000000..bca6c4550e --- /dev/null +++ b/libavcodec/wavpack.h @@ -0,0 +1,192 @@ +/* + * WavPack decoder/encoder common code + * Copyright (c) 2006,2011 Konstantin Shishkov + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVCODEC_WAVPACK_H +#define AVCODEC_WAVPACK_H + +#define MAX_TERMS 16 +#define MAX_TERM 8 + +#define WV_HEADER_SIZE 32 + +#define WV_MONO 0x00000004 +#define WV_JOINT_STEREO 0x00000010 +#define WV_CROSS_DECORR 0x00000020 +#define WV_FLOAT_DATA 0x00000080 +#define WV_INT32_DATA 0x00000100 +#define WV_FALSE_STEREO 0x40000000 + +#define WV_HYBRID_MODE 0x00000008 +#define WV_HYBRID_SHAPE 0x00000008 +#define WV_HYBRID_BITRATE 0x00000200 +#define WV_HYBRID_BALANCE 0x00000400 +#define WV_INITIAL_BLOCK 0x00000800 +#define WV_FINAL_BLOCK 0x00001000 + +#define WV_MONO_DATA (WV_MONO | WV_FALSE_STEREO) + +#define WV_SINGLE_BLOCK (WV_INITIAL_BLOCK | WV_FINAL_BLOCK) + +#define WV_FLT_SHIFT_ONES 0x01 +#define WV_FLT_SHIFT_SAME 0x02 +#define WV_FLT_SHIFT_SENT 0x04 +#define WV_FLT_ZERO_SENT 0x08 +#define WV_FLT_ZERO_SIGN 0x10 + +#define WV_MAX_SAMPLES 131072 + +enum WP_ID_Flags { + WP_IDF_MASK = 0x3F, + WP_IDF_IGNORE = 0x20, + WP_IDF_ODD = 0x40, + WP_IDF_LONG = 0x80 +}; + +enum WP_ID { + WP_ID_DUMMY = 0, + WP_ID_ENCINFO, + WP_ID_DECTERMS, + WP_ID_DECWEIGHTS, + WP_ID_DECSAMPLES, + WP_ID_ENTROPY, + WP_ID_HYBRID, + WP_ID_SHAPING, + WP_ID_FLOATINFO, + WP_ID_INT32INFO, + WP_ID_DATA, + WP_ID_CORR, + WP_ID_EXTRABITS, + WP_ID_CHANINFO, + WP_ID_SAMPLE_RATE = 0x27, +}; + +typedef struct Decorr { + int delta; + int value; + int weightA; + int weightB; + int samplesA[MAX_TERM]; + int samplesB[MAX_TERM]; + int sumA; + int sumB; +} Decorr; + +typedef struct WvChannel { + int median[3]; + int slow_level, error_limit; + int bitrate_acc, bitrate_delta; +} WvChannel; + +// macros for manipulating median values +#define GET_MED(n) ((c->median[n] >> 4) + 1) +#define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> n) - 2) / (128 >> n)) * 2 +#define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> n) ) / (128 >> n)) * 5 + +// macros for applying weight +#define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \ + if (samples && in) { \ + if ((samples ^ in) < 0) { \ + weight -= delta; \ + if (weight < -1024) \ + weight = -1024; \ + } else { \ + weight += delta; \ + if (weight > 1024) \ + weight = 1024; \ + } \ + } + +static const int wv_rates[16] = { + 6000, 8000, 9600, 11025, 12000, 16000, 22050, 24000, + 32000, 44100, 48000, 64000, 88200, 96000, 192000, 0 +}; + +// exponent table copied from WavPack source +static const uint8_t wp_exp2_table[256] = { + 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b, + 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16, + 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23, + 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d, + 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b, + 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, + 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, + 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, + 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a, + 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, + 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, + 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, + 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4, + 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9, + 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff +}; + +static const uint8_t wp_log2_table [] = { + 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15, + 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a, + 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e, + 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51, + 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, + 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75, + 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, + 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, + 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, + 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2, + 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0, + 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce, + 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb, + 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7, + 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, + 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff +}; + +static av_always_inline int wp_exp2(int16_t val) +{ + int res, neg = 0; + + if (val < 0) { + val = -val; + neg = 1; + } + + res = wp_exp2_table[val & 0xFF] | 0x100; + val >>= 8; + res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val)); + return neg ? -res : res; +} + +static av_always_inline int wp_log2(int32_t val) +{ + int bits; + + if (!val) + return 0; + if (val == 1) + return 256; + val += val >> 9; + bits = av_log2(val) + 1; + if (bits < 9) + return (bits << 8) + wp_log2_table[(val << (9 - bits)) & 0xFF]; + else + return (bits << 8) + wp_log2_table[(val >> (bits - 9)) & 0xFF]; +} + +#endif /* AVCODEC_WAVPACK_H */ diff --git a/libavcodec/wavpackenc.c b/libavcodec/wavpackenc.c new file mode 100644 index 0000000000..1a4f25206a --- /dev/null +++ b/libavcodec/wavpackenc.c @@ -0,0 +1,2987 @@ +/* + * WavPack lossless audio encoder + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#define BITSTREAM_WRITER_LE + +#include "libavutil/intreadwrite.h" +#include "libavutil/opt.h" +#include "avcodec.h" +#include "internal.h" +#include "put_bits.h" +#include "bytestream.h" +#include "wavpackenc.h" +#include "wavpack.h" + +#define UPDATE_WEIGHT(weight, delta, source, result) \ + if (source && result) { \ + int32_t s = (int32_t) (source ^ result) >> 31; \ + weight = (delta ^ s) + (weight - s); \ + } + +#define APPLY_WEIGHT_F(weight, sample) (((((sample & 0xffff) * weight) >> 9) + \ + (((sample & ~0xffff) >> 9) * weight) + 1) >> 1) + +#define APPLY_WEIGHT_I(weight, sample) ((weight * sample + 512) >> 10) + +#define APPLY_WEIGHT(weight, sample) (sample != (short) sample ? \ + APPLY_WEIGHT_F(weight, sample) : APPLY_WEIGHT_I (weight, sample)) + +#define CLEAR(destin) memset(&destin, 0, sizeof(destin)); + +#define SHIFT_LSB 13 +#define SHIFT_MASK (0x1FU << SHIFT_LSB) + +#define MAG_LSB 18 +#define MAG_MASK (0x1FU << MAG_LSB) + +#define SRATE_LSB 23 +#define SRATE_MASK (0xFU << SRATE_LSB) + +#define EXTRA_TRY_DELTAS 1 +#define EXTRA_ADJUST_DELTAS 2 +#define EXTRA_SORT_FIRST 4 +#define EXTRA_BRANCHES 8 +#define EXTRA_SORT_LAST 16 + +typedef struct WavPackExtraInfo { + struct Decorr dps[MAX_TERMS]; + int nterms, log_limit, gt16bit; + uint32_t best_bits; +} WavPackExtraInfo; + +typedef struct WavPackWords { + int pend_data, holding_one, zeros_acc; + int holding_zero, pend_count; + WvChannel c[2]; +} WavPackWords; + +typedef struct WavPackEncodeContext { + AVClass *class; + AVCodecContext *avctx; + PutBitContext pb; + int block_samples; + int buffer_size; + int sample_index; + int stereo, stereo_in; + int ch_offset; + + int32_t *samples[2]; + int samples_size[2]; + + int32_t *sampleptrs[MAX_TERMS+2][2]; + int sampleptrs_size[MAX_TERMS+2][2]; + + int32_t *temp_buffer[2][2]; + int temp_buffer_size[2][2]; + + int32_t *best_buffer[2]; + int best_buffer_size[2]; + + int32_t *js_left, *js_right; + int js_left_size, js_right_size; + + int32_t *orig_l, *orig_r; + int orig_l_size, orig_r_size; + + unsigned extra_flags; + int optimize_mono; + int decorr_filter; + int joint; + int num_branches; + + uint32_t flags; + uint32_t crc_x; + WavPackWords w; + + uint8_t int32_sent_bits, int32_zeros, int32_ones, int32_dups; + uint8_t float_flags, float_shift, float_max_exp, max_exp; + int32_t shifted_ones, shifted_zeros, shifted_both; + int32_t false_zeros, neg_zeros, ordata; + + int num_terms, shift, joint_stereo, false_stereo; + int num_decorrs, num_passes, best_decorr, mask_decorr; + struct Decorr decorr_passes[MAX_TERMS]; + const WavPackDecorrSpec *decorr_specs; + float delta_decay; +} WavPackEncodeContext; + +static av_cold int wavpack_encode_init(AVCodecContext *avctx) +{ + WavPackEncodeContext *s = avctx->priv_data; + + s->avctx = avctx; + + if (!avctx->frame_size) { + int block_samples; + if (!(avctx->sample_rate & 1)) + block_samples = avctx->sample_rate / 2; + else + block_samples = avctx->sample_rate; + + while (block_samples * avctx->channels > 150000) + block_samples /= 2; + + while (block_samples * avctx->channels < 40000) + block_samples *= 2; + avctx->frame_size = block_samples; + } else if (avctx->frame_size && (avctx->frame_size < 128 || + avctx->frame_size > WV_MAX_SAMPLES)) { + av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n", avctx->frame_size); + return AVERROR(EINVAL); + } + + if (avctx->compression_level != FF_COMPRESSION_DEFAULT) { + if (avctx->compression_level >= 3) { + s->decorr_filter = 3; + s->num_passes = 9; + if (avctx->compression_level >= 8) { + s->num_branches = 4; + s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_SORT_FIRST|EXTRA_SORT_LAST|EXTRA_BRANCHES; + } else if (avctx->compression_level >= 7) { + s->num_branches = 3; + s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_SORT_FIRST|EXTRA_BRANCHES; + } else if (avctx->compression_level >= 6) { + s->num_branches = 2; + s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_SORT_FIRST|EXTRA_BRANCHES; + } else if (avctx->compression_level >= 5) { + s->num_branches = 1; + s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_SORT_FIRST|EXTRA_BRANCHES; + } else if (avctx->compression_level >= 4) { + s->num_branches = 1; + s->extra_flags = EXTRA_TRY_DELTAS|EXTRA_ADJUST_DELTAS|EXTRA_BRANCHES; + } + } else if (avctx->compression_level == 2) { + s->decorr_filter = 2; + s->num_passes = 4; + } else if (avctx->compression_level == 1) { + s->decorr_filter = 1; + s->num_passes = 2; + } else if (avctx->compression_level < 1) { + s->decorr_filter = 0; + s->num_passes = 0; + } + } + + s->num_decorrs = decorr_filter_sizes[s->decorr_filter]; + s->decorr_specs = decorr_filters[s->decorr_filter]; + + s->delta_decay = 2.0; + + return 0; +} + +static void shift_mono(int32_t *samples, int nb_samples, int shift) +{ + int i; + for (i = 0; i < nb_samples; i++) + samples[i] >>= shift; +} + +static void shift_stereo(int32_t *left, int32_t *right, + int nb_samples, int shift) +{ + int i; + for (i = 0; i < nb_samples; i++) { + left [i] >>= shift; + right[i] >>= shift; + } +} + +#define FLOAT_SHIFT_ONES 1 +#define FLOAT_SHIFT_SAME 2 +#define FLOAT_SHIFT_SENT 4 +#define FLOAT_ZEROS_SENT 8 +#define FLOAT_NEG_ZEROS 0x10 +#define FLOAT_EXCEPTIONS 0x20 + +#define get_mantissa(f) ((f) & 0x7fffff) +#define get_exponent(f) (((f) >> 23) & 0xff) +#define get_sign(f) (((f) >> 31) & 0x1) + +static void process_float(WavPackEncodeContext *s, int32_t *sample) +{ + int32_t shift_count, value, f = *sample; + + if (get_exponent(f) == 255) { + s->float_flags |= FLOAT_EXCEPTIONS; + value = 0x1000000; + shift_count = 0; + } else if (get_exponent(f)) { + shift_count = s->max_exp - get_exponent(f); + value = 0x800000 + get_mantissa(f); + } else { + shift_count = s->max_exp ? s->max_exp - 1 : 0; + value = get_mantissa(f); + } + + if (shift_count < 25) + value >>= shift_count; + else + value = 0; + + if (!value) { + if (get_exponent(f) || get_mantissa(f)) + s->false_zeros++; + else if (get_sign(f)) + s->neg_zeros++; + } else if (shift_count) { + int32_t mask = (1 << shift_count) - 1; + + if (!(get_mantissa(f) & mask)) + s->shifted_zeros++; + else if ((get_mantissa(f) & mask) == mask) + s->shifted_ones++; + else + s->shifted_both++; + } + + s->ordata |= value; + *sample = get_sign(f) ? -value : value; +} + +static int scan_float(WavPackEncodeContext *s, + int32_t *samples_l, int32_t *samples_r, + int nb_samples) +{ + uint32_t crc = 0xffffffffu; + int i; + + s->shifted_ones = s->shifted_zeros = s->shifted_both = s->ordata = 0; + s->float_shift = s->float_flags = 0; + s->false_zeros = s->neg_zeros = 0; + s->max_exp = 0; + + if (s->flags & WV_MONO_DATA) { + for (i = 0; i < nb_samples; i++) { + int32_t f = samples_l[i]; + crc = crc * 27 + get_mantissa(f) * 9 + get_exponent(f) * 3 + get_sign(f); + + if (get_exponent(f) > s->max_exp && get_exponent(f) < 255) + s->max_exp = get_exponent(f); + } + } else { + for (i = 0; i < nb_samples; i++) { + int32_t f; + + f = samples_l[i]; + crc = crc * 27 + get_mantissa(f) * 9 + get_exponent(f) * 3 + get_sign(f); + if (get_exponent(f) > s->max_exp && get_exponent(f) < 255) + s->max_exp = get_exponent(f); + + f = samples_r[i]; + crc = crc * 27 + get_mantissa(f) * 9 + get_exponent(f) * 3 + get_sign(f); + + if (get_exponent(f) > s->max_exp && get_exponent(f) < 255) + s->max_exp = get_exponent(f); + } + } + + s->crc_x = crc; + + if (s->flags & WV_MONO_DATA) { + for (i = 0; i < nb_samples; i++) + process_float(s, &samples_l[i]); + } else { + for (i = 0; i < nb_samples; i++) { + process_float(s, &samples_l[i]); + process_float(s, &samples_r[i]); + } + } + + s->float_max_exp = s->max_exp; + + if (s->shifted_both) + s->float_flags |= FLOAT_SHIFT_SENT; + else if (s->shifted_ones && !s->shifted_zeros) + s->float_flags |= FLOAT_SHIFT_ONES; + else if (s->shifted_ones && s->shifted_zeros) + s->float_flags |= FLOAT_SHIFT_SAME; + else if (s->ordata && !(s->ordata & 1)) { + do { + s->float_shift++; + s->ordata >>= 1; + } while (!(s->ordata & 1)); + + if (s->flags & WV_MONO_DATA) + shift_mono(samples_l, nb_samples, s->float_shift); + else + shift_stereo(samples_l, samples_r, nb_samples, s->float_shift); + } + + s->flags &= ~MAG_MASK; + + while (s->ordata) { + s->flags += 1 << MAG_LSB; + s->ordata >>= 1; + } + + if (s->false_zeros || s->neg_zeros) + s->float_flags |= FLOAT_ZEROS_SENT; + + if (s->neg_zeros) + s->float_flags |= FLOAT_NEG_ZEROS; + + return s->float_flags & (FLOAT_EXCEPTIONS | FLOAT_ZEROS_SENT | + FLOAT_SHIFT_SENT | FLOAT_SHIFT_SAME); +} + +static void scan_int23(WavPackEncodeContext *s, + int32_t *samples_l, int32_t *samples_r, + int nb_samples) +{ + uint32_t magdata = 0, ordata = 0, xordata = 0, anddata = ~0; + int i, total_shift = 0; + + s->int32_sent_bits = s->int32_zeros = s->int32_ones = s->int32_dups = 0; + + if (s->flags & WV_MONO_DATA) { + for (i = 0; i < nb_samples; i++) { + int32_t M = samples_l[i]; + + magdata |= (M < 0) ? ~M : M; + xordata |= M ^ -(M & 1); + anddata &= M; + ordata |= M; + + if ((ordata & 1) && !(anddata & 1) && (xordata & 2)) + return; + } + } else { + for (i = 0; i < nb_samples; i++) { + int32_t L = samples_l[i]; + int32_t R = samples_r[i]; + + magdata |= (L < 0) ? ~L : L; + magdata |= (R < 0) ? ~R : R; + xordata |= L ^ -(L & 1); + xordata |= R ^ -(R & 1); + anddata &= L & R; + ordata |= L | R; + + if ((ordata & 1) && !(anddata & 1) && (xordata & 2)) + return; + } + } + + s->flags &= ~MAG_MASK; + + while (magdata) { + s->flags += 1 << MAG_LSB; + magdata >>= 1; + } + + if (!(s->flags & MAG_MASK)) + return; + + if (!(ordata & 1)) { + do { + s->flags -= 1 << MAG_LSB; + s->int32_zeros++; + total_shift++; + ordata >>= 1; + } while (!(ordata & 1)); + } else if (anddata & 1) { + do { + s->flags -= 1 << MAG_LSB; + s->int32_ones++; + total_shift++; + anddata >>= 1; + } while (anddata & 1); + } else if (!(xordata & 2)) { + do { + s->flags -= 1 << MAG_LSB; + s->int32_dups++; + total_shift++; + xordata >>= 1; + } while (!(xordata & 2)); + } + + if (total_shift) { + s->flags |= WV_INT32_DATA; + + if (s->flags & WV_MONO_DATA) + shift_mono(samples_l, nb_samples, total_shift); + else + shift_stereo(samples_l, samples_r, nb_samples, total_shift); + } +} + +static int scan_int32(WavPackEncodeContext *s, + int32_t *samples_l, int32_t *samples_r, + int nb_samples) +{ + uint32_t magdata = 0, ordata = 0, xordata = 0, anddata = ~0; + uint32_t crc = 0xffffffffu; + int i, total_shift = 0; + + s->int32_sent_bits = s->int32_zeros = s->int32_ones = s->int32_dups = 0; + + if (s->flags & WV_MONO_DATA) { + for (i = 0; i < nb_samples; i++) { + int32_t M = samples_l[i]; + + crc = crc * 9 + (M & 0xffff) * 3 + ((M >> 16) & 0xffff); + magdata |= (M < 0) ? ~M : M; + xordata |= M ^ -(M & 1); + anddata &= M; + ordata |= M; + } + } else { + for (i = 0; i < nb_samples; i++) { + int32_t L = samples_l[i]; + int32_t R = samples_r[i]; + + crc = crc * 9 + (L & 0xffff) * 3 + ((L >> 16) & 0xffff); + crc = crc * 9 + (R & 0xffff) * 3 + ((R >> 16) & 0xffff); + magdata |= (L < 0) ? ~L : L; + magdata |= (R < 0) ? ~R : R; + xordata |= L ^ -(L & 1); + xordata |= R ^ -(R & 1); + anddata &= L & R; + ordata |= L | R; + } + } + + s->crc_x = crc; + s->flags &= ~MAG_MASK; + + while (magdata) { + s->flags += 1 << MAG_LSB; + magdata >>= 1; + } + + if (!((s->flags & MAG_MASK) >> MAG_LSB)) { + s->flags &= ~WV_INT32_DATA; + return 0; + } + + if (!(ordata & 1)) + do { + s->flags -= 1 << MAG_LSB; + s->int32_zeros++; + total_shift++; + ordata >>= 1; + } while (!(ordata & 1)); + else if (anddata & 1) + do { + s->flags -= 1 << MAG_LSB; + s->int32_ones++; + total_shift++; + anddata >>= 1; + } while (anddata & 1); + else if (!(xordata & 2)) + do { + s->flags -= 1 << MAG_LSB; + s->int32_dups++; + total_shift++; + xordata >>= 1; + } while (!(xordata & 2)); + + if (((s->flags & MAG_MASK) >> MAG_LSB) > 23) { + s->int32_sent_bits = (uint8_t)(((s->flags & MAG_MASK) >> MAG_LSB) - 23); + total_shift += s->int32_sent_bits; + s->flags &= ~MAG_MASK; + s->flags += 23 << MAG_LSB; + } + + if (total_shift) { + s->flags |= WV_INT32_DATA; + + if (s->flags & WV_MONO_DATA) + shift_mono(samples_l, nb_samples, total_shift); + else + shift_stereo(samples_l, samples_r, nb_samples, total_shift); + } + + return s->int32_sent_bits; +} + +static int8_t store_weight(int weight) +{ + weight = av_clip(weight, -1024, 1024); + if (weight > 0) + weight -= (weight + 64) >> 7; + + return (weight + 4) >> 3; +} + +static int restore_weight(int8_t weight) +{ + int result; + + if ((result = (int) weight << 3) > 0) + result += (result + 64) >> 7; + + return result; +} + +static int log2s(int32_t value) +{ + return (value < 0) ? -wp_log2(-value) : wp_log2(value); +} + +static void decorr_mono(int32_t *in_samples, int32_t *out_samples, + int nb_samples, struct Decorr *dpp, int dir) +{ + int m = 0, i; + + dpp->sumA = 0; + + if (dir < 0) { + out_samples += (nb_samples - 1); + in_samples += (nb_samples - 1); + } + + dpp->weightA = restore_weight(store_weight(dpp->weightA)); + + for (i = 0; i < MAX_TERM; i++) + dpp->samplesA[i] = wp_exp2(log2s(dpp->samplesA[i])); + + if (dpp->value > MAX_TERM) { + while (nb_samples--) { + int32_t left, sam_A; + + sam_A = ((3 - (dpp->value & 1)) * dpp->samplesA[0] - dpp->samplesA[1]) >> !(dpp->value & 1); + + dpp->samplesA[1] = dpp->samplesA[0]; + dpp->samplesA[0] = left = in_samples[0]; + + left -= APPLY_WEIGHT(dpp->weightA, sam_A); + UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam_A, left); + dpp->sumA += dpp->weightA; + out_samples[0] = left; + in_samples += dir; + out_samples += dir; + } + } else if (dpp->value > 0) { + while (nb_samples--) { + int k = (m + dpp->value) & (MAX_TERM - 1); + int32_t left, sam_A; + + sam_A = dpp->samplesA[m]; + dpp->samplesA[k] = left = in_samples[0]; + m = (m + 1) & (MAX_TERM - 1); + + left -= APPLY_WEIGHT(dpp->weightA, sam_A); + UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam_A, left); + dpp->sumA += dpp->weightA; + out_samples[0] = left; + in_samples += dir; + out_samples += dir; + } + } + + if (m && dpp->value > 0 && dpp->value <= MAX_TERM) { + int32_t temp_A[MAX_TERM]; + + memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA)); + + for (i = 0; i < MAX_TERM; i++) { + dpp->samplesA[i] = temp_A[m]; + m = (m + 1) & (MAX_TERM - 1); + } + } +} + +static void reverse_mono_decorr(struct Decorr *dpp) +{ + if (dpp->value > MAX_TERM) { + int32_t sam_A; + + if (dpp->value & 1) + sam_A = 2 * dpp->samplesA[0] - dpp->samplesA[1]; + else + sam_A = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1; + + dpp->samplesA[1] = dpp->samplesA[0]; + dpp->samplesA[0] = sam_A; + + if (dpp->value & 1) + sam_A = 2 * dpp->samplesA[0] - dpp->samplesA[1]; + else + sam_A = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1; + + dpp->samplesA[1] = sam_A; + } else if (dpp->value > 1) { + int i, j, k; + + for (i = 0, j = dpp->value - 1, k = 0; k < dpp->value / 2; i++, j--, k++) { + i &= (MAX_TERM - 1); + j &= (MAX_TERM - 1); + dpp->samplesA[i] ^= dpp->samplesA[j]; + dpp->samplesA[j] ^= dpp->samplesA[i]; + dpp->samplesA[i] ^= dpp->samplesA[j]; + } + } +} + +static uint32_t log2sample(uint32_t v, int limit, uint32_t *result) +{ + uint32_t dbits; + + if ((v += v >> 9) < (1 << 8)) { + dbits = nbits_table[v]; + result += (dbits << 8) + wp_log2_table[(v << (9 - dbits)) & 0xff]; + } else { + if (v < (1L << 16)) + dbits = nbits_table[v >> 8] + 8; + else if (v < (1L << 24)) + dbits = nbits_table[v >> 16] + 16; + else + dbits = nbits_table[v >> 24] + 24; + + result += dbits = (dbits << 8) + wp_log2_table[(v >> (dbits - 9)) & 0xff]; + + if (limit && dbits >= limit) + return 1; + } + + return 0; +} + +static uint32_t log2mono(int32_t *samples, int nb_samples, int limit) +{ + uint32_t result = 0; + while (nb_samples--) { + if (log2sample(abs(*samples++), limit, &result)) + return UINT32_MAX; + } + return result; +} + +static uint32_t log2stereo(int32_t *samples_l, int32_t *samples_r, + int nb_samples, int limit) +{ + uint32_t result = 0; + while (nb_samples--) { + if (log2sample(abs(*samples_l++), limit, &result) || + log2sample(abs(*samples_r++), limit, &result)) + return UINT32_MAX; + } + return result; +} + +static void decorr_mono_buffer(int32_t *samples, int32_t *outsamples, + int nb_samples, struct Decorr *dpp, + int tindex) +{ + struct Decorr dp, *dppi = dpp + tindex; + int delta = dppi->delta, pre_delta, term = dppi->value; + + if (delta == 7) + pre_delta = 7; + else if (delta < 2) + pre_delta = 3; + else + pre_delta = delta + 1; + + CLEAR(dp); + dp.value = term; + dp.delta = pre_delta; + decorr_mono(samples, outsamples, FFMIN(2048, nb_samples), &dp, -1); + dp.delta = delta; + + if (tindex == 0) + reverse_mono_decorr(&dp); + else + CLEAR(dp.samplesA); + + memcpy(dppi->samplesA, dp.samplesA, sizeof(dp.samplesA)); + dppi->weightA = dp.weightA; + + if (delta == 0) { + dp.delta = 1; + decorr_mono(samples, outsamples, nb_samples, &dp, 1); + dp.delta = 0; + memcpy(dp.samplesA, dppi->samplesA, sizeof(dp.samplesA)); + dppi->weightA = dp.weightA = dp.sumA / nb_samples; + } + + decorr_mono(samples, outsamples, nb_samples, &dp, 1); +} + +static void recurse_mono(WavPackEncodeContext *s, WavPackExtraInfo *info, + int depth, int delta, uint32_t input_bits) +{ + int term, branches = s->num_branches - depth; + int32_t *samples, *outsamples; + uint32_t term_bits[22], bits; + + if (branches < 1 || depth + 1 == info->nterms) + branches = 1; + + CLEAR(term_bits); + samples = s->sampleptrs[depth][0]; + outsamples = s->sampleptrs[depth + 1][0]; + + for (term = 1; term <= 18; term++) { + if (term == 17 && branches == 1 && depth + 1 < info->nterms) + continue; + + if (term > 8 && term < 17) + continue; + + if (!s->extra_flags && (term > 4 && term < 17)) + continue; + + info->dps[depth].value = term; + info->dps[depth].delta = delta; + decorr_mono_buffer(samples, outsamples, s->block_samples, info->dps, depth); + bits = log2mono(outsamples, s->block_samples, info->log_limit); + + if (bits < info->best_bits) { + info->best_bits = bits; + CLEAR(s->decorr_passes); + memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * (depth + 1)); + memcpy(s->sampleptrs[info->nterms + 1][0], + s->sampleptrs[depth + 1][0], s->block_samples * 4); + } + + term_bits[term + 3] = bits; + } + + while (depth + 1 < info->nterms && branches--) { + uint32_t local_best_bits = input_bits; + int best_term = 0, i; + + for (i = 0; i < 22; i++) + if (term_bits[i] && term_bits[i] < local_best_bits) { + local_best_bits = term_bits[i]; + best_term = i - 3; + } + + if (!best_term) + break; + + term_bits[best_term + 3] = 0; + + info->dps[depth].value = best_term; + info->dps[depth].delta = delta; + decorr_mono_buffer(samples, outsamples, s->block_samples, info->dps, depth); + + recurse_mono(s, info, depth + 1, delta, local_best_bits); + } +} + +static void sort_mono(WavPackEncodeContext *s, WavPackExtraInfo *info) +{ + int reversed = 1; + uint32_t bits; + + while (reversed) { + int ri, i; + + memcpy(info->dps, s->decorr_passes, sizeof(s->decorr_passes)); + reversed = 0; + + for (ri = 0; ri < info->nterms && s->decorr_passes[ri].value; ri++) { + + if (ri + 1 >= info->nterms || !s->decorr_passes[ri+1].value) + break; + + if (s->decorr_passes[ri].value == s->decorr_passes[ri+1].value) { + decorr_mono_buffer(s->sampleptrs[ri][0], s->sampleptrs[ri+1][0], + s->block_samples, info->dps, ri); + continue; + } + + info->dps[ri ] = s->decorr_passes[ri+1]; + info->dps[ri+1] = s->decorr_passes[ri ]; + + for (i = ri; i < info->nterms && s->decorr_passes[i].value; i++) + decorr_mono_buffer(s->sampleptrs[i][0], s->sampleptrs[i+1][0], + s->block_samples, info->dps, i); + + bits = log2mono(s->sampleptrs[i][0], s->block_samples, info->log_limit); + if (bits < info->best_bits) { + reversed = 1; + info->best_bits = bits; + CLEAR(s->decorr_passes); + memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i); + memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[i][0], + s->block_samples * 4); + } else { + info->dps[ri ] = s->decorr_passes[ri]; + info->dps[ri+1] = s->decorr_passes[ri+1]; + decorr_mono_buffer(s->sampleptrs[ri][0], s->sampleptrs[ri+1][0], + s->block_samples, info->dps, ri); + } + } + } +} + +static void delta_mono(WavPackEncodeContext *s, WavPackExtraInfo *info) +{ + int lower = 0, delta, d; + uint32_t bits; + + if (!s->decorr_passes[0].value) + return; + delta = s->decorr_passes[0].delta; + + for (d = delta - 1; d >= 0; d--) { + int i; + + for (i = 0; i < info->nterms && s->decorr_passes[i].value; i++) { + info->dps[i].value = s->decorr_passes[i].value; + info->dps[i].delta = d; + decorr_mono_buffer(s->sampleptrs[i][0], s->sampleptrs[i+1][0], + s->block_samples, info->dps, i); + } + + bits = log2mono(s->sampleptrs[i][0], s->block_samples, info->log_limit); + if (bits >= info->best_bits) + break; + + lower = 1; + info->best_bits = bits; + CLEAR(s->decorr_passes); + memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i); + memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[i][0], + s->block_samples * 4); + } + + for (d = delta + 1; !lower && d <= 7; d++) { + int i; + + for (i = 0; i < info->nterms && s->decorr_passes[i].value; i++) { + info->dps[i].value = s->decorr_passes[i].value; + info->dps[i].delta = d; + decorr_mono_buffer(s->sampleptrs[i][0], s->sampleptrs[i+1][0], + s->block_samples, info->dps, i); + } + + bits = log2mono(s->sampleptrs[i][0], s->block_samples, info->log_limit); + if (bits >= info->best_bits) + break; + + info->best_bits = bits; + CLEAR(s->decorr_passes); + memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i); + memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[i][0], + s->block_samples * 4); + } +} + +static int allocate_buffers2(WavPackEncodeContext *s, int nterms) +{ + int i; + + for (i = 0; i < nterms + 2; i++) { + av_fast_padded_malloc(&s->sampleptrs[i][0], &s->sampleptrs_size[i][0], + s->block_samples * 4); + if (!s->sampleptrs[i][0]) + return AVERROR(ENOMEM); + if (!(s->flags & WV_MONO_DATA)) { + av_fast_padded_malloc(&s->sampleptrs[i][1], &s->sampleptrs_size[i][1], + s->block_samples * 4); + if (!s->sampleptrs[i][1]) + return AVERROR(ENOMEM); + } + } + + return 0; +} + +static int allocate_buffers(WavPackEncodeContext *s) +{ + int i; + + for (i = 0; i < 2; i++) { + av_fast_padded_malloc(&s->best_buffer[0], &s->best_buffer_size[0], + s->block_samples * 4); + if (!s->best_buffer[0]) + return AVERROR(ENOMEM); + + av_fast_padded_malloc(&s->temp_buffer[i][0], &s->temp_buffer_size[i][0], + s->block_samples * 4); + if (!s->temp_buffer[i][0]) + return AVERROR(ENOMEM); + if (!(s->flags & WV_MONO_DATA)) { + av_fast_padded_malloc(&s->best_buffer[1], &s->best_buffer_size[1], + s->block_samples * 4); + if (!s->best_buffer[1]) + return AVERROR(ENOMEM); + + av_fast_padded_malloc(&s->temp_buffer[i][1], &s->temp_buffer_size[i][1], + s->block_samples * 4); + if (!s->temp_buffer[i][1]) + return AVERROR(ENOMEM); + } + } + + return 0; +} + +static void analyze_mono(WavPackEncodeContext *s, int32_t *samples, int do_samples) +{ + WavPackExtraInfo info; + int i; + + info.log_limit = (((s->flags & MAG_MASK) >> MAG_LSB) + 4) * 256; + info.log_limit = FFMIN(6912, info.log_limit); + + info.nterms = s->num_terms; + + if (allocate_buffers2(s, s->num_terms)) + return; + + memcpy(info.dps, s->decorr_passes, sizeof(info.dps)); + memcpy(s->sampleptrs[0][0], samples, s->block_samples * 4); + + for (i = 0; i < info.nterms && info.dps[i].value; i++) + decorr_mono(s->sampleptrs[i][0], s->sampleptrs[i + 1][0], + s->block_samples, info.dps + i, 1); + + info.best_bits = log2mono(s->sampleptrs[info.nterms][0], s->block_samples, 0) * 1; + memcpy(s->sampleptrs[info.nterms + 1][0], s->sampleptrs[i][0], s->block_samples * 4); + + if (s->extra_flags & EXTRA_BRANCHES) + recurse_mono(s, &info, 0, (int) floor(s->delta_decay + 0.5), + log2mono(s->sampleptrs[0][0], s->block_samples, 0)); + + if (s->extra_flags & EXTRA_SORT_FIRST) + sort_mono(s, &info); + + if (s->extra_flags & EXTRA_TRY_DELTAS) { + delta_mono(s, &info); + + if ((s->extra_flags & EXTRA_ADJUST_DELTAS) && s->decorr_passes[0].value) + s->delta_decay = (float)((s->delta_decay * 2.0 + s->decorr_passes[0].delta) / 3.0); + else + s->delta_decay = 2.0; + } + + if (s->extra_flags & EXTRA_SORT_LAST) + sort_mono(s, &info); + + if (do_samples) + memcpy(samples, s->sampleptrs[info.nterms + 1][0], s->block_samples * 4); + + for (i = 0; i < info.nterms; i++) + if (!s->decorr_passes[i].value) + break; + + s->num_terms = i; +} + +static void scan_word(WavPackEncodeContext *s, WvChannel *c, + int32_t *samples, int nb_samples, int dir) +{ + if (dir < 0) + samples += nb_samples - 1; + + while (nb_samples--) { + uint32_t low, value = labs(samples[0]); + + if (value < GET_MED(0)) { + DEC_MED(0); + } else { + low = GET_MED(0); + INC_MED(0); + + if (value - low < GET_MED(1)) { + DEC_MED(1); + } else { + low += GET_MED(1); + INC_MED(1); + + if (value - low < GET_MED(2)) { + DEC_MED(2); + } else { + INC_MED(2); + } + } + } + samples += dir; + } +} + +static int wv_mono(WavPackEncodeContext *s, int32_t *samples, + int no_history, int do_samples) +{ + struct Decorr temp_decorr_pass, save_decorr_passes[MAX_TERMS] = {{0}}; + int nb_samples = s->block_samples; + int buf_size = sizeof(int32_t) * nb_samples; + uint32_t best_size = UINT32_MAX, size; + int log_limit, pi, i, ret; + + for (i = 0; i < nb_samples; i++) + if (samples[i]) + break; + + if (i == nb_samples) { + CLEAR(s->decorr_passes); + CLEAR(s->w); + s->num_terms = 0; + return 0; + } + + log_limit = (((s->flags & MAG_MASK) >> MAG_LSB) + 4) * 256; + log_limit = FFMIN(6912, log_limit); + + if ((ret = allocate_buffers(s)) < 0) + return ret; + + if (no_history || s->num_passes >= 7) + s->best_decorr = s->mask_decorr = 0; + + for (pi = 0; pi < s->num_passes;) { + const WavPackDecorrSpec *wpds; + int nterms, c, j; + + if (!pi) { + c = s->best_decorr; + } else { + if (s->mask_decorr == 0) + c = 0; + else + c = (s->best_decorr & (s->mask_decorr - 1)) | s->mask_decorr; + + if (c == s->best_decorr) { + s->mask_decorr = s->mask_decorr ? ((s->mask_decorr << 1) & (s->num_decorrs - 1)) : 1; + continue; + } + } + + wpds = &s->decorr_specs[c]; + nterms = decorr_filter_nterms[s->decorr_filter]; + + while (1) { + memcpy(s->temp_buffer[0][0], samples, buf_size); + CLEAR(save_decorr_passes); + + for (j = 0; j < nterms; j++) { + CLEAR(temp_decorr_pass); + temp_decorr_pass.delta = wpds->delta; + temp_decorr_pass.value = wpds->terms[j]; + + if (temp_decorr_pass.value < 0) + temp_decorr_pass.value = 1; + + decorr_mono(s->temp_buffer[j&1][0], s->temp_buffer[~j&1][0], + FFMIN(nb_samples, 2048), &temp_decorr_pass, -1); + + if (j) { + CLEAR(temp_decorr_pass.samplesA); + } else { + reverse_mono_decorr(&temp_decorr_pass); + } + + memcpy(save_decorr_passes + j, &temp_decorr_pass, sizeof(struct Decorr)); + decorr_mono(s->temp_buffer[j&1][0], s->temp_buffer[~j&1][0], + nb_samples, &temp_decorr_pass, 1); + } + + size = log2mono(s->temp_buffer[j&1][0], nb_samples, log_limit); + if (size != UINT32_MAX || !nterms) + break; + nterms >>= 1; + } + + if (size < best_size) { + memcpy(s->best_buffer[0], s->temp_buffer[j&1][0], buf_size); + memcpy(s->decorr_passes, save_decorr_passes, sizeof(struct Decorr) * MAX_TERMS); + s->num_terms = nterms; + s->best_decorr = c; + best_size = size; + } + + if (pi++) + s->mask_decorr = s->mask_decorr ? ((s->mask_decorr << 1) & (s->num_decorrs - 1)) : 1; + } + + if (s->extra_flags) + analyze_mono(s, samples, do_samples); + else if (do_samples) + memcpy(samples, s->best_buffer[0], buf_size); + + if (no_history || s->extra_flags) { + CLEAR(s->w); + scan_word(s, &s->w.c[0], s->best_buffer[0], nb_samples, -1); + } + return 0; +} + +static void decorr_stereo(int32_t *in_left, int32_t *in_right, + int32_t *out_left, int32_t *out_right, + int nb_samples, struct Decorr *dpp, int dir) +{ + int m = 0, i; + + dpp->sumA = dpp->sumB = 0; + + if (dir < 0) { + out_left += nb_samples - 1; + out_right += nb_samples - 1; + in_left += nb_samples - 1; + in_right += nb_samples - 1; + } + + dpp->weightA = restore_weight(store_weight(dpp->weightA)); + dpp->weightB = restore_weight(store_weight(dpp->weightB)); + + for (i = 0; i < MAX_TERM; i++) { + dpp->samplesA[i] = wp_exp2(log2s(dpp->samplesA[i])); + dpp->samplesB[i] = wp_exp2(log2s(dpp->samplesB[i])); + } + + switch (dpp->value) { + case 2: + while (nb_samples--) { + int32_t sam, tmp; + + sam = dpp->samplesA[0]; + dpp->samplesA[0] = dpp->samplesA[1]; + out_left[0] = tmp = (dpp->samplesA[1] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam); + UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); + dpp->sumA += dpp->weightA; + + sam = dpp->samplesB[0]; + dpp->samplesB[0] = dpp->samplesB[1]; + out_right[0] = tmp = (dpp->samplesB[1] = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam); + UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); + dpp->sumB += dpp->weightB; + + in_left += dir; + out_left += dir; + in_right += dir; + out_right += dir; + } + break; + case 17: + while (nb_samples--) { + int32_t sam, tmp; + + sam = 2 * dpp->samplesA[0] - dpp->samplesA[1]; + dpp->samplesA[1] = dpp->samplesA[0]; + out_left[0] = tmp = (dpp->samplesA[0] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam); + UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); + dpp->sumA += dpp->weightA; + + sam = 2 * dpp->samplesB[0] - dpp->samplesB[1]; + dpp->samplesB[1] = dpp->samplesB[0]; + out_right[0] = tmp = (dpp->samplesB[0] = in_right[0]) - APPLY_WEIGHT (dpp->weightB, sam); + UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); + dpp->sumB += dpp->weightB; + + in_left += dir; + out_left += dir; + in_right += dir; + out_right += dir; + } + break; + case 18: + while (nb_samples--) { + int32_t sam, tmp; + + sam = dpp->samplesA[0] + ((dpp->samplesA[0] - dpp->samplesA[1]) >> 1); + dpp->samplesA[1] = dpp->samplesA[0]; + out_left[0] = tmp = (dpp->samplesA[0] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam); + UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); + dpp->sumA += dpp->weightA; + + sam = dpp->samplesB[0] + ((dpp->samplesB[0] - dpp->samplesB[1]) >> 1); + dpp->samplesB[1] = dpp->samplesB[0]; + out_right[0] = tmp = (dpp->samplesB[0] = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam); + UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); + dpp->sumB += dpp->weightB; + + in_left += dir; + out_left += dir; + in_right += dir; + out_right += dir; + } + break; + default: { + int k = dpp->value & (MAX_TERM - 1); + + while (nb_samples--) { + int32_t sam, tmp; + + sam = dpp->samplesA[m]; + out_left[0] = tmp = (dpp->samplesA[k] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam); + UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); + dpp->sumA += dpp->weightA; + + sam = dpp->samplesB[m]; + out_right[0] = tmp = (dpp->samplesB[k] = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam); + UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); + dpp->sumB += dpp->weightB; + + in_left += dir; + out_left += dir; + in_right += dir; + out_right += dir; + m = (m + 1) & (MAX_TERM - 1); + k = (k + 1) & (MAX_TERM - 1); + } + + if (m) { + int32_t temp_A[MAX_TERM], temp_B[MAX_TERM]; + int k; + + memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA)); + memcpy(temp_B, dpp->samplesB, sizeof(dpp->samplesB)); + + for (k = 0; k < MAX_TERM; k++) { + dpp->samplesA[k] = temp_A[m]; + dpp->samplesB[k] = temp_B[m]; + m = (m + 1) & (MAX_TERM - 1); + } + } + break; + } + case -1: + while (nb_samples--) { + int32_t sam_A, sam_B, tmp; + + sam_A = dpp->samplesA[0]; + out_left[0] = tmp = (sam_B = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam_A); + UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); + dpp->sumA += dpp->weightA; + + out_right[0] = tmp = (dpp->samplesA[0] = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam_B); + UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); + dpp->sumB += dpp->weightB; + + in_left += dir; + out_left += dir; + in_right += dir; + out_right += dir; + } + break; + case -2: + while (nb_samples--) { + int32_t sam_A, sam_B, tmp; + + sam_B = dpp->samplesB[0]; + out_right[0] = tmp = (sam_A = in_right[0]) - APPLY_WEIGHT(dpp->weightB, sam_B); + UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); + dpp->sumB += dpp->weightB; + + out_left[0] = tmp = (dpp->samplesB[0] = in_left[0]) - APPLY_WEIGHT(dpp->weightA, sam_A); + UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); + dpp->sumA += dpp->weightA; + + in_left += dir; + out_left += dir; + in_right += dir; + out_right += dir; + } + break; + case -3: + while (nb_samples--) { + int32_t sam_A, sam_B, tmp; + + sam_A = dpp->samplesA[0]; + sam_B = dpp->samplesB[0]; + + dpp->samplesA[0] = tmp = in_right[0]; + out_right[0] = tmp -= APPLY_WEIGHT(dpp->weightB, sam_B); + UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); + dpp->sumB += dpp->weightB; + + dpp->samplesB[0] = tmp = in_left[0]; + out_left[0] = tmp -= APPLY_WEIGHT(dpp->weightA, sam_A); + UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); + dpp->sumA += dpp->weightA; + + in_left += dir; + out_left += dir; + in_right += dir; + out_right += dir; + } + break; + } +} + +static void reverse_decorr(struct Decorr *dpp) +{ + if (dpp->value > MAX_TERM) { + int32_t sam_A, sam_B; + + if (dpp->value & 1) { + sam_A = 2 * dpp->samplesA[0] - dpp->samplesA[1]; + sam_B = 2 * dpp->samplesB[0] - dpp->samplesB[1]; + } else { + sam_A = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1; + sam_B = (3 * dpp->samplesB[0] - dpp->samplesB[1]) >> 1; + } + + dpp->samplesA[1] = dpp->samplesA[0]; + dpp->samplesB[1] = dpp->samplesB[0]; + dpp->samplesA[0] = sam_A; + dpp->samplesB[0] = sam_B; + + if (dpp->value & 1) { + sam_A = 2 * dpp->samplesA[0] - dpp->samplesA[1]; + sam_B = 2 * dpp->samplesB[0] - dpp->samplesB[1]; + } else { + sam_A = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1; + sam_B = (3 * dpp->samplesB[0] - dpp->samplesB[1]) >> 1; + } + + dpp->samplesA[1] = sam_A; + dpp->samplesB[1] = sam_B; + } else if (dpp->value > 1) { + int i, j, k; + + for (i = 0, j = dpp->value - 1, k = 0; k < dpp->value / 2; i++, j--, k++) { + i &= (MAX_TERM - 1); + j &= (MAX_TERM - 1); + dpp->samplesA[i] ^= dpp->samplesA[j]; + dpp->samplesA[j] ^= dpp->samplesA[i]; + dpp->samplesA[i] ^= dpp->samplesA[j]; + dpp->samplesB[i] ^= dpp->samplesB[j]; + dpp->samplesB[j] ^= dpp->samplesB[i]; + dpp->samplesB[i] ^= dpp->samplesB[j]; + } + } +} + +static void decorr_stereo_quick(int32_t *in_left, int32_t *in_right, + int32_t *out_left, int32_t *out_right, + int nb_samples, struct Decorr *dpp) +{ + int m = 0, i; + + dpp->weightA = restore_weight(store_weight(dpp->weightA)); + dpp->weightB = restore_weight(store_weight(dpp->weightB)); + + for (i = 0; i < MAX_TERM; i++) { + dpp->samplesA[i] = wp_exp2(log2s(dpp->samplesA[i])); + dpp->samplesB[i] = wp_exp2(log2s(dpp->samplesB[i])); + } + + switch (dpp->value) { + case 2: + for (i = 0; i < nb_samples; i++) { + int32_t sam, tmp; + + sam = dpp->samplesA[0]; + dpp->samplesA[0] = dpp->samplesA[1]; + out_left[i] = tmp = (dpp->samplesA[1] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam); + UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); + + sam = dpp->samplesB[0]; + dpp->samplesB[0] = dpp->samplesB[1]; + out_right[i] = tmp = (dpp->samplesB[1] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam); + UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); + } + break; + case 17: + for (i = 0; i < nb_samples; i++) { + int32_t sam, tmp; + + sam = 2 * dpp->samplesA[0] - dpp->samplesA[1]; + dpp->samplesA[1] = dpp->samplesA[0]; + out_left[i] = tmp = (dpp->samplesA[0] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam); + UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); + + sam = 2 * dpp->samplesB[0] - dpp->samplesB[1]; + dpp->samplesB[1] = dpp->samplesB[0]; + out_right[i] = tmp = (dpp->samplesB[0] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam); + UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); + } + break; + case 18: + for (i = 0; i < nb_samples; i++) { + int32_t sam, tmp; + + sam = dpp->samplesA[0] + ((dpp->samplesA[0] - dpp->samplesA[1]) >> 1); + dpp->samplesA[1] = dpp->samplesA[0]; + out_left[i] = tmp = (dpp->samplesA[0] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam); + UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); + + sam = dpp->samplesB[0] + ((dpp->samplesB[0] - dpp->samplesB[1]) >> 1); + dpp->samplesB[1] = dpp->samplesB[0]; + out_right[i] = tmp = (dpp->samplesB[0] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam); + UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); + } + break; + default: { + int k = dpp->value & (MAX_TERM - 1); + + for (i = 0; i < nb_samples; i++) { + int32_t sam, tmp; + + sam = dpp->samplesA[m]; + out_left[i] = tmp = (dpp->samplesA[k] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam); + UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); + + sam = dpp->samplesB[m]; + out_right[i] = tmp = (dpp->samplesB[k] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam); + UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); + + m = (m + 1) & (MAX_TERM - 1); + k = (k + 1) & (MAX_TERM - 1); + } + + if (m) { + int32_t temp_A[MAX_TERM], temp_B[MAX_TERM]; + int k; + + memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA)); + memcpy(temp_B, dpp->samplesB, sizeof(dpp->samplesB)); + + for (k = 0; k < MAX_TERM; k++) { + dpp->samplesA[k] = temp_A[m]; + dpp->samplesB[k] = temp_B[m]; + m = (m + 1) & (MAX_TERM - 1); + } + } + break; + } + case -1: + for (i = 0; i < nb_samples; i++) { + int32_t sam_A, sam_B, tmp; + + sam_A = dpp->samplesA[0]; + out_left[i] = tmp = (sam_B = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam_A); + UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); + + out_right[i] = tmp = (dpp->samplesA[0] = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam_B); + UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); + } + break; + case -2: + for (i = 0; i < nb_samples; i++) { + int32_t sam_A, sam_B, tmp; + + sam_B = dpp->samplesB[0]; + out_right[i] = tmp = (sam_A = in_right[i]) - APPLY_WEIGHT_I(dpp->weightB, sam_B); + UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); + + out_left[i] = tmp = (dpp->samplesB[0] = in_left[i]) - APPLY_WEIGHT_I(dpp->weightA, sam_A); + UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); + } + break; + case -3: + for (i = 0; i < nb_samples; i++) { + int32_t sam_A, sam_B, tmp; + + sam_A = dpp->samplesA[0]; + sam_B = dpp->samplesB[0]; + + dpp->samplesA[0] = tmp = in_right[i]; + out_right[i] = tmp -= APPLY_WEIGHT_I(dpp->weightB, sam_B); + UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); + + dpp->samplesB[0] = tmp = in_left[i]; + out_left[i] = tmp -= APPLY_WEIGHT_I(dpp->weightA, sam_A); + UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); + } + break; + } +} + +static void decorr_stereo_buffer(WavPackExtraInfo *info, + int32_t *in_left, int32_t *in_right, + int32_t *out_left, int32_t *out_right, + int nb_samples, int tindex) +{ + struct Decorr dp = {0}, *dppi = info->dps + tindex; + int delta = dppi->delta, pre_delta; + int term = dppi->value; + + if (delta == 7) + pre_delta = 7; + else if (delta < 2) + pre_delta = 3; + else + pre_delta = delta + 1; + + dp.value = term; + dp.delta = pre_delta; + decorr_stereo(in_left, in_right, out_left, out_right, + FFMIN(2048, nb_samples), &dp, -1); + dp.delta = delta; + + if (tindex == 0) { + reverse_decorr(&dp); + } else { + CLEAR(dp.samplesA); + CLEAR(dp.samplesB); + } + + memcpy(dppi->samplesA, dp.samplesA, sizeof(dp.samplesA)); + memcpy(dppi->samplesB, dp.samplesB, sizeof(dp.samplesB)); + dppi->weightA = dp.weightA; + dppi->weightB = dp.weightB; + + if (delta == 0) { + dp.delta = 1; + decorr_stereo(in_left, in_right, out_left, out_right, nb_samples, &dp, 1); + dp.delta = 0; + memcpy(dp.samplesA, dppi->samplesA, sizeof(dp.samplesA)); + memcpy(dp.samplesB, dppi->samplesB, sizeof(dp.samplesB)); + dppi->weightA = dp.weightA = dp.sumA / nb_samples; + dppi->weightB = dp.weightB = dp.sumB / nb_samples; + } + + if (info->gt16bit) + decorr_stereo(in_left, in_right, out_left, out_right, + nb_samples, &dp, 1); + else + decorr_stereo_quick(in_left, in_right, out_left, out_right, + nb_samples, &dp); +} + +static void sort_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info) +{ + int reversed = 1; + uint32_t bits; + + while (reversed) { + int ri, i; + + memcpy(info->dps, s->decorr_passes, sizeof(s->decorr_passes)); + reversed = 0; + + for (ri = 0; ri < info->nterms && s->decorr_passes[ri].value; ri++) { + + if (ri + 1 >= info->nterms || !s->decorr_passes[ri+1].value) + break; + + if (s->decorr_passes[ri].value == s->decorr_passes[ri+1].value) { + decorr_stereo_buffer(info, + s->sampleptrs[ri ][0], s->sampleptrs[ri ][1], + s->sampleptrs[ri+1][0], s->sampleptrs[ri+1][1], + s->block_samples, ri); + continue; + } + + info->dps[ri ] = s->decorr_passes[ri+1]; + info->dps[ri+1] = s->decorr_passes[ri ]; + + for (i = ri; i < info->nterms && s->decorr_passes[i].value; i++) + decorr_stereo_buffer(info, + s->sampleptrs[i ][0], s->sampleptrs[i ][1], + s->sampleptrs[i+1][0], s->sampleptrs[i+1][1], + s->block_samples, i); + + bits = log2stereo(s->sampleptrs[i][0], s->sampleptrs[i][1], + s->block_samples, info->log_limit); + + if (bits < info->best_bits) { + reversed = 1; + info->best_bits = bits; + CLEAR(s->decorr_passes); + memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i); + memcpy(s->sampleptrs[info->nterms + 1][0], + s->sampleptrs[i][0], s->block_samples * 4); + memcpy(s->sampleptrs[info->nterms + 1][1], + s->sampleptrs[i][1], s->block_samples * 4); + } else { + info->dps[ri ] = s->decorr_passes[ri ]; + info->dps[ri+1] = s->decorr_passes[ri+1]; + decorr_stereo_buffer(info, + s->sampleptrs[ri ][0], s->sampleptrs[ri ][1], + s->sampleptrs[ri+1][0], s->sampleptrs[ri+1][1], + s->block_samples, ri); + } + } + } +} + +static void delta_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info) +{ + int lower = 0, delta, d, i; + uint32_t bits; + + if (!s->decorr_passes[0].value) + return; + delta = s->decorr_passes[0].delta; + + for (d = delta - 1; d >= 0; d--) { + for (i = 0; i < info->nterms && s->decorr_passes[i].value; i++) { + info->dps[i].value = s->decorr_passes[i].value; + info->dps[i].delta = d; + decorr_stereo_buffer(info, + s->sampleptrs[i ][0], s->sampleptrs[i ][1], + s->sampleptrs[i+1][0], s->sampleptrs[i+1][1], + s->block_samples, i); + } + + bits = log2stereo(s->sampleptrs[i][0], s->sampleptrs[i][1], + s->block_samples, info->log_limit); + if (bits >= info->best_bits) + break; + lower = 1; + info->best_bits = bits; + CLEAR(s->decorr_passes); + memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i); + memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[i][0], + s->block_samples * 4); + memcpy(s->sampleptrs[info->nterms + 1][1], s->sampleptrs[i][1], + s->block_samples * 4); + } + + for (d = delta + 1; !lower && d <= 7; d++) { + for (i = 0; i < info->nterms && s->decorr_passes[i].value; i++) { + info->dps[i].value = s->decorr_passes[i].value; + info->dps[i].delta = d; + decorr_stereo_buffer(info, + s->sampleptrs[i ][0], s->sampleptrs[i ][1], + s->sampleptrs[i+1][0], s->sampleptrs[i+1][1], + s->block_samples, i); + } + + bits = log2stereo(s->sampleptrs[i][0], s->sampleptrs[i][1], + s->block_samples, info->log_limit); + + if (bits < info->best_bits) { + info->best_bits = bits; + CLEAR(s->decorr_passes); + memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * i); + memcpy(s->sampleptrs[info->nterms + 1][0], + s->sampleptrs[i][0], s->block_samples * 4); + memcpy(s->sampleptrs[info->nterms + 1][1], + s->sampleptrs[i][1], s->block_samples * 4); + } + else + break; + } +} + +static void recurse_stereo(WavPackEncodeContext *s, WavPackExtraInfo *info, + int depth, int delta, uint32_t input_bits) +{ + int term, branches = s->num_branches - depth; + int32_t *in_left, *in_right, *out_left, *out_right; + uint32_t term_bits[22], bits; + + if (branches < 1 || depth + 1 == info->nterms) + branches = 1; + + CLEAR(term_bits); + in_left = s->sampleptrs[depth ][0]; + in_right = s->sampleptrs[depth ][1]; + out_left = s->sampleptrs[depth + 1][0]; + out_right = s->sampleptrs[depth + 1][1]; + + for (term = -3; term <= 18; term++) { + if (!term || (term > 8 && term < 17)) + continue; + + if (term == 17 && branches == 1 && depth + 1 < info->nterms) + continue; + + if (term == -1 || term == -2) + if (!(s->flags & WV_CROSS_DECORR)) + continue; + + if (!s->extra_flags && (term > 4 && term < 17)) + continue; + + info->dps[depth].value = term; + info->dps[depth].delta = delta; + decorr_stereo_buffer(info, in_left, in_right, out_left, out_right, + s->block_samples, depth); + bits = log2stereo(out_left, out_right, s->block_samples, info->log_limit); + + if (bits < info->best_bits) { + info->best_bits = bits; + CLEAR(s->decorr_passes); + memcpy(s->decorr_passes, info->dps, sizeof(info->dps[0]) * (depth + 1)); + memcpy(s->sampleptrs[info->nterms + 1][0], s->sampleptrs[depth + 1][0], + s->block_samples * 4); + memcpy(s->sampleptrs[info->nterms + 1][1], s->sampleptrs[depth + 1][1], + s->block_samples * 4); + } + + term_bits[term + 3] = bits; + } + + while (depth + 1 < info->nterms && branches--) { + uint32_t local_best_bits = input_bits; + int best_term = 0, i; + + for (i = 0; i < 22; i++) + if (term_bits[i] && term_bits[i] < local_best_bits) { + local_best_bits = term_bits[i]; + best_term = i - 3; + } + + if (!best_term) + break; + + term_bits[best_term + 3] = 0; + + info->dps[depth].value = best_term; + info->dps[depth].delta = delta; + decorr_stereo_buffer(info, in_left, in_right, out_left, out_right, + s->block_samples, depth); + + recurse_stereo(s, info, depth + 1, delta, local_best_bits); + } +} + +static void analyze_stereo(WavPackEncodeContext *s, + int32_t *in_left, int32_t *in_right, + int do_samples) +{ + WavPackExtraInfo info; + int i; + + info.gt16bit = ((s->flags & MAG_MASK) >> MAG_LSB) >= 16; + + info.log_limit = (((s->flags & MAG_MASK) >> MAG_LSB) + 4) * 256; + info.log_limit = FFMIN(6912, info.log_limit); + + info.nterms = s->num_terms; + + if (allocate_buffers2(s, s->num_terms)) + return; + + memcpy(info.dps, s->decorr_passes, sizeof(info.dps)); + memcpy(s->sampleptrs[0][0], in_left, s->block_samples * 4); + memcpy(s->sampleptrs[0][1], in_right, s->block_samples * 4); + + for (i = 0; i < info.nterms && info.dps[i].value; i++) + if (info.gt16bit) + decorr_stereo(s->sampleptrs[i ][0], s->sampleptrs[i ][1], + s->sampleptrs[i + 1][0], s->sampleptrs[i + 1][1], + s->block_samples, info.dps + i, 1); + else + decorr_stereo_quick(s->sampleptrs[i ][0], s->sampleptrs[i ][1], + s->sampleptrs[i + 1][0], s->sampleptrs[i + 1][1], + s->block_samples, info.dps + i); + + info.best_bits = log2stereo(s->sampleptrs[info.nterms][0], s->sampleptrs[info.nterms][1], + s->block_samples, 0); + + memcpy(s->sampleptrs[info.nterms + 1][0], s->sampleptrs[i][0], s->block_samples * 4); + memcpy(s->sampleptrs[info.nterms + 1][1], s->sampleptrs[i][1], s->block_samples * 4); + + if (s->extra_flags & EXTRA_BRANCHES) + recurse_stereo(s, &info, 0, (int) floor(s->delta_decay + 0.5), + log2stereo(s->sampleptrs[0][0], s->sampleptrs[0][1], + s->block_samples, 0)); + + if (s->extra_flags & EXTRA_SORT_FIRST) + sort_stereo(s, &info); + + if (s->extra_flags & EXTRA_TRY_DELTAS) { + delta_stereo(s, &info); + + if ((s->extra_flags & EXTRA_ADJUST_DELTAS) && s->decorr_passes[0].value) + s->delta_decay = (float)((s->delta_decay * 2.0 + s->decorr_passes[0].delta) / 3.0); + else + s->delta_decay = 2.0; + } + + if (s->extra_flags & EXTRA_SORT_LAST) + sort_stereo(s, &info); + + if (do_samples) { + memcpy(in_left, s->sampleptrs[info.nterms + 1][0], s->block_samples * 4); + memcpy(in_right, s->sampleptrs[info.nterms + 1][1], s->block_samples * 4); + } + + for (i = 0; i < info.nterms; i++) + if (!s->decorr_passes[i].value) + break; + + s->num_terms = i; +} + +static int wv_stereo(WavPackEncodeContext *s, + int32_t *samples_l, int32_t *samples_r, + int no_history, int do_samples) +{ + struct Decorr temp_decorr_pass, save_decorr_passes[MAX_TERMS] = {{0}}; + int nb_samples = s->block_samples, ret; + int buf_size = sizeof(int32_t) * nb_samples; + int log_limit, force_js = 0, force_ts = 0, got_js = 0, pi, i; + uint32_t best_size = UINT32_MAX, size; + + for (i = 0; i < nb_samples; i++) + if (samples_l[i] || samples_r[i]) + break; + + if (i == nb_samples) { + s->flags &= ~((uint32_t) WV_JOINT_STEREO); + CLEAR(s->decorr_passes); + CLEAR(s->w); + s->num_terms = 0; + return 0; + } + + log_limit = (((s->flags & MAG_MASK) >> MAG_LSB) + 4) * 256; + log_limit = FFMIN(6912, log_limit); + + if (s->joint) { + force_js = s->joint > 0; + force_ts = s->joint < 0; + } + + if ((ret = allocate_buffers(s)) < 0) + return ret; + + if (no_history || s->num_passes >= 7) + s->best_decorr = s->mask_decorr = 0; + + for (pi = 0; pi < s->num_passes;) { + const WavPackDecorrSpec *wpds; + int nterms, c, j; + + if (!pi) + c = s->best_decorr; + else { + if (s->mask_decorr == 0) + c = 0; + else + c = (s->best_decorr & (s->mask_decorr - 1)) | s->mask_decorr; + + if (c == s->best_decorr) { + s->mask_decorr = s->mask_decorr ? ((s->mask_decorr << 1) & (s->num_decorrs - 1)) : 1; + continue; + } + } + + wpds = &s->decorr_specs[c]; + nterms = decorr_filter_nterms[s->decorr_filter]; + + while (1) { + if (force_js || (wpds->joint_stereo && !force_ts)) { + if (!got_js) { + av_fast_padded_malloc(&s->js_left, &s->js_left_size, buf_size); + av_fast_padded_malloc(&s->js_right, &s->js_right_size, buf_size); + memcpy(s->js_left, samples_l, buf_size); + memcpy(s->js_right, samples_r, buf_size); + + for (i = 0; i < nb_samples; i++) + s->js_right[i] += ((s->js_left[i] -= s->js_right[i]) >> 1); + got_js = 1; + } + + memcpy(s->temp_buffer[0][0], s->js_left, buf_size); + memcpy(s->temp_buffer[0][1], s->js_right, buf_size); + } else { + memcpy(s->temp_buffer[0][0], samples_l, buf_size); + memcpy(s->temp_buffer[0][1], samples_r, buf_size); + } + + CLEAR(save_decorr_passes); + + for (j = 0; j < nterms; j++) { + CLEAR(temp_decorr_pass); + temp_decorr_pass.delta = wpds->delta; + temp_decorr_pass.value = wpds->terms[j]; + + if (temp_decorr_pass.value < 0 && !(s->flags & WV_CROSS_DECORR)) + temp_decorr_pass.value = -3; + + decorr_stereo(s->temp_buffer[ j&1][0], s->temp_buffer[ j&1][1], + s->temp_buffer[~j&1][0], s->temp_buffer[~j&1][1], + FFMIN(2048, nb_samples), &temp_decorr_pass, -1); + + if (j) { + CLEAR(temp_decorr_pass.samplesA); + CLEAR(temp_decorr_pass.samplesB); + } else { + reverse_decorr(&temp_decorr_pass); + } + + memcpy(save_decorr_passes + j, &temp_decorr_pass, sizeof(struct Decorr)); + + if (((s->flags & MAG_MASK) >> MAG_LSB) >= 16) + decorr_stereo(s->temp_buffer[ j&1][0], s->temp_buffer[ j&1][1], + s->temp_buffer[~j&1][0], s->temp_buffer[~j&1][1], + nb_samples, &temp_decorr_pass, 1); + else + decorr_stereo_quick(s->temp_buffer[ j&1][0], s->temp_buffer[ j&1][1], + s->temp_buffer[~j&1][0], s->temp_buffer[~j&1][1], + nb_samples, &temp_decorr_pass); + } + + size = log2stereo(s->temp_buffer[j&1][0], s->temp_buffer[j&1][1], + nb_samples, log_limit); + if (size != UINT32_MAX || !nterms) + break; + nterms >>= 1; + } + + if (size < best_size) { + memcpy(s->best_buffer[0], s->temp_buffer[j&1][0], buf_size); + memcpy(s->best_buffer[1], s->temp_buffer[j&1][1], buf_size); + memcpy(s->decorr_passes, save_decorr_passes, sizeof(struct Decorr) * MAX_TERMS); + s->num_terms = nterms; + s->best_decorr = c; + best_size = size; + } + + if (pi++) + s->mask_decorr = s->mask_decorr ? ((s->mask_decorr << 1) & (s->num_decorrs - 1)) : 1; + } + + if (force_js || (s->decorr_specs[s->best_decorr].joint_stereo && !force_ts)) + s->flags |= WV_JOINT_STEREO; + else + s->flags &= ~((uint32_t) WV_JOINT_STEREO); + + if (s->extra_flags) { + if (s->flags & WV_JOINT_STEREO) { + analyze_stereo(s, s->js_left, s->js_right, do_samples); + + if (do_samples) { + memcpy(samples_l, s->js_left, buf_size); + memcpy(samples_r, s->js_right, buf_size); + } + } else + analyze_stereo(s, samples_l, samples_r, do_samples); + } else if (do_samples) { + memcpy(samples_l, s->best_buffer[0], buf_size); + memcpy(samples_r, s->best_buffer[1], buf_size); + } + + if (s->extra_flags || no_history || + s->joint_stereo != s->decorr_specs[s->best_decorr].joint_stereo) { + s->joint_stereo = s->decorr_specs[s->best_decorr].joint_stereo; + CLEAR(s->w); + scan_word(s, &s->w.c[0], s->best_buffer[0], nb_samples, -1); + scan_word(s, &s->w.c[1], s->best_buffer[1], nb_samples, -1); + } + return 0; +} + +#define count_bits(av) ( \ + (av) < (1 << 8) ? nbits_table[av] : \ + ( \ + (av) < (1L << 16) ? nbits_table[(av) >> 8] + 8 : \ + ((av) < (1L << 24) ? nbits_table[(av) >> 16] + 16 : nbits_table[(av) >> 24] + 24) \ + ) \ +) + +static void encode_flush(WavPackEncodeContext *s) +{ + WavPackWords *w = &s->w; + PutBitContext *pb = &s->pb; + + if (w->zeros_acc) { + int cbits = count_bits(w->zeros_acc); + + do { + if (cbits > 31) { + put_bits(pb, 31, 0x7FFFFFFF); + cbits -= 31; + } else { + put_bits(pb, cbits, (1 << cbits) - 1); + cbits = 0; + } + } while (cbits); + + put_bits(pb, 1, 0); + + while (w->zeros_acc > 1) { + put_bits(pb, 1, w->zeros_acc & 1); + w->zeros_acc >>= 1; + } + + w->zeros_acc = 0; + } + + if (w->holding_one) { + if (w->holding_one >= 16) { + int cbits; + + put_bits(pb, 16, (1 << 16) - 1); + put_bits(pb, 1, 0); + w->holding_one -= 16; + cbits = count_bits(w->holding_one); + + do { + if (cbits > 31) { + put_bits(pb, 31, 0x7FFFFFFF); + cbits -= 31; + } else { + put_bits(pb, cbits, (1 << cbits) - 1); + cbits = 0; + } + } while (cbits); + + put_bits(pb, 1, 0); + + while (w->holding_one > 1) { + put_bits(pb, 1, w->holding_one & 1); + w->holding_one >>= 1; + } + + w->holding_zero = 0; + } else { + put_bits(pb, w->holding_one, (1 << w->holding_one) - 1); + } + + w->holding_one = 0; + } + + if (w->holding_zero) { + put_bits(pb, 1, 0); + w->holding_zero = 0; + } + + if (w->pend_count) { + put_bits(pb, w->pend_count, w->pend_data); + w->pend_data = w->pend_count = 0; + } +} + +static void wavpack_encode_sample(WavPackEncodeContext *s, WvChannel *c, int32_t sample) +{ + WavPackWords *w = &s->w; + uint32_t ones_count, low, high; + int sign = ((sample) < 0) ? 1 : 0; + + if (s->w.c[0].median[0] < 2 && !s->w.holding_zero && s->w.c[1].median[0] < 2) { + if (w->zeros_acc) { + if (sample) + encode_flush(s); + else { + w->zeros_acc++; + return; + } + } else if (sample) { + put_bits(&s->pb, 1, 0); + } else { + CLEAR(s->w.c[0].median); + CLEAR(s->w.c[1].median); + w->zeros_acc = 1; + return; + } + } + + if (sign) + sample = ~sample; + + if (sample < (int32_t) GET_MED(0)) { + ones_count = low = 0; + high = GET_MED(0) - 1; + DEC_MED(0); + } else { + low = GET_MED(0); + INC_MED(0); + + if (sample - low < GET_MED(1)) { + ones_count = 1; + high = low + GET_MED(1) - 1; + DEC_MED(1); + } else { + low += GET_MED(1); + INC_MED(1); + + if (sample - low < GET_MED(2)) { + ones_count = 2; + high = low + GET_MED(2) - 1; + DEC_MED(2); + } else { + ones_count = 2 + (sample - low) / GET_MED(2); + low += (ones_count - 2) * GET_MED(2); + high = low + GET_MED(2) - 1; + INC_MED(2); + } + } + } + + if (w->holding_zero) { + if (ones_count) + w->holding_one++; + + encode_flush(s); + + if (ones_count) { + w->holding_zero = 1; + ones_count--; + } else + w->holding_zero = 0; + } else + w->holding_zero = 1; + + w->holding_one = ones_count * 2; + + if (high != low) { + uint32_t maxcode = high - low, code = sample - low; + int bitcount = count_bits(maxcode); + uint32_t extras = (1 << bitcount) - maxcode - 1; + + if (code < extras) { + w->pend_data |= code << w->pend_count; + w->pend_count += bitcount - 1; + } else { + w->pend_data |= ((code + extras) >> 1) << w->pend_count; + w->pend_count += bitcount - 1; + w->pend_data |= ((code + extras) & 1) << w->pend_count++; + } + } + + w->pend_data |= ((int32_t) sign << w->pend_count++); + + if (!w->holding_zero) + encode_flush(s); +} + +static void pack_int32(WavPackEncodeContext *s, + int32_t *samples_l, int32_t *samples_r, + int nb_samples) +{ + const int sent_bits = s->int32_sent_bits; + int32_t value, mask = (1 << sent_bits) - 1; + PutBitContext *pb = &s->pb; + int i, pre_shift; + + pre_shift = s->int32_zeros + s->int32_ones + s->int32_dups; + + if (!sent_bits) + return; + + if (s->flags & WV_MONO_DATA) { + for (i = 0; i < nb_samples; i++) { + value = (samples_l[i] >> pre_shift) & mask; + put_bits(pb, sent_bits, value); + } + } else { + for (i = 0; i < nb_samples; i++) { + value = (samples_l[i] >> pre_shift) & mask; + put_bits(pb, sent_bits, value); + value = (samples_r[i] >> pre_shift) & mask; + put_bits(pb, sent_bits, value); + } + } +} + +static void pack_float_sample(WavPackEncodeContext *s, int32_t *sample) +{ + const int max_exp = s->float_max_exp; + PutBitContext *pb = &s->pb; + int32_t value, shift_count; + + if (get_exponent(*sample) == 255) { + if (get_mantissa(*sample)) { + put_bits(pb, 1, 1); + put_bits(pb, 23, get_mantissa(*sample)); + } else { + put_bits(pb, 1, 0); + } + + value = 0x1000000; + shift_count = 0; + } else if (get_exponent(*sample)) { + shift_count = max_exp - get_exponent(*sample); + value = 0x800000 + get_mantissa(*sample); + } else { + shift_count = max_exp ? max_exp - 1 : 0; + value = get_mantissa(*sample); + } + + if (shift_count < 25) + value >>= shift_count; + else + value = 0; + + if (!value) { + if (s->float_flags & FLOAT_ZEROS_SENT) { + if (get_exponent(*sample) || get_mantissa(*sample)) { + put_bits(pb, 1, 1); + put_bits(pb, 23, get_mantissa(*sample)); + + if (max_exp >= 25) + put_bits(pb, 8, get_exponent(*sample)); + + put_bits(pb, 1, get_sign(*sample)); + } else { + put_bits(pb, 1, 0); + + if (s->float_flags & FLOAT_NEG_ZEROS) + put_bits(pb, 1, get_sign(*sample)); + } + } + } else if (shift_count) { + if (s->float_flags & FLOAT_SHIFT_SENT) { + int32_t data = get_mantissa(*sample) & ((1 << shift_count) - 1); + put_bits(pb, shift_count, data); + } else if (s->float_flags & FLOAT_SHIFT_SAME) { + put_bits(pb, 1, get_mantissa(*sample) & 1); + } + } +} + +static void pack_float(WavPackEncodeContext *s, + int32_t *samples_l, int32_t *samples_r, + int nb_samples) +{ + int i; + + if (s->flags & WV_MONO_DATA) { + for (i = 0; i < nb_samples; i++) + pack_float_sample(s, &samples_l[i]); + } else { + for (i = 0; i < nb_samples; i++) { + pack_float_sample(s, &samples_l[i]); + pack_float_sample(s, &samples_r[i]); + } + } +} + +static void decorr_stereo_pass2(struct Decorr *dpp, + int32_t *samples_l, int32_t *samples_r, + int nb_samples) +{ + int i, m, k; + + switch (dpp->value) { + case 17: + for (i = 0; i < nb_samples; i++) { + int32_t sam, tmp; + + sam = 2 * dpp->samplesA[0] - dpp->samplesA[1]; + dpp->samplesA[1] = dpp->samplesA[0]; + samples_l[i] = tmp = (dpp->samplesA[0] = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam); + UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); + + sam = 2 * dpp->samplesB[0] - dpp->samplesB[1]; + dpp->samplesB[1] = dpp->samplesB[0]; + samples_r[i] = tmp = (dpp->samplesB[0] = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam); + UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); + } + break; + case 18: + for (i = 0; i < nb_samples; i++) { + int32_t sam, tmp; + + sam = dpp->samplesA[0] + ((dpp->samplesA[0] - dpp->samplesA[1]) >> 1); + dpp->samplesA[1] = dpp->samplesA[0]; + samples_l[i] = tmp = (dpp->samplesA[0] = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam); + UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); + + sam = dpp->samplesB[0] + ((dpp->samplesB[0] - dpp->samplesB[1]) >> 1); + dpp->samplesB[1] = dpp->samplesB[0]; + samples_r[i] = tmp = (dpp->samplesB[0] = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam); + UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); + } + break; + default: + for (m = 0, k = dpp->value & (MAX_TERM - 1), i = 0; i < nb_samples; i++) { + int32_t sam, tmp; + + sam = dpp->samplesA[m]; + samples_l[i] = tmp = (dpp->samplesA[k] = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam); + UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, tmp); + + sam = dpp->samplesB[m]; + samples_r[i] = tmp = (dpp->samplesB[k] = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam); + UPDATE_WEIGHT(dpp->weightB, dpp->delta, sam, tmp); + + m = (m + 1) & (MAX_TERM - 1); + k = (k + 1) & (MAX_TERM - 1); + } + if (m) { + int32_t temp_A[MAX_TERM], temp_B[MAX_TERM]; + + memcpy(temp_A, dpp->samplesA, sizeof (dpp->samplesA)); + memcpy(temp_B, dpp->samplesB, sizeof (dpp->samplesB)); + + for (k = 0; k < MAX_TERM; k++) { + dpp->samplesA[k] = temp_A[m]; + dpp->samplesB[k] = temp_B[m]; + m = (m + 1) & (MAX_TERM - 1); + } + } + break; + case -1: + for (i = 0; i < nb_samples; i++) { + int32_t sam_A, sam_B, tmp; + + sam_A = dpp->samplesA[0]; + samples_l[i] = tmp = (sam_B = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam_A); + UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); + + samples_r[i] = tmp = (dpp->samplesA[0] = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam_B); + UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); + } + break; + case -2: + for (i = 0; i < nb_samples; i++) { + int32_t sam_A, sam_B, tmp; + + sam_B = dpp->samplesB[0]; + samples_r[i] = tmp = (sam_A = samples_r[i]) - APPLY_WEIGHT(dpp->weightB, sam_B); + UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); + + samples_l[i] = tmp = (dpp->samplesB[0] = samples_l[i]) - APPLY_WEIGHT(dpp->weightA, sam_A); + UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); + } + break; + case -3: + for (i = 0; i < nb_samples; i++) { + int32_t sam_A, sam_B, tmp; + + sam_A = dpp->samplesA[0]; + sam_B = dpp->samplesB[0]; + + dpp->samplesA[0] = tmp = samples_r[i]; + samples_r[i] = tmp -= APPLY_WEIGHT(dpp->weightB, sam_B); + UPDATE_WEIGHT_CLIP(dpp->weightB, dpp->delta, sam_B, tmp); + + dpp->samplesB[0] = tmp = samples_l[i]; + samples_l[i] = tmp -= APPLY_WEIGHT(dpp->weightA, sam_A); + UPDATE_WEIGHT_CLIP(dpp->weightA, dpp->delta, sam_A, tmp); + } + break; + } +} + +#define update_weight_d2(weight, delta, source, result) \ + if (source && result) \ + weight -= (((source ^ result) >> 29) & 4) - 2; + +#define update_weight_clip_d2(weight, delta, source, result) \ + if (source && result) { \ + const int32_t s = (source ^ result) >> 31; \ + if ((weight = (weight ^ s) + (2 - s)) > 1024) weight = 1024; \ + weight = (weight ^ s) - s; \ + } + +static void decorr_stereo_pass_id2(struct Decorr *dpp, + int32_t *samples_l, int32_t *samples_r, + int nb_samples) +{ + int i, m, k; + + switch (dpp->value) { + case 17: + for (i = 0; i < nb_samples; i++) { + int32_t sam, tmp; + + sam = 2 * dpp->samplesA[0] - dpp->samplesA[1]; + dpp->samplesA[1] = dpp->samplesA[0]; + samples_l[i] = tmp = (dpp->samplesA[0] = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam); + update_weight_d2(dpp->weightA, dpp->delta, sam, tmp); + + sam = 2 * dpp->samplesB[0] - dpp->samplesB[1]; + dpp->samplesB[1] = dpp->samplesB[0]; + samples_r[i] = tmp = (dpp->samplesB[0] = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam); + update_weight_d2(dpp->weightB, dpp->delta, sam, tmp); + } + break; + case 18: + for (i = 0; i < nb_samples; i++) { + int32_t sam, tmp; + + sam = dpp->samplesA[0] + ((dpp->samplesA[0] - dpp->samplesA[1]) >> 1); + dpp->samplesA[1] = dpp->samplesA[0]; + samples_l[i] = tmp = (dpp->samplesA[0] = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam); + update_weight_d2(dpp->weightA, dpp->delta, sam, tmp); + + sam = dpp->samplesB[0] + ((dpp->samplesB[0] - dpp->samplesB[1]) >> 1); + dpp->samplesB[1] = dpp->samplesB[0]; + samples_r[i] = tmp = (dpp->samplesB[0] = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam); + update_weight_d2(dpp->weightB, dpp->delta, sam, tmp); + } + break; + default: + for (m = 0, k = dpp->value & (MAX_TERM - 1), i = 0; i < nb_samples; i++) { + int32_t sam, tmp; + + sam = dpp->samplesA[m]; + samples_l[i] = tmp = (dpp->samplesA[k] = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam); + update_weight_d2(dpp->weightA, dpp->delta, sam, tmp); + + sam = dpp->samplesB[m]; + samples_r[i] = tmp = (dpp->samplesB[k] = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam); + update_weight_d2(dpp->weightB, dpp->delta, sam, tmp); + + m = (m + 1) & (MAX_TERM - 1); + k = (k + 1) & (MAX_TERM - 1); + } + + if (m) { + int32_t temp_A[MAX_TERM], temp_B[MAX_TERM]; + + memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA)); + memcpy(temp_B, dpp->samplesB, sizeof(dpp->samplesB)); + + for (k = 0; k < MAX_TERM; k++) { + dpp->samplesA[k] = temp_A[m]; + dpp->samplesB[k] = temp_B[m]; + m = (m + 1) & (MAX_TERM - 1); + } + } + break; + case -1: + for (i = 0; i < nb_samples; i++) { + int32_t sam_A, sam_B, tmp; + + sam_A = dpp->samplesA[0]; + samples_l[i] = tmp = (sam_B = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam_A); + update_weight_clip_d2(dpp->weightA, dpp->delta, sam_A, tmp); + + samples_r[i] = tmp = (dpp->samplesA[0] = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam_B); + update_weight_clip_d2(dpp->weightB, dpp->delta, sam_B, tmp); + } + break; + case -2: + for (i = 0; i < nb_samples; i++) { + int32_t sam_A, sam_B, tmp; + + sam_B = dpp->samplesB[0]; + samples_r[i] = tmp = (sam_A = samples_r[i]) - APPLY_WEIGHT_I(dpp->weightB, sam_B); + update_weight_clip_d2(dpp->weightB, dpp->delta, sam_B, tmp); + + samples_l[i] = tmp = (dpp->samplesB[0] = samples_l[i]) - APPLY_WEIGHT_I(dpp->weightA, sam_A); + update_weight_clip_d2(dpp->weightA, dpp->delta, sam_A, tmp); + } + break; + case -3: + for (i = 0; i < nb_samples; i++) { + int32_t sam_A, sam_B, tmp; + + sam_A = dpp->samplesA[0]; + sam_B = dpp->samplesB[0]; + + dpp->samplesA[0] = tmp = samples_r[i]; + samples_r[i] = tmp -= APPLY_WEIGHT_I(dpp->weightB, sam_B); + update_weight_clip_d2(dpp->weightB, dpp->delta, sam_B, tmp); + + dpp->samplesB[0] = tmp = samples_l[i]; + samples_l[i] = tmp -= APPLY_WEIGHT_I(dpp->weightA, sam_A); + update_weight_clip_d2(dpp->weightA, dpp->delta, sam_A, tmp); + } + break; + } +} + +static void put_metadata_block(PutByteContext *pb, int flags, int size) +{ + if (size & 1) + flags |= WP_IDF_ODD; + + bytestream2_put_byte(pb, flags); + bytestream2_put_byte(pb, (size + 1) >> 1); +} + +static int wavpack_encode_block(WavPackEncodeContext *s, + int32_t *samples_l, int32_t *samples_r, + uint8_t *out, int out_size) +{ + int block_size, start, end, data_size, tcount, temp, m = 0; + int i, j, ret, got_extra = 0, nb_samples = s->block_samples; + uint32_t crc = 0xffffffffu; + struct Decorr *dpp; + PutByteContext pb; + + if (!(s->flags & WV_MONO) && s->optimize_mono) { + int32_t lor = 0, diff = 0; + + for (i = 0; i < nb_samples; i++) { + lor |= samples_l[i] | samples_r[i]; + diff |= samples_l[i] - samples_r[i]; + + if (lor && diff) + break; + } + + if (i == nb_samples && lor && !diff) { + s->flags &= ~(WV_JOINT_STEREO | WV_CROSS_DECORR); + s->flags |= WV_FALSE_STEREO; + + if (!s->false_stereo) { + s->false_stereo = 1; + s->num_terms = 0; + CLEAR(s->w); + } + } else if (s->false_stereo) { + s->false_stereo = 0; + s->num_terms = 0; + CLEAR(s->w); + } + } + + if (s->flags & SHIFT_MASK) { + int shift = (s->flags & SHIFT_MASK) >> SHIFT_LSB; + int mag = (s->flags & MAG_MASK) >> MAG_LSB; + + if (s->flags & WV_MONO_DATA) + shift_mono(samples_l, nb_samples, shift); + else + shift_stereo(samples_l, samples_r, nb_samples, shift); + + if ((mag -= shift) < 0) + s->flags &= ~MAG_MASK; + else + s->flags -= (1 << MAG_LSB) * shift; + } + + if ((s->flags & WV_FLOAT_DATA) || (s->flags & MAG_MASK) >> MAG_LSB >= 24) { + av_fast_padded_malloc(&s->orig_l, &s->orig_l_size, sizeof(int32_t) * nb_samples); + av_fast_padded_malloc(&s->orig_r, &s->orig_r_size, sizeof(int32_t) * nb_samples); + memcpy(s->orig_l, samples_l, sizeof(int32_t) * nb_samples); + memcpy(s->orig_r, samples_r, sizeof(int32_t) * nb_samples); + + if (s->flags & WV_FLOAT_DATA) + got_extra = scan_float(s, samples_l, samples_r, nb_samples); + else + got_extra = scan_int32(s, samples_l, samples_r, nb_samples); + s->num_terms = 0; + } else { + scan_int23(s, samples_l, samples_r, nb_samples); + if (s->shift != s->int32_zeros + s->int32_ones + s->int32_dups) { + s->shift = s->int32_zeros + s->int32_ones + s->int32_dups; + s->num_terms = 0; + } + } + + if (!s->num_passes && !s->num_terms) { + s->num_passes = 1; + + if (s->flags & WV_MONO_DATA) + ret = wv_mono(s, samples_l, 1, 0); + else + ret = wv_stereo(s, samples_l, samples_r, 1, 0); + + s->num_passes = 0; + } + if (s->flags & WV_MONO_DATA) { + for (i = 0; i < nb_samples; i++) + crc += (crc << 1) + samples_l[i]; + + if (s->num_passes) + ret = wv_mono(s, samples_l, !s->num_terms, 1); + } else { + for (i = 0; i < nb_samples; i++) + crc += (crc << 3) + (samples_l[i] << 1) + samples_l[i] + samples_r[i]; + + if (s->num_passes) + ret = wv_stereo(s, samples_l, samples_r, !s->num_terms, 1); + } + if (ret < 0) + return ret; + + if (!s->ch_offset) + s->flags |= WV_INITIAL_BLOCK; + + s->ch_offset += 1 + !(s->flags & WV_MONO); + + if (s->ch_offset == s->avctx->channels) + s->flags |= WV_FINAL_BLOCK; + + bytestream2_init_writer(&pb, out, out_size); + bytestream2_put_le32(&pb, MKTAG('w', 'v', 'p', 'k')); + bytestream2_put_le32(&pb, 0); + bytestream2_put_le16(&pb, 0x410); + bytestream2_put_le16(&pb, 0); + bytestream2_put_le32(&pb, 0); + bytestream2_put_le32(&pb, s->sample_index); + bytestream2_put_le32(&pb, nb_samples); + bytestream2_put_le32(&pb, s->flags); + bytestream2_put_le32(&pb, crc); + + if (s->flags & WV_INITIAL_BLOCK && + s->avctx->channel_layout != AV_CH_LAYOUT_MONO && + s->avctx->channel_layout != AV_CH_LAYOUT_STEREO) { + put_metadata_block(&pb, WP_ID_CHANINFO, 5); + bytestream2_put_byte(&pb, s->avctx->channels); + bytestream2_put_le32(&pb, s->avctx->channel_layout); + bytestream2_put_byte(&pb, 0); + } + + if ((s->flags & SRATE_MASK) == SRATE_MASK) { + put_metadata_block(&pb, WP_ID_SAMPLE_RATE, 3); + bytestream2_put_le24(&pb, s->avctx->sample_rate); + bytestream2_put_byte(&pb, 0); + } + + put_metadata_block(&pb, WP_ID_DECTERMS, s->num_terms); + for (i = 0; i < s->num_terms; i++) { + struct Decorr *dpp = &s->decorr_passes[i]; + bytestream2_put_byte(&pb, ((dpp->value + 5) & 0x1f) | ((dpp->delta << 5) & 0xe0)); + } + if (s->num_terms & 1) + bytestream2_put_byte(&pb, 0); + +#define WRITE_DECWEIGHT(type) do { \ + temp = store_weight(type); \ + bytestream2_put_byte(&pb, temp); \ + type = restore_weight(temp); \ + } while (0) + + bytestream2_put_byte(&pb, WP_ID_DECWEIGHTS); + bytestream2_put_byte(&pb, 0); + start = bytestream2_tell_p(&pb); + for (i = s->num_terms - 1; i >= 0; --i) { + struct Decorr *dpp = &s->decorr_passes[i]; + + if (store_weight(dpp->weightA) || + (!(s->flags & WV_MONO_DATA) && store_weight(dpp->weightB))) + break; + } + tcount = i + 1; + for (i = 0; i < s->num_terms; i++) { + struct Decorr *dpp = &s->decorr_passes[i]; + if (i < tcount) { + WRITE_DECWEIGHT(dpp->weightA); + if (!(s->flags & WV_MONO_DATA)) + WRITE_DECWEIGHT(dpp->weightB); + } else { + dpp->weightA = dpp->weightB = 0; + } + } + end = bytestream2_tell_p(&pb); + out[start - 2] = WP_ID_DECWEIGHTS | (((end - start) & 1) ? WP_IDF_ODD: 0); + out[start - 1] = (end - start + 1) >> 1; + if ((end - start) & 1) + bytestream2_put_byte(&pb, 0); + +#define WRITE_DECSAMPLE(type) do { \ + temp = log2s(type); \ + type = wp_exp2(temp); \ + bytestream2_put_le16(&pb, temp); \ + } while (0) + + bytestream2_put_byte(&pb, WP_ID_DECSAMPLES); + bytestream2_put_byte(&pb, 0); + start = bytestream2_tell_p(&pb); + for (i = 0; i < s->num_terms; i++) { + struct Decorr *dpp = &s->decorr_passes[i]; + if (i == 0) { + if (dpp->value > MAX_TERM) { + WRITE_DECSAMPLE(dpp->samplesA[0]); + WRITE_DECSAMPLE(dpp->samplesA[1]); + if (!(s->flags & WV_MONO_DATA)) { + WRITE_DECSAMPLE(dpp->samplesB[0]); + WRITE_DECSAMPLE(dpp->samplesB[1]); + } + } else if (dpp->value < 0) { + WRITE_DECSAMPLE(dpp->samplesA[0]); + WRITE_DECSAMPLE(dpp->samplesB[0]); + } else { + for (j = 0; j < dpp->value; j++) { + WRITE_DECSAMPLE(dpp->samplesA[j]); + if (!(s->flags & WV_MONO_DATA)) + WRITE_DECSAMPLE(dpp->samplesB[j]); + } + } + } else { + CLEAR(dpp->samplesA); + CLEAR(dpp->samplesB); + } + } + end = bytestream2_tell_p(&pb); + out[start - 1] = (end - start) >> 1; + +#define WRITE_CHAN_ENTROPY(chan) do { \ + for (i = 0; i < 3; i++) { \ + temp = wp_log2(s->w.c[chan].median[i]); \ + bytestream2_put_le16(&pb, temp); \ + s->w.c[chan].median[i] = wp_exp2(temp); \ + } \ + } while (0) + + put_metadata_block(&pb, WP_ID_ENTROPY, 6 * (1 + (!(s->flags & WV_MONO_DATA)))); + WRITE_CHAN_ENTROPY(0); + if (!(s->flags & WV_MONO_DATA)) + WRITE_CHAN_ENTROPY(1); + + if (s->flags & WV_FLOAT_DATA) { + put_metadata_block(&pb, WP_ID_FLOATINFO, 4); + bytestream2_put_byte(&pb, s->float_flags); + bytestream2_put_byte(&pb, s->float_shift); + bytestream2_put_byte(&pb, s->float_max_exp); + bytestream2_put_byte(&pb, 127); + } + + if (s->flags & WV_INT32_DATA) { + put_metadata_block(&pb, WP_ID_INT32INFO, 4); + bytestream2_put_byte(&pb, s->int32_sent_bits); + bytestream2_put_byte(&pb, s->int32_zeros); + bytestream2_put_byte(&pb, s->int32_ones); + bytestream2_put_byte(&pb, s->int32_dups); + } + + if (s->flags & WV_MONO_DATA && !s->num_passes) { + for (i = 0; i < nb_samples; i++) { + int32_t code = samples_l[i]; + + for (tcount = s->num_terms, dpp = s->decorr_passes; tcount--; dpp++) { + int32_t sam; + + if (dpp->value > MAX_TERM) { + if (dpp->value & 1) + sam = 2 * dpp->samplesA[0] - dpp->samplesA[1]; + else + sam = (3 * dpp->samplesA[0] - dpp->samplesA[1]) >> 1; + + dpp->samplesA[1] = dpp->samplesA[0]; + dpp->samplesA[0] = code; + } else { + sam = dpp->samplesA[m]; + dpp->samplesA[(m + dpp->value) & (MAX_TERM - 1)] = code; + } + + code -= APPLY_WEIGHT(dpp->weightA, sam); + UPDATE_WEIGHT(dpp->weightA, dpp->delta, sam, code); + } + + m = (m + 1) & (MAX_TERM - 1); + samples_l[i] = code; + } + if (m) { + for (tcount = s->num_terms, dpp = s->decorr_passes; tcount--; dpp++) + if (dpp->value > 0 && dpp->value <= MAX_TERM) { + int32_t temp_A[MAX_TERM], temp_B[MAX_TERM]; + int k; + + memcpy(temp_A, dpp->samplesA, sizeof(dpp->samplesA)); + memcpy(temp_B, dpp->samplesB, sizeof(dpp->samplesB)); + + for (k = 0; k < MAX_TERM; k++) { + dpp->samplesA[k] = temp_A[m]; + dpp->samplesB[k] = temp_B[m]; + m = (m + 1) & (MAX_TERM - 1); + } + } + } + } else if (!s->num_passes) { + if (s->flags & WV_JOINT_STEREO) { + for (i = 0; i < nb_samples; i++) + samples_r[i] += ((samples_l[i] -= samples_r[i]) >> 1); + } + + for (i = 0; i < s->num_terms; i++) { + struct Decorr *dpp = &s->decorr_passes[i]; + if (((s->flags & MAG_MASK) >> MAG_LSB) >= 16 || dpp->delta != 2) + decorr_stereo_pass2(dpp, samples_l, samples_r, nb_samples); + else + decorr_stereo_pass_id2(dpp, samples_l, samples_r, nb_samples); + } + } + + bytestream2_put_byte(&pb, WP_ID_DATA | WP_IDF_LONG); + init_put_bits(&s->pb, pb.buffer + 3, bytestream2_get_bytes_left_p(&pb)); + if (s->flags & WV_MONO_DATA) { + for (i = 0; i < nb_samples; i++) + wavpack_encode_sample(s, &s->w.c[0], s->samples[0][i]); + } else { + for (i = 0; i < nb_samples; i++) { + wavpack_encode_sample(s, &s->w.c[0], s->samples[0][i]); + wavpack_encode_sample(s, &s->w.c[1], s->samples[1][i]); + } + } + encode_flush(s); + flush_put_bits(&s->pb); + data_size = put_bits_count(&s->pb) >> 3; + bytestream2_put_le24(&pb, (data_size + 1) >> 1); + bytestream2_skip_p(&pb, data_size); + if (data_size & 1) + bytestream2_put_byte(&pb, 0); + + if (got_extra) { + bytestream2_put_byte(&pb, WP_ID_EXTRABITS | WP_IDF_LONG); + init_put_bits(&s->pb, pb.buffer + 7, bytestream2_get_bytes_left_p(&pb)); + if (s->flags & WV_FLOAT_DATA) + pack_float(s, s->orig_l, s->orig_r, nb_samples); + else + pack_int32(s, s->orig_l, s->orig_r, nb_samples); + flush_put_bits(&s->pb); + data_size = put_bits_count(&s->pb) >> 3; + bytestream2_put_le24(&pb, (data_size + 5) >> 1); + bytestream2_put_le32(&pb, s->crc_x); + bytestream2_skip_p(&pb, data_size); + if (data_size & 1) + bytestream2_put_byte(&pb, 0); + } + + block_size = bytestream2_tell_p(&pb); + AV_WL32(out + 4, block_size - 8); + + return block_size; +} + +static void fill_buffer(WavPackEncodeContext *s, + const int8_t *src, int32_t *dst, + int nb_samples) +{ + int i; + +#define COPY_SAMPLES(type, offset, shift) do { \ + const type *sptr = (const type *)src; \ + for (i = 0; i < nb_samples; i++) \ + dst[i] = (sptr[i] - offset) >> shift; \ + } while (0) + + switch (s->avctx->sample_fmt) { + case AV_SAMPLE_FMT_U8P: + COPY_SAMPLES(int8_t, 0x80, 0); + break; + case AV_SAMPLE_FMT_S16P: + COPY_SAMPLES(int16_t, 0, 0); + break; + case AV_SAMPLE_FMT_S32P: + if (s->avctx->bits_per_raw_sample <= 24) { + COPY_SAMPLES(int32_t, 0, 8); + break; + } + case AV_SAMPLE_FMT_FLTP: + memcpy(dst, src, nb_samples * 4); + } +} + +static void set_samplerate(WavPackEncodeContext *s) +{ + int i; + + for (i = 0; i < 15; i++) { + if (wv_rates[i] == s->avctx->sample_rate) + break; + } + + s->flags = i << SRATE_LSB; +} + +static int wavpack_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, + const AVFrame *frame, int *got_packet_ptr) +{ + WavPackEncodeContext *s = avctx->priv_data; + int buf_size, ret; + uint8_t *buf; + + s->block_samples = frame->nb_samples; + av_fast_padded_malloc(&s->samples[0], &s->samples_size[0], + sizeof(int32_t) * s->block_samples); + if (!s->samples[0]) + return AVERROR(ENOMEM); + if (avctx->channels > 1) { + av_fast_padded_malloc(&s->samples[1], &s->samples_size[1], + sizeof(int32_t) * s->block_samples); + if (!s->samples[1]) + return AVERROR(ENOMEM); + } + + if ((ret = ff_alloc_packet2(avctx, avpkt, s->block_samples * avctx->channels * 8)) < 0) + return ret; + buf = avpkt->data; + buf_size = avpkt->size; + + for (s->ch_offset = 0; s->ch_offset < avctx->channels;) { + set_samplerate(s); + + switch (s->avctx->sample_fmt) { + case AV_SAMPLE_FMT_S16P: s->flags |= 1; break; + case AV_SAMPLE_FMT_S32P: s->flags |= 3 - (s->avctx->bits_per_raw_sample <= 24); break; + case AV_SAMPLE_FMT_FLTP: s->flags |= 3 | WV_FLOAT_DATA; + } + + fill_buffer(s, frame->extended_data[s->ch_offset], s->samples[0], s->block_samples); + if (avctx->channels - s->ch_offset == 1) { + s->flags |= WV_MONO; + } else { + s->flags |= WV_CROSS_DECORR; + fill_buffer(s, frame->extended_data[s->ch_offset + 1], s->samples[1], s->block_samples); + } + + s->flags += (1 << MAG_LSB) * ((s->flags & 3) * 8 + 7); + + if ((ret = wavpack_encode_block(s, s->samples[0], s->samples[1], + buf, buf_size)) < 0) + return ret; + + buf += ret; + buf_size -= ret; + } + s->sample_index += frame->nb_samples; + + avpkt->pts = frame->pts; + avpkt->size = buf - avpkt->data; + avpkt->duration = ff_samples_to_time_base(avctx, frame->nb_samples); + *got_packet_ptr = 1; + return 0; +} + +static av_cold int wavpack_encode_close(AVCodecContext *avctx) +{ + WavPackEncodeContext *s = avctx->priv_data; + int i; + + for (i = 0; i < MAX_TERMS + 2; i++) { + av_freep(&s->sampleptrs[i][0]); + av_freep(&s->sampleptrs[i][1]); + s->sampleptrs_size[i][0] = s->sampleptrs_size[i][1] = 0; + } + + for (i = 0; i < 2; i++) { + av_freep(&s->samples[i]); + s->samples_size[i] = 0; + + av_freep(&s->best_buffer[i]); + s->best_buffer_size[i] = 0; + + av_freep(&s->temp_buffer[i][0]); + av_freep(&s->temp_buffer[i][1]); + s->temp_buffer_size[i][0] = s->temp_buffer_size[i][1] = 0; + } + + av_freep(&s->js_left); + av_freep(&s->js_right); + s->js_left_size = s->js_right_size = 0; + + av_freep(&s->orig_l); + av_freep(&s->orig_r); + s->orig_l_size = s->orig_r_size = 0; + + return 0; +} + +#define OFFSET(x) offsetof(WavPackEncodeContext, x) +#define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM +static const AVOption options[] = { + { "joint_stereo", "", OFFSET(joint), AV_OPT_TYPE_INT, {.i64=0},-1, 1, FLAGS, "joint" }, + { "on", "mid/side", 0, AV_OPT_TYPE_CONST, {.i64= 1}, 0, 0, FLAGS, "joint"}, + { "off", "left/right", 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, FLAGS, "joint"}, + { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64= 0}, 0, 0, FLAGS, "joint"}, + { "optimize_mono", "", OFFSET(optimize_mono), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "opt_mono" }, + { "on", NULL, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "opt_mono"}, + { "off", NULL, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "opt_mono"}, + { NULL }, +}; + +static const AVClass wavpack_encoder_class = { + .class_name = "WavPack encoder", + .item_name = av_default_item_name, + .option = options, + .version = LIBAVUTIL_VERSION_INT, +}; + +AVCodec ff_wavpack_encoder = { + .name = "wavpack", + .long_name = NULL_IF_CONFIG_SMALL("WavPack"), + .type = AVMEDIA_TYPE_AUDIO, + .id = AV_CODEC_ID_WAVPACK, + .priv_data_size = sizeof(WavPackEncodeContext), + .priv_class = &wavpack_encoder_class, + .init = wavpack_encode_init, + .encode2 = wavpack_encode_frame, + .close = wavpack_encode_close, + .capabilities = CODEC_CAP_SMALL_LAST_FRAME, + .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_U8P, + AV_SAMPLE_FMT_S16P, + AV_SAMPLE_FMT_S32P, + AV_SAMPLE_FMT_FLTP, + AV_SAMPLE_FMT_NONE }, +}; diff --git a/libavcodec/wavpackenc.h b/libavcodec/wavpackenc.h new file mode 100644 index 0000000000..1582d683e2 --- /dev/null +++ b/libavcodec/wavpackenc.h @@ -0,0 +1,664 @@ +/* + * WavPack lossless audio encoder + * + * This file is part of FFmpeg. + * + * FFmpeg is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * FFmpeg is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef AVCODEC_WAVPACKENC_H +#define AVCODEC_WAVPACKENC_H + +#include "wavpack.h" + +typedef struct WavPackDecorrSpec { + int8_t joint_stereo, delta, terms[MAX_TERMS+1]; +} WavPackDecorrSpec; + +static const WavPackDecorrSpec fast_specs[] = { + { 1, 2, { 18,17 } }, { 1, 1, { 17,17 } }, { 0, 2, { 18,17 } }, + { 0, 1, { 17,17 } }, { 1, 3, { 1,18 } }, { 1, 1, { 17, 1 } }, + { 0, 1, { 1,17 } }, { 0, 1, { -2,17 } }, { 0, 2, { -1,17 } }, + { 1, 1, { 17, 2 } }, { 0, 3, { 18,18 } }, { 0, 1, { 17, 1 } }, + { 1, 6, { 1, 2 } }, { 1, 1, { 17, 3 } }, { 0, 1, { -2, 3 } }, + { 0, 1, { 2,17 } }, { 0, 1, { 18,-2 } }, { 0, 1, { -1,17 } }, + { 0, 1, { 18,17 } }, { 0, 1, { 17, 2 } }, { 1, 2, { 18,-2 } }, + { 1, 1, { 1,17 } }, { 0, 3, { 18, 2 } }, { 0, 1, { 17,-2 } }, + { 0, 1, { 18,-2 } }, { 1, 2, { 17,-3 } }, { 0, 1, { 18, 3 } }, + { 0, 1, { 18,18 } }, { 1, 1, { 1, 3 } }, { 1, 1, { 18, 3 } }, + { 1, 1, { 1, 3 } }, { 0, 2, { 18,17 } }, { 1, 1, { 1,17 } }, + { 1, 1, { 17, 3 } }, { 0, 3, { 18,17 } }, { 0, 1, { 18,18 } }, + { 1, 1, { 1, 3 } }, { 1, 1, { 1,18 } }, { 0, 1, { 18,-2 } }, + { 0, 2, { 18,17 } }, { 0, 1, { -1,18 } }, { 1, 1, { 17, 3 } }, + { 0, 1, { 17, 2 } }, { 0, 1, { 17, 3 } }, { 1, 1, { 18, 2 } }, + { 1, 1, { 17,-2 } }, { 0, 1, { 1,-2 } }, { 0, 2, { 18,17 } }, + { 0, 1, { 17,-2 } }, { 1, 1, { 17,-2 } }, { 0, 1, { 18, 3 } }, + { 0, 1, { 2,17 } }, { 1, 2, { 18,-3 } }, { 1, 2, { 1,18 } }, + { 1, 2, { 18, 2 } }, { 0, 1, { 17,-1 } }, { 0, 1, { 17,-2 } }, + { 1, 1, { 17,-2 } }, { 1, 1, { 1, 3 } }, { 0, 1, { 1,17 } }, + { 1, 2, { 18,-2 } }, { 1, 2, { 17,-3 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 18,17 } }, { 1, 1, { 17, 2 } }, { 1, 2, { 18,18 } }, + { 0, 1, { 17, 2 } }, { 0, 1, { 18,17 } }, { 1, 1, { 1,17 } }, + { 1, 1, { 17, 2 } }, { 0, 2, { 18,18 } }, { 0, 2, { 18,17 } }, + { 1, 2, { 17,-3 } }, { 1, 6, { 1, 2 } }, { 0, 3, { 17,17 } }, + { 0, 1, { 1,18 } }, { 0, 1, { 1,-2 } }, { 1, 1, { 17, 2 } }, + { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, { 1, 1, { 18, 3 } }, + { 1, 2, { 17,-3 } }, { 0, 1, { 17, 2 } }, { 0, 1, { 17, 3 } }, + { 0, 1, { 18,-2 } }, { 1, 1, { 18,18 } }, { 1, 6, { 1, 2 } }, + { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, { 0, 1, { -1,17 } }, + { 1, 1, { 18, 3 } }, { 0, 1, { 17,18 } }, { 1, 1, { 17, 3 } }, + { 0, 1, { 18, 3 } }, { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, + { 1, 2, { 18, 2 } }, { 0, 1, { -2, 3 } }, { 0, 4, { 18,-1 } }, + { 0, 2, { 18,18 } }, { 0, 1, { -2, 3 } }, { 1, 1, { 17,-2 } }, + { 0, 1, { 17, 3 } }, { 0, 2, { 18,17 } }, { 0, 2, { -1,18 } }, + { 1, 1, { 2,17 } }, { 0, 2, { 17,-2 } }, { 0, 1, { 17, 2 } }, + { 1, 2, { 18,-3 } }, { 0, 1, { 17,-2 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 18,17 } }, { 1, 1, { 17,-2 } }, { 1, 2, { 17,-3 } }, + { 1, 1, { 1, 3 } }, { 1, 1, { 2,17 } }, { 1, 2, { 18, 2 } }, + { 1, 1, { 2,17 } }, { 1, 1, { 18, 2 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 18,17 } }, { 0, 1, { 17,-2 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 17,-1 } }, { 0, 2, { 18,-2 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, { 1, 1, { 1, 3 } }, + { 0, 2, { -2,17 } }, { 0, 2, { 18,-2 } }, { 0, 2, { 17,-2 } }, + { 1, 1, { 2,17 } }, { 1, 1, { 1, 3 } }, { 0, 1, { 2,17 } }, + { 0, 2, { 18,17 } }, { 0, 3, { -1,17 } }, { 1, 1, { 2,17 } }, + { 0, 2, { 18,18 } }, { 0, 1, { 17, 2 } }, { 1, 4, { 18,-3 } }, + { 1, 1, { 18, 1 } }, { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, + { 1, 2, { 18,-1 } }, { 0, 1, { -1,18 } }, { 1, 6, { 1, 2 } }, + { 1, 1, { 17, 2 } }, { 1, 4, { 18, 3 } }, { 0, 1, { 1,17 } }, + { 0, 1, { 18, 2 } }, { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, + { 1, 2, { 17, 2 } }, { 0, 2, { 18,-2 } }, { 0, 1, { 1,18 } }, + { 1, 2, { 18,-3 } }, { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 18,17 } }, { 1, 2, { 18,18 } }, { 1, 3, { 17,17 } }, + { 0, 1, { -2,17 } }, { 0, 1, { 17,18 } }, { 0, 1, { -1, 3 } }, + { 1, 1, { 2,17 } }, { 0, 2, { 18,-1 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 18,17 } }, { 1, 1, { 17,-2 } }, { 1, 2, { 17, 2 } }, + { 1, 1, { 18, 3 } }, { 0, 1, { 18, 2 } }, { 1, 2, { 17,-3 } }, + { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, { 0, 1, { -2,17 } }, + { 0, 1, { 17,-1 } }, { 0, 1, { 18,-1 } }, { 0, 2, { 18,17 } }, + { 1, 2, { 17,-3 } }, { 1, 1, { 1,18 } }, { 1, 3, { 18, 2 } }, + { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 18,17 } }, { 0, 3, { 18,18 } }, { 0, 1, { 1,-2 } }, + { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, + { 1, 2, { 17,-3 } }, { 1, 1, { 18,18 } }, { 0, 2, { 18, 2 } }, + { 0, 1, { 17,18 } }, { 1, 2, { 18, 2 } }, { 1, 1, { 17,-2 } }, + { 0, 2, { 17,-1 } }, { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 18,17 } }, { 0, 1, { 1,-2 } }, { 0, 1, { 18, 1 } }, + { 1, 2, { 18,-2 } }, { 0, 1, { 17, 2 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 18,17 } }, { 1, 1, { 17, 3 } }, { 0, 1, { 17,-1 } }, + { 0, 1, { 18, 2 } }, { 1, 1, { 17, 3 } }, { 1, 1, { 17,-2 } }, + { 0, 1, { 18,18 } }, { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, + { 1, 1, { 17,18 } }, { 0, 1, { -2, 3 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, { 1, 2, { 18,-3 } }, + { 0, 2, { 18,17 } }, { 0, 3, { 18, 2 } }, { 0, 1, { 1,18 } }, + { 0, 2, { 18,17 } }, { 0, 1, { 17,-1 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, { 0, 1, { -2, 3 } }, + { 0, 3, { 17,17 } }, { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, + { 1, 1, { 17, 2 } }, { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, + { 1, 1, { 17, 2 } }, { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 18,17 } }, { 0, 2, { 18, 2 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, { 0, 2, { 18,17 } }, + { 0, 2, { 18,17 } }, +}; + +static const WavPackDecorrSpec default_specs[] = { + { 1, 2, { 18,18, 2,17, 3 } }, { 0, 2, { 18,17,-1, 3, 2 } }, + { 1, 1, { 17,18,18,-2, 2 } }, { 0, 2, { 18,17, 3,-2,17 } }, + { 1, 2, { 18,17, 2,17, 3 } }, { 0, 1, { 18,18,-1, 2,17 } }, + { 0, 1, { 17,17,-2, 2, 3 } }, { 0, 1, { 18,-2,18, 2,17 } }, + { 1, 2, { 18,18,-1, 2, 3 } }, { 0, 2, { 18,17, 3, 2, 5 } }, + { 1, 1, { 18,17,18, 2, 5 } }, { 0, 1, { 17,17,-2, 2, 3 } }, + { 0, 1, { 18,-2,18, 2, 5 } }, { 0, 1, { 17,-2,17, 2,-3 } }, + { 1, 1, { 17,-2,17, 1, 2 } }, { 0, 1, { 17,17,-2, 2, 3 } }, + { 1, 1, { 18, 3, 1, 5, 4 } }, { 1, 4, { 18,18, 2, 3,-2 } }, + { 0, 1, { 1,-1,-1, 2,17 } }, { 0, 2, { 18,17, 3, 2, 5 } }, + { 0, 1, { 18,18,18, 2,17 } }, { 0, 1, { 18,17,-1, 2,18 } }, + { 1, 1, { 17, 3, 2, 1, 7 } }, { 0, 2, { 18,-2,18, 2, 3 } }, + { 1, 3, { 18,-3,18, 2, 3 } }, { 0, 3, { 18,17, 2, 3,17 } }, + { 1, 1, { 17,17, 2, 1, 4 } }, { 0, 1, { 17,18,-2, 2,17 } }, + { 1, 1, { 18,18, 3, 5, 2 } }, { 0, 1, { 17,17, 2,18, 4 } }, + { 0, 1, { 18,17, 1, 4, 6 } }, { 1, 1, { 3,17,18, 2,17 } }, + { 1, 1, { 17, 3, 2, 1, 7 } }, { 0, 1, { 18,17,-1, 2, 3 } }, + { 1, 1, { 17,17, 2, 1, 4 } }, { 1, 2, { 18,17,-1,17, 3 } }, + { 1, 2, { 18,17, 2, 3,-1 } }, { 0, 2, { 18,18,-2, 2,17 } }, + { 0, 1, { 17,17, 2,18, 4 } }, { 0, 5, { -2,18,18,18, 2 } }, + { 1, 1, { 18,18,-1, 6, 3 } }, { 0, 1, { 17,17,-2, 2, 3 } }, + { 1, 1, { 18,17,18, 2,17 } }, { 0, 1, { 18,17, 4, 3, 1 } }, + { 0, 1, { -2,18, 2, 2,18 } }, { 1, 2, { 18,18,-2, 2,-1 } }, + { 1, 1, { 17,17, 2, 1, 4 } }, { 0, 1, { 17,18,-2, 2,17 } }, + { 1, 1, { 17, 3, 2, 1, 7 } }, { 1, 3, { 18,-3,18, 2, 3 } }, + { 1, 2, { 18,18,-2, 2,-1 } }, { 1, 1, { 18,18, 3, 5, 2 } }, + { 0, 2, { 18,18,-1, 2,17 } }, { 0, 1, { 18,-1,17,18, 2 } }, + { 0, 1, { 17,-1, 2, 3, 6 } }, { 0, 1, { 18,-2,18, 2, 5 } }, + { 1, 2, { 18,18,-2, 2,-1 } }, { 0, 3, { 18,18, 2, 3,17 } }, + { 0, 1, { 17,17, 2,18, 4 } }, { 1, 1, { 17,-2,17, 1, 2 } }, + { 0, 1, { -1, 3, 5, 4, 7 } }, { 0, 3, { 18,18, 3, 2, 5 } }, + { 0, 1, { 17,17, 2,18, 4 } }, { 0, 1, { 18,17,-2,18, 3 } }, + { 0, 2, { 18,18,-2, 2,17 } }, { 0, 3, { 18,17,-2, 2, 3 } }, + { 1, 1, { 18,18,-2, 2,17 } }, { 0, 1, { 18,17, 4, 3, 1 } }, + { 1, 2, { 3,18,17, 2,17 } }, { 1, 2, { 18,18, 2,-2,18 } }, + { 1, 2, { 18,18,-1,18, 2 } }, { 0, 2, { 18,18,-2, 2,17 } }, + { 1, 3, { 18,18, 2, 3,-2 } }, { 0, 3, { 18,18, 3, 2, 5 } }, + { 0, 1, { 18,-2,18, 2, 5 } }, { 1, 1, { 17, 3, 2, 1, 7 } }, + { 1, 3, { 18,18,-2, 2,18 } }, { 1, 1, { 17,18,18,-2, 2 } }, + { 0, 1, { 18,-2,18, 2, 5 } }, { 0, 2, { 18,-2,18, 2, 3 } }, + { 0, 1, { -1, 3, 4, 5, 7 } }, { 1, 1, { 17,17, 2,-1, 7 } }, + { 0, 1, { 18,-1,-1, 2,-2 } }, { 0, 2, { 18,17, 2, 3,17 } }, + { 0, 1, { 18,17, 2,18, 2 } }, { 0, 2, { 18,17,-1, 2,17 } }, + { 0, 1, { 1,18, 3, 2, 5 } }, { 0, 2, { 18,-2, 4,18, 2 } }, + { 1, 1, { 18, 3, 1, 5, 4 } }, { 0, 1, { 18,17,18, 2, 5 } }, + { 1, 1, { 18, 3, 1, 5, 4 } }, { 0, 4, { 18,18,-2, 2,18 } }, + { 1, 1, { 18,18, 3, 2, 5 } }, { 1, 1, { 17,17, 2, 1, 4 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 1, 1, { 18,18, 2, 1, 3 } }, { 1, 1, { 17,17, 2, 1, 4 } }, + { 1, 2, { 17,17, 2,18, 3 } }, { 0, 1, { 18,17, 1, 4, 6 } }, + { 1, 2, { 18,18,-2, 2,-1 } }, { 0, 1, { 18,-2,18, 2, 5 } }, + { 1, 1, { 17, 2,18, 2,17 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 0, 1, { 18,18, 3, 6,-1 } }, { 0, 1, { 18,17, 2,18, 3 } }, + { 0, 1, { 18,17,-2, 2,17 } }, { 1, 1, { 3,17,18, 2,17 } }, + { 1, 3, { 18,-3,18, 2, 3 } }, { 1, 3, { 18,18,-3,18, 2 } }, + { 1, 1, { 18, 3, 1, 5, 4 } }, { 0, 1, { 17,-2,17, 2,-3 } }, + { 1, 1, { 18,18, 3, 5, 2 } }, { 1, 2, { 18,18,-2, 2,-1 } }, + { 0, 1, { 18,-1,-1, 2,-2 } }, { 1, 1, { 18, 3, 1, 5, 4 } }, + { 0, 3, { 18,17,-1, 2,17 } }, { 1, 3, { 18,17, 2,18,-2 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 1, 2, { 18,18,-2, 2,-1 } }, + { 1, 1, { 18, 3, 1, 5, 4 } }, { 0, 4, { 3,18,18, 2,17 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 1, 1, { 18,17,-1,18, 2 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 1, 1, { 18,18,18, 3, 2 } }, { 0, 1, { 17,-1, 2, 3, 6 } }, + { 0, 1, { 17,-1, 2, 3, 6 } }, { 0, 2, { 18,17,-2, 3, 2 } }, + { 1, 3, { 18,17, 2,-2,18 } }, { 0, 2, { 18,18, 2,17, 3 } }, + { 0, 1, { 18,18, 2,18,-2 } }, { 0, 2, { 18,-2, 4,18, 2 } }, + { 0, 1, { -2,18, 2, 2,18 } }, { 0, 2, { 18,17, 3, 6, 2 } }, + { 0, 1, { 18,17,18, 2, 5 } }, { 0, 3, { 18,18,-2, 3, 2 } }, + { 1, 1, { 18,18, 2,18, 5 } }, { 0, 1, { 17,-1, 2, 3, 6 } }, + { 1, 4, { 18,18, 2, 3,-2 } }, { 0, 2, { 18,17,18, 2,-2 } }, + { 0, 1, { 1,18, 3, 2, 5 } }, { 1, 4, { 18,-2,18, 2, 3 } }, + { 1, 2, { 18, 2,18, 3,-2 } }, { 0, 2, { 18,18,18, 2, 4 } }, + { 0, 2, { 3,17,18, 2,17 } }, { 1, 1, { 18,-1,18, 2,17 } }, + { 1, 2, { 17,17, 2,18, 3 } }, { 0, 2, { 18,17,-2, 3, 2 } }, + { 0, 1, { 1,-1,-1, 2,17 } }, { 0, 3, { 3,18,18, 2,17 } }, + { 0, 1, { 18,-1,17,18, 2 } }, { 0, 1, { 18,17, 2,18, 3 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 1, { 18,17, 2,18, 2 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 1, 2, { 17,17, 2,18, 3 } }, { 0, 1, { 18,17,-2, 2, 3 } }, + { 0, 1, { 18,-2,18, 2, 5 } }, { 1, 4, { 18,-2,18, 2, 3 } }, + { 1, 3, { 18,17, 2, 3, 6 } }, { 0, 2, { 18,18, 2,17, 3 } }, + { 0, 2, { 18,17, 2,18, 2 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 1, 1, { 18,18, 3, 5, 2 } }, { 0, 2, { 18,18,-2, 2, 3 } }, + { 1, 2, { 18,17, 2,17, 3 } }, { 0, 1, { 18,17, 2, 3,18 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 1, 4, { 18,18, 2, 3,-2 } }, + { 0, 1, { 17,-2,17, 2,-3 } }, { 0, 1, { 17,17, 2,18, 4 } }, + { 1, 1, { 18,18,18, 2, 4 } }, { 1, 2, { 18, 2,18, 3,-2 } }, + { 1, 1, { 18,18,-2, 2,17 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 0, 2, { 18,18, 2,17, 3 } }, { 0, 2, { 18,18,18, 2, 4 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,17,-2, 3, 2 } }, + { 0, 1, { 1,-1,-1, 2,17 } }, { 1, 4, { 18,18, 2, 3,-2 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 1, { 18,-2,18, 3, 2 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 0, 1, { 18,18,-2, 2,17 } }, { 0, 3, { 18,17, 2, 3,17 } }, + { 1, 2, { 18,18, 2,-2,18 } }, { 0, 1, { -1, 3, 5, 4, 7 } }, + { 1, 1, { 18, 3, 1, 5, 4 } }, { 1, 1, { 18,18,-2,18, 3 } }, + { 0, 2, { 18,17,18, 2,-2 } }, { 0, 2, { 18,18, 2,17, 3 } }, + { 1, 2, { 18, 2,18, 3,-2 } }, { 1, 4, { 18,18, 2, 3,-2 } }, + { 1, 3, { 18,17, 2, 3, 6 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 1, 2, { 18,17,-2,-1,17 } }, { 0, 1, { 17,-1, 2, 3, 6 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,18,-2, 2, 3 } }, + { 1, 1, { 18,18,18, 2, 5 } }, { 0, 1, { 17,17,-2, 2, 3 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,17, 3, 6, 2 } }, + { 0, 2, { 18,17,18, 2, 3 } }, { 0, 3, { 18,17,-3,18, 2 } }, + { 0, 1, { 18,18,18, 2, 3 } }, { 0, 1, { 18,-2,-3, 2, 6 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 1, 1, { 18,17,18, 2, 5 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 1, 1, { 18,17,18, 2, 5 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 0, 1, { 18,18,18, 2, 3 } }, { 1, 1, { 17,-2,17, 1, 2 } }, + { 1, 1, { 17,17, 2,-1, 7 } }, { 0, 1, { 18,17, 4, 3, 1 } }, + { 1, 3, { 18,-3,18, 2, 3 } }, { 0, 1, { 1,18, 3, 2, 5 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 0, 1, { 18,18, 3, 6, 2 } }, { 0, 1, { 17,17, 2,18, 4 } }, + { 0, 1, { 17,17, 2,18, 4 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 1, 2, { 18,-2,18, 3, 2 } }, { 1, 1, { 17,-2,17, 1, 2 } }, + { 1, 1, { 18,18, 3, 2, 5 } }, { 0, 1, { 18,18,-1, 2, 3 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 0, 1, { 18,17,18, 2, 5 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 1, { 3,18,18, 2,17 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,18,-2,18, 2 } }, + { 0, 2, { 18,18,-2,18, 2 } }, { 0, 2, { 18,18,-2,18, 2 } }, +}; + +static const WavPackDecorrSpec high_specs[] = { + { 1, 2, { 18,18,18,-2, 2, 3, 5,-1,17, 4 } }, { 0, 1, { 18,17,-2, 2,18, 3, 7, 2, 5, 4 } }, + { 1, 2, { 1,18, 3, 6,-2,18, 2, 3, 4, 5 } }, { 0, 2, { 18,18,-2, 2,18, 3, 6, 2,17, 4 } }, + { 1, 2, { 18,18, 2,18, 3, 2,-1, 4,18, 5 } }, { 1, 1, { 7, 6, 5, 3, 4, 2, 5, 4, 3, 7 } }, + { 1, 1, { 17, 3,18, 7, 2, 6, 1, 4, 3, 5 } }, { 1, 1, { -2,18,18,18, 3,-2, 6, 5, 2, 1 } }, + { 1, 2, { 18,18,-1,18, 2, 3, 6,-2,17, 5 } }, { 0, 1, { 17,17,18, 3, 6, 4, 5, 2,18,-2 } }, + { 1, 2, { 1,18,-2, 3, 5, 2, 4,-1, 6, 1 } }, { 0, 2, { 18,18, 3, 6,18, 2, 4, 8, 5, 3 } }, + { 0, 1, { -2, 1,18, 2,-2, 7,18, 2,-1, 5 } }, { 1, 1, { 4, 3, 8, 1, 5, 2, 5, 6, 2, 8 } }, + { 1, 1, { 17,18, 2, 6, 3, 4,-1, 1, 8, 6 } }, { 0, 1, { 18,18, 3, 6, 3,-2, 2, 5,-1, 1 } }, + { 0, 1, { 18,18,17,-1, 2,-2,18, 3, 4, 5 } }, { 1, 2, { 18,17, 2,-2,18, 3, 5, 7, 2, 4 } }, + { 1, 2, { 18,18, 3, 6,-2,18, 2, 5, 8, 3 } }, { 0, 1, { 18,17, 2,18,18, 2, 6, 5,17, 7 } }, + { 1, 2, { 18,17, 2,18, 3, 2, 6,18,-1, 4 } }, { 1, 1, { 5, 3, 6, 5, 3, 4, 1, 2, 4, 7 } }, + { 1, 1, { 5, 3, 6, 5, 3, 4, 1, 2, 4, 7 } }, { 0, 1, { -2,18,18,18,-2, 3, 2, 4, 6, 5 } }, + { 1, 2, { 18,17,-3, 3,-1,18, 2, 3, 6, 5 } }, { 0, 1, { 17,18, 7, 3,-2, 7, 1, 2, 4, 5 } }, + { 1, 1, { 2,18,18,-2, 2, 4,-1,18, 3, 6 } }, { 0, 3, { 1,18, 4, 3, 5, 2, 4,18, 2, 3 } }, + { 0, 1, { -2,18, 2,18, 3, 7,18, 2, 6,-2 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 1, { 18,18, 5, 4, 6, 4, 5, 1, 4, 3 } }, { 1, 1, { 18, 3, 6, 5, 7, 8, 2, 3, 1,-1 } }, + { 1, 1, { 18,18,18, 2,-2, 3, 5,18, 2, 8 } }, { 0, 2, { 18,17,-2, 2, 3,18,-3, 5, 2, 7 } }, + { 1, 1, { 1, 1,-1, 8,17, 3,-2, 2, 6,17 } }, { 0, 2, { 18,18,17, 2,-2, 3, 2, 4,18, 5 } }, + { 1, 1, { 17,18, 2,-1, 5, 7,18, 3, 4, 6 } }, { 1, 1, { 5, 4, 5,17, 3, 6, 3, 4, 7, 2 } }, + { 0, 1, { 17, 3, 1, 7, 4, 2, 5,-2,18, 6 } }, { 0, 1, { 17,18, 2,18, 4, 3, 5, 7,-3, 6 } }, + { 1, 2, { 17,17,-3,-2, 2, 8,18,-1, 3, 5 } }, { 0, 1, { 17,17,18, 2, 3, 6,-2, 8, 1, 7 } }, + { 1, 1, { 1, 2, 6,-2,18, 2, 5,-3, 7,-2 } }, { 0, 1, { 18,18, 3,18, 6, 8,-2, 2, 3, 5 } }, + { 0, 1, { 18,17, 2,18,-2, 3, 7, 6, 2, 4 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 1, { 18,18, 2,-1, 3, 6, 1, 3, 4, 8 } }, { 0, 1, { 18,18, 3, 6, 5, 3,-2, 2,18,-1 } }, + { 0, 1, { 18,17,-3,18, 2, 4,-2, 3, 6,17 } }, { 1, 3, { 1, 2,17, 3,18, 7,-1, 5, 2, 4 } }, + { 1, 1, { 18, 3,18, 6, 8,18,-2, 5, 7, 2 } }, { 0, 1, { 17, 2,18, 6, 3, 2, 5, 4, 8, 1 } }, + { 0, 1, { 18,17,-1, 2, 3,18,18, 2, 3,17 } }, { 1, 1, { 18, 7, 6, 5, 5, 3, 1, 4, 2, 4 } }, + { 1, 1, { 6,17, 3, 8, 1, 5, 7,-1, 2, 1 } }, { 1, 1, { 18,-2,18, 3,-2, 2, 7, 4, 6,18 } }, + { 1, 3, { 18,-3,18, 2, 3,18,-1, 7, 2, 5 } }, { 0, 2, { 18,-2, 7, 1, 3, 2, 4, 6,-3, 7 } }, + { 1, 1, { 18,-2, 2,-3,18,-2,17,-1, 4, 2 } }, { 0, 3, { 17,17, 2, 5, 3, 7,18, 6, 4, 2 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 1, { 18,17, 4, 6, 6, 4, 5, 3, 4, 1 } }, { 0, 1, { 18, 5, 3, 6, 2, 3, 8, 1, 3, 7 } }, + { 1, 2, { 18,17,-2, 2,18, 3, 5, 7,-1, 2 } }, { 0, 1, { 1,18,18, 3, 6,-1, 4, 8, 5, 2 } }, + { 1, 1, { 1, 5, 3, 4, 1, 1, 3, 5, 7, 3 } }, { 0, 1, { 3,18,18, 2,18,18,-1, 2, 3,18 } }, + { 1, 2, { 18,18,-1,18, 2, 3, 4, 6,18, 5 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 1, { 18, 3, 1, 4, 5, 2, 7, 1, 3, 6 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 2, { 18,18,-1,18, 2, 3, 5,-2, 6, 8 } }, { 1, 1, { 17,18, 4, 8, 3, 2, 5, 2, 7, 6 } }, + { 1, 4, { 1, 2, 5,18,-2, 2, 3, 7,-1, 4 } }, { 0, 2, { 18,17,-1, 3, 6,18, 2, 3, 7, 5 } }, + { 0, 1, { -2,18, 2,-3, 6,18, 4, 3,-2, 5 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { 17,17, 6, 2, 4, 8, 3, 5,-1,17 } }, { 1, 1, { 18, 3,18, 6, 8,18,-2, 5, 7, 2 } }, + { 1, 2, { 17,17,-3, 2,18,-2, 8, 3, 6,-1 } }, { 1, 1, { 18,-2,17,18, 2, 3,-2, 6, 5, 4 } }, + { 1, 2, { 18,17,-1, 3,18, 2, 5, 3, 6,-3 } }, { 0, 1, { 18,17, 2,18, 7,18, 2, 4, 3,17 } }, + { 1, 3, { 18,18, 5, 6, 4, 3, 4,18, 6, 5 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 1, { 7, 6, 5, 3, 4, 2, 5, 4, 3, 7 } }, { 0, 1, { -2,18,18,18, 3, 6, 4, 2, 5, 2 } }, + { 0, 3, { 18,17,-3,18, 3, 2, 5,-1,17, 3 } }, { 1, 1, { 17,18, 7, 3, 1, 7, 4, 2, 6, 5 } }, + { 1, 1, { 18, 2,-2,-1,18, 5, 3,-2, 1, 2 } }, { 0, 3, { 18,18,-1, 3, 2, 7, 5,18, 4, 3 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 1, { 17,18, 2,-2, 4, 8,18, 3, 6, 5 } }, { 0, 2, { 18,17, 3, 5,-2, 7, 2,18, 3,-1 } }, + { 1, 1, { 18, 2,-2,-1,18, 5, 3,-2, 1, 2 } }, { 0, 2, { 3,17,18,18, 2, 5, 7, 6,18, 3 } }, + { 1, 1, { 17,18,18, 4, 3, 2,18, 7, 8,-1 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { 17, 1, 2, 3, 5, 6, 1, 4, 8,17 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 2, { 18,17,-1,18,-3, 2, 8, 3, 6,17 } }, { 1, 1, { 17,17, 1, 2, 4, 5,-1, 2, 1, 6 } }, + { 1, 1, { 1, 2, 6,-2,18, 2,-3, 3,-2, 5 } }, { 0, 1, { 18, 3,18, 6,18, 5, 2, 4,-1, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 1, { 18,18,-1, 2,18, 3, 6, 4,-2, 7 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 2, { -1,18,18,18, 2,-2, 4, 7, 2, 3 } }, { 0, 3, { 3,17,-2, 5, 2, 7,18, 6, 4, 5 } }, + { 0, 1, { 17, 6,18, 3, 8, 4, 5, 3, 8,18 } }, { 0, 2, { 18, 2, 6, 2,18, 3, 2, 4, 5, 8 } }, + { 0, 1, { 3,18,18, 2,18,-1, 2,18, 2,17 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { 3, 6,17,-2, 5, 1, 2, 7, 4, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 3, { 3,18,17, 5, 6, 2, 7,-2, 8,18 } }, { 1, 1, { 18,-1, 3, 1, 7, 2,-1, 4, 6,17 } }, + { 1, 1, { 18, 2,-2,-1,18, 5, 3,-2, 1, 2 } }, { 0, 2, { 18, 1, 2,18, 3, 6, 5, 2, 4, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 1, { 17,-2, 2,18,18, 8, 5, 3, 2, 6 } }, { 0, 1, { 18,17, 2,18, 3, 2, 7,-2,18, 4 } }, + { 1, 2, { 1,18, 2, 3,-1, 5, 6, 4, 7,17 } }, { 0, 2, { 18,17, 3, 6,-2, 2, 3, 8, 5,17 } }, + { 0, 2, { 18,18, 3, 2,18,-1, 2, 4, 3,17 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 2, { 17,-1,18, 2, 3,-2, 5,18, 2, 7 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 2, { 18,-3,18, 2, 3,-2,18, 5, 6,-3 } }, { 0, 2, { 18,17, 3, 5,-2, 7, 2,18, 3,-1 } }, + { 1, 1, { 1,18,-1, 2, 3, 1,-2, 8, 2, 5 } }, { 0, 1, { 18,18, 3, 6,18, 2, 3, 4, 8, 5 } }, + { 0, 1, { -2, 1,18, 2,-2, 5, 7,18, 2,-1 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 1, { 17,18,-1, 2, 8, 3, 4, 5, 1, 7 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 2, { 18,18,-1, 2,18, 3,-2, 5, 4, 2 } }, { 1, 1, { 18,17, 2,18, 3, 8, 5, 2, 7,17 } }, + { 0, 1, { 18,18, 3,18, 6, 8,-2, 2, 3, 5 } }, { 0, 1, { 18,18, 2,18, 2, 6,18, 2,17, 7 } }, + { 1, 3, { 18,17,18, 2, 8,18, 5,-1, 3, 6 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 1, { 18, 7, 6, 5, 5, 3, 1, 4, 2, 4 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 2, { 18,17,-1, 3, 6,18, 2, 5, 8, 3 } }, { 0, 1, { 17,18,18, 4, 7, 2, 3,-2,18, 5 } }, + { 1, 2, { 18, 1, 2, 6, 2, 5,18, 2, 4, 8 } }, { 0, 4, { 18, 4, 1, 2, 3, 5, 4, 1, 2, 6 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 2, { 18,17, 2,-1,18, 3,-3, 5, 2, 4 } }, + { 0, 1, { 17,17, 3, 6, 3, 5,-2, 2,18,-1 } }, { 0, 2, { 18,18, 3,-2,18, 2,-3, 5, 3, 6 } }, + { 1, 1, { 17,17, 2, 4, 1, 3, 5, 2, 6,-3 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { 17, 1, 3, 2, 7, 1, 6, 3, 4, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { 17,-1,18, 2, 1, 5, 3, 8,-1,-2 } }, { 1, 1, { 17,18,-1, 8, 2, 5, 3, 4, 1, 6 } }, + { 1, 2, { 1,18, 3,-1, 5, 1, 2, 4, 7, 6 } }, { 0, 1, { 18,18, 3, 6, 5, 3,-2, 2,18,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { 1,18,-1, 3, 8, 5, 6, 1, 2, 3 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 2, { 18,18, 2, 3, 6,18,-1, 4, 2, 3 } }, { 1, 1, { 1, 3, 5,18, 2, 6, 7, 2, 3, 1 } }, + { 1, 1, { 1, 3, 8,18, 5, 2, 7, 1, 3,-2 } }, { 0, 2, { 17, 2,18, 3, 6, 2, 4, 5, 8, 3 } }, + { 0, 1, { 18,17, 2,18, 3, 2, 7,-2,18, 4 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 2, { 18,-3,18,-1, 3,-2, 5, 7, 1, 2 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 3, { 18,18, 2, 6,18, 5,18, 2, 3,17 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 3, { 1,-1, 1, 3,-2, 2, 5, 7,-3,18 } }, { 1, 2, { 18, 7, 3,-3, 2, 8, 2, 5, 4,17 } }, + { 1, 1, { 1, 4, 5, 1, 3, 4, 6, 7, 8, 3 } }, { 0, 1, { 18,17, 2,18,-1, 2, 3,18, 2, 4 } }, + { 0, 2, { 18,18,-2,18, 2, 3, 4, 7, 5,17 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 1, { 17,18, 2, 1, 3, 2, 5, 1, 2, 3 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 2, { 18,18,-1, 2, 3, 5, 8, 6, 1,-2 } }, { 0, 1, { 17,18, 8, 3, 4, 6, 5, 2, 8, 7 } }, + { 1, 2, { 1, 3,-2,18, 2, 5, 1, 7,-1,-2 } }, { 0, 3, { 18,17,-1, 3,18, 2, 3, 6, 4,17 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 2, { 18,18, 4,18, 6, 7, 8, 3,18, 2 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 2, { 17,-3,17, 2,-2, 8, 3,18, 4,-3 } }, { 1, 1, { 18,17, 3, 5, 6, 2, 8, 1, 3, 7 } }, + { 0, 1, { 18,18, 3, 6, 5, 3,-2, 2,18,-1 } }, { 0, 3, { 18,18, 2, 6,18, 5,18, 2, 3,17 } }, + { 1, 1, { 18,18, 5, 4, 6, 4, 5, 1, 4, 3 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 2, { 3,17,18,-3, 2, 5,18, 6,-1, 7 } }, { 1, 1, { 17,18, 3, 2, 5,-1, 6, 8, 4, 7 } }, + { 1, 1, { 18, 1,-2, 3, 2, 1, 7, 6, 3, 4 } }, { 0, 3, { 1, 2,17, 3,18, 2, 7, 5, 4,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 1, { 17,-2, 2,18,18, 8, 5, 3, 2, 6 } }, { 0, 2, { 18, 5,18, 2, 3, 7,-2, 1, 6, 8 } }, + { 0, 1, { 2,-1,18,-1, 2, 4,-3, 5,18, 3 } }, { 0, 1, { 3,17,18, 5, 2,18, 7, 3, 6, 5 } }, + { 1, 4, { 1, 2, 5,18,-2, 2, 3, 7,-1, 4 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { 1,18, 2, 1, 3, 4, 1, 5, 2, 7 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { 17,17,18, 2, 4, 5,18,-2, 6, 3 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 2, { 18,18,-1, 3, 5, 6, 8,18, 2, 3 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { 18,18, 4, 6, 8,18, 7, 3, 2, 5 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 2, { -1,18,18,18, 2, 4,-2, 2, 3, 6 } }, { 0, 2, { 18,-2, 7, 1, 3, 2, 4, 6,-3, 7 } }, + { 1, 1, { 17,18, 8, 3, 4, 6,-2, 5, 3, 8 } }, { 0, 2, { 18, 1, 2, 6, 2, 8, 3,18, 5, 4 } }, + { 1, 1, { 3,18,18, 2,18, 2,18, 3, 2,18 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 1, 1, { 3,17,18, 5, 2, 6, 7, 1, 4, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2, 8 } }, +}; + +static const WavPackDecorrSpec very_high_specs[] = { + { 1, 2, { 18,18, 2, 3,-2,18, 2, 4, 7, 5, 3, 6, 8,-1,18, 2 } }, + { 0, 1, { 18,18,-1,18, 2, 3, 4, 6, 5, 7,18,-3, 8, 2,-1, 3 } }, + { 1, 2, { 1,18,-2, 4,18, 2, 3, 6,-1, 7, 5,-2,18, 8, 2, 4 } }, + { 0, 1, { 17,17, 2, 3, 4,18,-1, 5, 6, 7,18, 2, 8,17, 3,-2 } }, + { 1, 1, { 18,18, 2,18, 3, 2,18, 4,-1, 3,18, 2, 6, 8,17, 5 } }, + { 0, 2, { 18,17, 2, 3,-2, 5,18,-3, 2, 4, 7, 3, 6, 8, 5,17 } }, + { 1, 1, { 18,-2, 2,-3,18, 5,-2,18, 2, 3, 6, 2,17, 4, 7,-1 } }, + { 1, 1, { 17, 8,18, 3,-2, 2, 5, 4,18, 6, 3, 8, 7, 2, 5, 4 } }, + { 0, 2, { 18,17,-2, 2,18, 3, 2, 5,-3, 4, 7,18, 3, 8, 6, 2 } }, + { 1, 1, { 3, 6, 5, 5, 1, 3, 7, 4, 2, 6, 4,18, 3, 7, 5, 6 } }, + { 1, 2, { 1,18, 3, 2,-2, 1, 5, 4, 6, 2, 7, 1, 8, 3,-1, 1 } }, + { 0, 1, { 18,18, 2, 3, 6, 3, 5,-2, 2, 4,18, 3,-2,-1, 6, 7 } }, + { 0, 1, { -2,18, 2,18, 7, 2, 6,-2, 3, 4,18,18, 2,-3, 8, 5 } }, + { 0, 2, { 18,18,18, 2, 4, 3,18, 5, 3, 6,-2, 2, 4,18, 8, 7 } }, + { 0, 1, { -2, 1,18, 2,-2,18,-1, 5, 7, 2, 3, 4,18, 2, 6, 2 } }, + { 1, 1, { 17,18, 3, 2, 1, 7,-1, 2, 4, 3, 5, 6,-2,18, 7, 8 } }, + { 1, 1, { 18,18, 2,18, 3, 4, 6,-2,18, 5, 8, 2, 3, 7, 4,-1 } }, + { 0, 1, { 18,18,18,-1, 2, 3, 4, 6, 8,18, 3, 5, 2, 6, 7, 4 } }, + { 1, 1, { 17,-2,18,18, 2, 5, 3, 8, 2,-1, 6, 1, 3, 4, 7, 5 } }, + { 0, 1, { 17,17,18, 2, 3, 6,-2, 8, 1, 7, 5, 2, 3, 1, 4, 8 } }, + { 1, 1, { 17,17, 3, 2, 7, 1, 4, 3, 6, 2, 5,-2, 8, 7,18, 6 } }, + { 0, 1, { 18,17,-2, 2,18, 3,-3, 7, 6, 5, 2, 4,-1, 8, 3,17 } }, + { 1, 1, { 2,18,18,-2, 2, 4,-1, 5,18, 3, 8, 6, 2, 7,17, 4 } }, + { 0, 1, { 17, 3, 6, 8, 5, 4, 3, 8, 1,18, 7, 2, 4, 5, 6, 3 } }, + { 1, 2, { 17,18, 4, 8, 3, 2, 5, 7, 6, 8, 2, 7,-2,18, 3, 4 } }, + { 1, 1, { 6, 5, 5, 3, 4, 7, 3, 2, 4, 6, 3, 7, 1, 5, 2, 4 } }, + { 1, 1, { 1,18,-1, 2, 1, 3, 8,-2, 2, 5, 6, 3, 8, 7,18, 4 } }, + { 0, 1, { 1,17,-1,18, 3, 2, 5, 4, 6, 7, 8, 3, 4, 2, 1,-2 } }, + { 0, 1, { 18, 2,18,18, 2,18, 6,-2,18, 7, 5, 4, 3, 2,18,-2 } }, + { 0, 3, { 1, 4,18, 3, 2, 4, 1, 5, 2, 3, 6,18, 8, 7, 2, 4 } }, + { 0, 1, { 17,-2, 1,-3, 2,18, 3,-2, 4,18, 3, 6, 7,-3, 2, 8 } }, + { 1, 1, { 17,18,18, 4, 2, 3, 7, 6,18, 8, 5,-1, 4, 2, 3,17 } }, + { 1, 2, { 18,-1,17,18, 2, 3,-2,18, 5, 8, 2, 4, 3, 7, 6,-1 } }, + { 1, 1, { 18,18,18,-2, 4, 2, 3,18, 5, 8, 2, 4, 6, 7,-2, 3 } }, + { 1, 2, { 18,18,-2,18,-1, 3, 2, 5,18,-2, 7, 2, 3, 4, 6, 8 } }, + { 0, 1, { 17,18,-1, 2, 4,18, 8, 3, 6, 5, 7,-3, 2, 4, 3,17 } }, + { 1, 1, { 18,18,17, 2,-1,18, 3, 2,18, 6, 5, 4,18, 7, 2,-1 } }, + { 0, 2, { 1,18,-1,18, 3, 2, 4, 6,-3, 7,-1, 5, 1, 2, 3, 8 } }, + { 1, 1, { 1,17,-2, 2,-3, 6, 3, 5, 1, 2, 7, 6, 8,-2, 4, 1 } }, + { 0, 1, { 17,-1, 5, 1, 4, 3, 6, 2,-2,18, 3, 2, 4, 5, 8,-1 } }, + { 0, 2, { 18,18,17, 2, 3,-2, 5,18, 2, 4, 7, 8, 6,17, 3, 5 } }, + { 1, 1, { 1, 5, 1, 3, 4, 3, 7, 5, 1, 3, 6, 1, 2, 4, 3, 8 } }, + { 1, 2, { 1,-1, 3, 2,18, 7,-2, 5, 2, 6, 4, 3,-1,18, 8, 7 } }, + { 0, 2, { 18,17, 3,18, 2, 5, 4, 3, 6, 2, 7, 8,18, 3, 4, 5 } }, + { 1, 1, { 3, 6,17, 8, 7, 5,18,-1, 1, 2, 3, 4, 2, 6, 8, 1 } }, + { 0, 2, { 18,18, 3,-3,18, 2, 6, 5, 3, 7,18, 4,-2, 8, 2, 3 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 17, 1, 7, 2, 3,18,-2, 3, 6, 4, 2, 7, 8, 5, 3,17 } }, + { 1, 1, { 3, 6, 5, 5, 1, 3, 7, 4, 2, 6, 4,18, 3, 7, 5, 6 } }, + { 0, 1, { 18,18,18, 2, 4,-1,18, 8,-1, 2, 3, 4, 6,-2, 1, 7 } }, + { 1, 1, { 18,-2,17,18, 2, 6, 3,-2, 5, 4, 7, 1,-3, 8, 2, 6 } }, + { 0, 1, { 17,18,18, 4, 2, 7, 3, 6,-2,18, 8, 4, 5, 2, 7,17 } }, + { 1, 1, { 18,18, 5, 4, 6, 4, 1, 5, 4, 3, 2, 5, 6, 1, 4, 5 } }, + { 0, 1, { 18,18,-2,18, 2,-3, 3, 8, 5,18, 6, 4, 3,-1, 7, 2 } }, + { 1, 1, { 18, 2,-2,-3,18, 5, 2, 3,-2, 4, 6, 1,-3, 2, 7, 8 } }, + { 0, 1, { 18, 3, 5, 8, 2, 6, 7, 3, 1, 5, 2,-1, 8, 6, 7, 4 } }, + { 1, 1, { 4, 3, 8, 1, 5, 6, 2, 5, 8,-2, 2, 7, 3,18, 5, 4 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 17, 3,18,18, 7, 2, 4,18, 6, 2, 3,-1, 8, 5,18,-3 } }, + { 0, 1, { 3,17,18, 2,18, 6, 7,-3,18, 2, 5, 6, 3, 8, 7,-1 } }, + { 1, 1, { 18,18, 2,18,18, 2,-1, 7, 3,18, 5, 2, 6, 4,-1,18 } }, + { 0, 3, { 18, 3, 4, 1, 5, 2,18, 4, 2, 3,18, 7, 6, 1, 2, 4 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 17, 1,18, 2, 3, 6, 4, 5, 7,18, 3, 8, 2, 4,-2,17 } }, + { 1, 2, { 18,17, 2, 3, 5,18, 6,-2, 7, 3, 2, 4,18, 8,-1, 5 } }, + { 0, 2, { 1,18,-1,18, 3, 2, 4, 6,-3, 7,-1, 5, 1, 2, 3, 8 } }, + { 1, 1, { 1,18,-1, 8, 2, 6, 3,-2, 1, 2, 5, 4,-3, 8, 6, 3 } }, + { 0, 1, { 18,18, 2,18, 2,18, 7, 6,18, 2,-2, 3, 5, 4,18, 8 } }, + { 1, 2, { 18,17, 2, 3,18,-1, 2, 3, 6,18, 5, 4, 3, 7, 2, 8 } }, + { 1, 2, { 18,18, 3,-2, 4,18, 5, 7, 6, 2, 4,-3, 8, 5,18, 3 } }, + { 1, 1, { 17,-2,18,18, 2, 5, 3, 8, 2,-1, 6, 1, 3, 4, 7, 5 } }, + { 1, 1, { 3,17,18, 5, 7, 2, 4, 6, 1, 8,-1, 3, 7, 4, 1, 2 } }, + { 0, 2, { 1,-2, 2,18, 3, 5, 2, 4, 7,-1, 2, 3, 5,18,-2, 4 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 1, 2,-2, 6,18,-3, 2, 7, 3,-2, 5, 6, 1, 8, 2, 4 } }, + { 0, 1, { 18,18,18, 3,-2, 6,18, 2, 4, 3, 5, 8, 7, 6, 2,-2 } }, + { 1, 1, { 1, 5, 1, 3, 4, 3, 7, 5, 1, 3, 6, 1, 2, 4, 3, 8 } }, + { 0, 1, { 3,17,18, 2, 5,18, 6, 7, 5,-2, 2, 4,18, 3, 6, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 2, { 17,-1,18, 2, 4,-1, 8, 3,18, 7,-3, 4, 5, 1, 2,-2 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 8, 6, 4, 5, 7,-1 } }, + { 1, 1, { 18,18, 3, 6, 4, 8,-2, 2, 5, 3, 7,18, 6, 8, 4, 2 } }, + { 1, 1, { 17,18,18,-2, 5, 2, 3, 1, 4,-1, 8, 6, 5, 3, 2,18 } }, + { 1, 1, { 17,17, 1, 2, 4, 5, 2, 6,-1, 3, 1, 1,-2, 4, 2, 7 } }, + { 1, 1, { 17, 1, 7, 2, 3,18,-2, 3, 6, 4, 2, 7, 8, 5, 3,17 } }, + { 0, 1, { 18,17,-2,-3, 1, 2, 3, 2, 5, 4, 7,-3, 6,-2, 2, 1 } }, + { 1, 1, { 1, 3, 5,18, 1, 2, 7, 3, 6, 2, 5, 8,-1, 1, 4, 7 } }, + { 1, 1, { 17, 3, 6, 8, 1, 4, 5, 3,-2, 7, 2, 8, 5, 6,18, 3 } }, + { 1, 1, { 17,18, 2, 4, 8,-2, 3, 1, 5, 6, 7, 1, 2, 3, 4, 7 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 3, 1, 8,18, 5, 2, 3,18, 6, 7,-2, 4, 3, 2, 8,18 } }, + { 0, 1, { 18,17, 2,18, 3, 4,-1,18, 7, 6, 2, 8, 4,18,18, 5 } }, + { 0, 1, { 18,18, 2,18,18, 2, 7,-2, 6, 5, 4, 3,18, 3, 2,17 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 17, 8,18, 3, 2, 1, 5, 4, 6,-1, 3,-3, 8,18, 7, 2 } }, + { 1, 2, { 18,17,18, 2, 3, 5,-2,18, 6,-1, 2, 3, 7, 4, 8,17 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 8, 6, 4, 5, 7,-1 } }, + { 1, 2, { 18,18,-2,17, 2,18, 3, 4,18, 8, 7,-1, 2, 4, 5,17 } }, + { 0, 2, { 17,-3,17, 3, 2,-2,18, 8, 4,-3, 2,18, 5, 3,-2, 6 } }, + { 0, 1, { 18,18, 2,18,18, 2, 7,-2, 6, 5, 4, 3,18, 3, 2,17 } }, + { 0, 2, { 1,18,-1, 3, 5, 2,-3,18, 7, 3,-1, 6, 4, 2,17, 5 } }, + { 1, 1, { 17,-2,17, 2,-3, 1, 5,-1, 4, 6, 3, 2, 8, 7,-2, 5 } }, + { 1, 1, { 1,18, 1, 3, 5, 8, 6, 2, 3,-1, 7, 1, 4, 8, 5,-3 } }, + { 0, 2, { 3,18,18, 2,18,-2, 6, 5, 7, 2, 4,18, 3, 6,-3, 5 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 3, 6,17, 8, 7, 5,18,-1, 1, 2, 3, 4, 2, 6, 8, 1 } }, + { 0, 4, { 18, 2,17, 3,18,-2, 2, 6,18, 2, 7, 3, 5, 4, 8,18 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { 18,18, 2, 3, 6, 3, 5,-2, 2, 4,18, 3,-2,-1, 6, 7 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 17, 1, 2, 5, 3,-2, 1, 4, 3, 7, 6,-3, 2, 1, 1, 2 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 18,18,-2,18,-2, 2, 3, 6,18, 4,-1, 2, 3, 8, 1, 4 } }, + { 1, 1, { 17,-2,17, 2,-3, 1, 5,-1, 4, 6, 3, 2, 8, 7,-2, 5 } }, + { 0, 1, { 17,17,18, 3, 2,18,18, 6, 8, 2,-2, 3, 5, 4,17,18 } }, + { 1, 1, { 1, 5, 1, 3, 4, 3, 7, 5, 1, 3, 6, 1, 2, 4, 3, 8 } }, + { 1, 1, { 1, 3,-3,18,18, 6, 5,18, 2,-1, 3, 8, 7,-3, 4,17 } }, + { 1, 1, { 18, 1, 2, 1, 3, 8, 7, 4, 1, 5, 2,-1,-3,18, 6, 2 } }, + { 0, 1, { 18, 3, 5, 2, 6, 8,18, 5, 7, 2, 3,-1, 6, 7, 8, 5 } }, + { 0, 2, { 18, 3,-2, 7, 8, 2, 5, 4,-3, 8, 3, 2,18, 5, 4, 6 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 3, { 1, 1, 2, 5, 2, 7, 4, 3,-1,18,-2, 8, 2, 1, 6, 7 } }, + { 0, 1, { 3,17,18, 5, 2, 6, 7,18, 4, 5, 3, 6,18, 2, 7, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { 1,18, 1, 2, 3, 5, 1, 2, 6, 7, 4, 3, 8, 1,17, 5 } }, + { 1, 2, { 17,-1,18,-2, 2, 3, 5,18, 2, 4, 6, 7, 3,-1, 5, 8 } }, + { 1, 1, { 18,18,-3,18,-2, 2, 3,-2,18, 6, 4, 5, 8, 3,17,-3 } }, + { 1, 1, { 18, 7, 6, 5, 5, 3, 1, 4, 2, 7, 3, 4,-3, 6,18, 8 } }, + { 0, 2, { 18,18, 2, 3, 5,18, 2, 4, 3, 6,18, 7, 8,-1, 5, 2 } }, + { 0, 1, { 18,17,-1, 2,18, 3, 2,18, 4, 3,18, 2, 6, 5, 8,17 } }, + { 0, 2, { 18,17, 2, 3,18, 5,-1, 6, 7, 8, 2, 3, 4, 5,18, 6 } }, + { 1, 2, { 18,-3,18, 2, 3,-2,-3, 5,18, 7, 6, 2, 4, 3, 8,-2 } }, + { 1, 1, { 17,18,18,-2, 2, 3, 5, 4, 8,18,-1, 5, 3, 6,-2, 7 } }, + { 1, 2, { 18,17, 2,-2,18, 3,-1, 4,18, 2, 7, 5, 3, 8, 6, 4 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 1, 5, 1, 3, 4, 3, 7, 5, 1, 3, 6, 1, 2, 4, 3, 8 } }, + { 0, 2, { 18,18, 3, 3,-2, 2, 5,18, 6, 3,-1, 4, 7,-1, 1, 2 } }, + { 0, 1, { -2, 1,18, 2,-2, 5, 7,18, 3, 2, 6, 2,-1, 4,-2,17 } }, + { 0, 2, { 18,18,18, 2, 3,-2,18, 5, 4, 2, 6, 8, 3,-2, 4,18 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 17,18,-1, 3, 2, 5, 1, 3, 2, 8, 4, 7, 6, 2,-1, 5 } }, + { 1, 1, { 17,18,18, 4, 2, 3, 7, 6,18, 8, 5,-1, 4, 2, 3,17 } }, + { 0, 1, { 18,18,-2,18, 2, 3, 4, 5, 6,18, 8, 2, 3, 7,-2, 4 } }, + { 0, 1, { 18,-2,18,18,-3,-2, 2, 3, 5, 8, 1, 2, 6, 4, 7,-1 } }, + { 0, 1, { 18,17, 2,18, 3,-2, 2, 7, 6, 4,18, 3, 8, 7, 4, 2 } }, + { 1, 1, { 17,18,18, 4, 2, 3, 7, 6,18, 8, 5,-1, 4, 2, 3,17 } }, + { 1, 1, { 18,17,18, 2, 5, 3,-2,18, 6, 2, 3, 4, 8, 7, 5,-1 } }, + { 0, 1, { 2,-1,18,-1, 2, 4,-3,18, 5, 3, 6,18, 2, 4, 7, 8 } }, + { 1, 1, { 17,18, 8, 3, 6, 4,-1, 5, 2, 7, 3, 8, 6, 5,18, 4 } }, + { 0, 2, { 18, 3,-2, 7, 8, 2, 5, 4,-3, 8, 3, 2,18, 5, 4, 6 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 1,18,-1, 8, 2, 6, 3,-2, 1, 2, 5, 4,-3, 8, 6, 3 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { 17,18,18, 4, 2, 7, 3, 6,-2,18, 8, 4, 5, 2, 7,17 } }, + { 1, 2, { 18,-1,18, 3,-2,18, 2, 5, 3, 6, 7, 2,-1,18, 8, 4 } }, + { 1, 2, { 1,18,-2, 4,18, 2, 3, 6,-1, 7, 5,-2,18, 8, 2, 4 } }, + { 1, 2, { 1,18,-3, 2, 3,18,-1, 5, 6, 2, 8, 3, 4, 1,-2, 7 } }, + { 0, 1, { 1,17,-1,18, 3, 2, 5, 4, 6, 7, 8, 3, 4, 2, 1,-2 } }, + { 1, 1, { 18,17,18, 4, 3, 5, 1, 2, 6, 3, 4, 7, 1, 8, 5, 2 } }, + { 0, 1, { 18,-2, 7, 1, 3, 2,-3, 4, 6,-2, 7, 8, 1, 5, 4, 3 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 2, { 18,18,18,-2, 2, 5, 3, 7,18, 2, 4,-3, 5, 6, 3, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 3, { 3,18,-1, 5, 2, 7,18, 6, 5, 2, 4, 3,-1, 7,18, 6 } }, + { 0, 2, { 18,18,18, 4, 3, 2, 6, 4, 8,18, 5, 3, 2, 7,-2, 6 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 2, { 18,18,18, 2, 3,-2,18, 5, 4, 2, 6, 8, 3,-2, 4,18 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 17, 8,18, 3, 2, 1, 5, 4, 6,-1, 3,-3, 8,18, 7, 2 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18,18, 2, 4, 6,-2, 2, 8, 3, 4,18, 7,-1, 6 } }, + { 0, 1, { 18, 1,-2, 2, 4, 1, 3,-1, 2, 5, 7, 1, 6, 8,-2,17 } }, + { 0, 1, { 17,17,18, 2, 5, 4,18, 3, 8, 7, 4, 6, 8, 1, 5, 2 } }, + { 1, 2, { 18,18, 5, 4, 6, 3, 4,18, 8, 4,-1, 7, 5, 3, 6, 2 } }, + { 0, 1, { 18,18,-3,18, 3, 6, 2, 5, 7,18, 3, 8,-1, 4, 5, 2 } }, + { 1, 1, { 18, 2,-2,-3,18, 5, 2,-2, 4, 3, 6,18, 8,-1, 2, 7 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 17, 1, 7, 2, 3,18,-2, 3, 6, 4, 2, 7, 8, 5, 3,17 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { 17,18, 3,18, 2, 5, 4, 7,-3, 6, 3, 2,18, 4, 7, 3 } }, + { 1, 1, { 1, 7, 4, 5, 3, 4, 5, 1, 3, 6, 3, 2, 4, 8,-2, 7 } }, + { 0, 1, { 1,18,-1,-2,18, 3, 2,-1, 6, 7, 4, 5, 3,18, 2,-3 } }, + { 1, 1, { 18,18,-1, 3, 6,18, 5, 4, 8, 2, 3, 6,18, 7, 4,-2 } }, + { 0, 2, { 18,18, 2, 6,18, 2,18, 5, 3,18, 2, 4, 7, 8, 3,18 } }, + { 1, 1, { 3,18,18, 5,18, 6, 2, 4, 7,-2,18, 5, 8, 6, 3, 2 } }, + { 0, 1, { 18,-2, 7, 1, 3, 2,-3, 4, 6,-2, 7, 8, 1, 5, 4, 3 } }, + { 1, 1, { 18,-2,18, 2, 5,18, 3,-2, 4, 7, 2,-1, 8, 6, 5, 1 } }, + { 1, 1, { 17,17, 5,18, 4, 1, 2, 8, 6, 4,-2, 3, 5,-1, 1, 8 } }, + { 0, 2, { 1, 2,17, 3, 7,18, 2,-1, 4, 5,18, 2, 7, 3, 6, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 3, 6,17, 8, 7, 5,18,-1, 1, 2, 3, 4, 2, 6, 8, 1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 2, { 18,18,18, 2,-2, 3, 6, 4, 8,18, 2, 5, 7, 4, 3, 6 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 18, 1, 8, 3, 5, 6, 4,-1, 8, 3, 7,18, 2, 5, 8, 4 } }, + { 1, 1, { 17,18, 5, 2, 4, 3, 1, 6,-2, 1, 3, 2, 4, 5,-1,17 } }, + { 1, 1, { 18,17, 2,18, 3,-3, 7, 2, 6, 4, 3, 5,18, 8, 2,-2 } }, + { 1, 1, { 18,17,18, 4, 3, 5,-1,18, 2, 7, 8, 4, 6, 3,18, 5 } }, + { 0, 1, { 18,17,18,-2, 2,-3, 3, 4, 8, 5, 2,18, 6, 3, 7,-2 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 17,18, 8, 3, 4, 6,18, 5,-2, 3, 8, 5, 2, 4, 7, 6 } }, + { 0, 1, { 18,-2, 3, 5, 1, 7, 3, 2, 6,-3, 4, 1, 5, 8, 3,-2 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 3,17,18, 5,-1,18, 2, 6, 7,18, 5, 3,-3,-1, 6, 2 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 3, { 18,17,-2, 3,-1,18, 2, 5, 3, 7, 6, 2, 4, 8,18, 5 } }, + { 0, 1, { 18,-1,18, 2,18, 3, 5,18, 2, 8,18, 5, 4,-1, 6, 2 } }, + { 1, 2, { 18,-2,18,18, 2, 3, 4,-3, 2, 5,18, 7, 4, 3, 8, 6 } }, + { 0, 2, { 17,-1,18, 2,-1, 1, 7, 3, 8, 5,-2, 4, 1, 2,-3, 6 } }, + { 0, 1, { 18,17, 2,18, 2,18, 6, 7, 4, 3,18, 5, 2,-2,17, 8 } }, + { 0, 3, { 18,17, 2, 3,-3,-1,18, 2, 4, 5,18, 7, 3, 2,-3, 6 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 2, { 3,18,18,18, 2, 6, 5,18, 7, 2, 4, 6,18, 5, 3, 8 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { 18,18, 3, 6, 3,-2, 2,18, 5,-1, 7, 3, 4,-2, 2, 6 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 1, 1, { 18,17,18,18,-2, 2, 3,-3,18, 6, 4, 2,-2, 8, 3, 7 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { 18,18,18, 4, 2, 7, 8,18, 3, 2,-2, 4, 7, 6,17, 5 } }, + { 1, 1, { 18,18,-1,-2, 8, 3,18, 6, 3, 5, 8, 2, 4, 7, 1, 6 } }, + { 1, 1, { 1,-3, 3,18,18, 2,-1, 3, 6, 5,18, 4, 7,-2, 8, 3 } }, + { 1, 1, { 1,18, 4, 2, 5,18, 1, 3,-1, 6, 1, 4, 8, 2, 5, 1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, + { 0, 1, { -1,18,18, 2,18, 3, 5,18, 2,18, 6, 8, 4, 5, 7,-1 } }, +}; + +static const WavPackDecorrSpec const *decorr_filters[] = { + &fast_specs[0], &default_specs[0], &high_specs[0], &very_high_specs[0], +}; + +static const uint16_t decorr_filter_sizes[] = { + FF_ARRAY_ELEMS(fast_specs), + FF_ARRAY_ELEMS(default_specs), + FF_ARRAY_ELEMS(high_specs), + FF_ARRAY_ELEMS(very_high_specs), +}; + +static const uint8_t decorr_filter_nterms[] = { 2, 5, 10, 16 }; + +static const int8_t nbits_table[] = { + 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 +}; + +#endif /* AVCODEC_WAVPACKENC_H */