22 #define BITSTREAM_READER_LE
36 #define WV_MONO 0x00000004
37 #define WV_JOINT_STEREO 0x00000010
38 #define WV_FALSE_STEREO 0x40000000
40 #define WV_HYBRID_MODE 0x00000008
41 #define WV_HYBRID_SHAPE 0x00000008
42 #define WV_HYBRID_BITRATE 0x00000200
43 #define WV_HYBRID_BALANCE 0x00000400
45 #define WV_FLT_SHIFT_ONES 0x01
46 #define WV_FLT_SHIFT_SAME 0x02
47 #define WV_FLT_SHIFT_SENT 0x04
48 #define WV_FLT_ZERO_SENT 0x08
49 #define WV_FLT_ZERO_SIGN 0x10
127 #define WV_MAX_FRAME_DECODERS 14
145 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
146 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
147 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
148 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
149 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
150 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
151 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
152 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
153 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
154 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
155 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
156 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
157 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
158 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
159 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
160 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
164 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
165 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
166 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
167 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
168 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
169 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
170 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
171 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
172 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
173 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
174 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
175 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
176 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
177 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
178 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
179 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
193 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
194 return neg ? -res : res;
210 return (bits << 8) +
wp_log2_table[(val >> (bits - 9)) & 0xFF];
213 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
216 #define GET_MED(n) ((c->median[n] >> 4) + 1)
217 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> n) - 2) / (128 >> n)) * 2
218 #define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> n) ) / (128 >> n)) * 5
221 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
222 if (samples && in) { \
223 if ((samples ^ in) < 0) { \
225 if (weight < -1024) \
242 e = (1 << (p + 1)) - k - 1;
259 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
260 if (balance > br[0]) {
263 }
else if (-balance > br[0]) {
267 br[1] = br[0] + balance;
268 br[0] = br[0] - balance;
273 if (sl[i] - br[i] > -0x100)
284 int channel,
int *last)
287 int sign, base, add, ret;
305 t =
get_bits(gb, t - 1) | (1 << (t-1));
336 t +=
get_bits(gb, t2 - 1) | (1 << (t2 - 1));
350 if (ctx->
hybrid && !channel)
380 int mid = (base * 2 + add + 1) >> 1;
388 add = mid - base - 1;
389 mid = (base * 2 + add + 1) >> 1;
396 return sign ? ~ret : ret;
413 *crc = *crc * 9 + (S & 0xffff) * 3 + ((
unsigned)S >> 16);
417 bit = (S & s->
and) | s->
or;
418 bit = ((S + bit) << s->
shift) - bit;
437 const int max_bits = 1 + 23 + 8 + 1;
449 if (S >= 0x1000000) {
467 S |= (1 << shift) - 1;
493 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
495 value.u = (sign << 31) | (exp << 23) | S;
506 uint32_t crc_extra_bits)
521 void *dst,
const int type)
527 uint32_t crc = s->
sc.
crc;
529 int16_t *dst16 = dst;
542 for (i = 0; i < s->
terms; i++) {
572 }
else if (t == -1) {
610 L += (R -= (L >> 1));
611 crc = (crc * 3 +
L) * 3 + R;
616 dstfl += channel_pad;
620 dst32 += channel_pad;
624 dst16 += channel_pad;
627 }
while (!last && count < s->
samples);
638 void *dst,
const int type)
644 uint32_t crc = s->
sc.
crc;
646 int16_t *dst16 = dst;
657 for (i = 0; i < s->
terms; i++) {
683 dstfl += channel_stride;
686 dst32 += channel_stride;
689 dst16 += channel_stride;
692 }
while (!last && count < s->
samples);
737 if (ver >= 0x402 && ver <= 0x410)
762 void *
data,
int *got_frame_ptr,
763 const uint8_t *buf,
int buf_size)
770 int got_terms = 0, got_weights = 0, got_samples = 0,
771 got_entropy = 0, got_bs = 0, got_float = 0, got_hybrid = 0;
772 int i, j,
id,
size, ssize, weights,
t;
773 int bpp, chan, chmask, orig_bpp;
785 s = wc->
fdec[block_no];
792 memset(s->
ch, 0,
sizeof(s->
ch));
800 s->
samples = bytestream2_get_le32(&gb);
824 s->
CRC = bytestream2_get_le32(&gb);
832 id = bytestream2_get_byte(&gb);
833 size = bytestream2_get_byte(&gb);
835 size |= (bytestream2_get_byte(&gb)) << 8;
836 size |= (bytestream2_get_byte(&gb)) << 16;
848 "Block size %i is out of bounds\n", size);
864 for (i = 0; i < s->
terms; i++) {
865 uint8_t val = bytestream2_get_byte(&gb);
882 for (i = 0; i < weights; i++) {
883 t = (int8_t)bytestream2_get_byte(&gb);
889 t = (int8_t)bytestream2_get_byte(&gb);
904 for (i = s->
terms - 1; (i >= 0) && (t < size); i--) {
907 wp_exp2(bytestream2_get_le16(&gb));
909 wp_exp2(bytestream2_get_le16(&gb));
913 wp_exp2(bytestream2_get_le16(&gb));
915 wp_exp2(bytestream2_get_le16(&gb));
921 wp_exp2(bytestream2_get_le16(&gb));
923 wp_exp2(bytestream2_get_le16(&gb));
928 wp_exp2(bytestream2_get_le16(&gb));
931 wp_exp2(bytestream2_get_le16(&gb));
942 "Entropy vars size should be %i, got %i",
948 for (i = 0; i < 3; i++) {
961 for (i = 0; i < (s->
stereo_in + 1); i++) {
966 for (i = 0; i < (s->
stereo_in + 1); i++) {
968 wp_exp2((int16_t)bytestream2_get_le16(&gb));
980 "Invalid INT32INFO, size = %i\n",
1011 "Invalid FLOATINFO, size = %i\n", size);
1048 chan = bytestream2_get_byte(&gb);
1051 chmask = bytestream2_get_byte(&gb);
1054 chmask = bytestream2_get_le16(&gb);
1057 chmask = bytestream2_get_le24(&gb);
1060 chmask = bytestream2_get_le32(&gb);;
1064 chan |= (bytestream2_get_byte(&gb) & 0xF) << 8;
1065 chmask = bytestream2_get_le16(&gb);
1075 "Block reports total %d channels, "
1076 "decoder believes it's %d channels\n",
1086 if (
id & WP_IDF_ODD)
1106 if (s->
hybrid && !got_hybrid) {
1121 if (size < wanted) {
1135 if (samplecount < 0)
1140 const int channel_stride = avctx->
channels;
1149 if (samplecount < 0)
1153 int16_t *dst = (int16_t*)samples + 1;
1154 int16_t *src = (int16_t*)samples;
1155 int cnt = samplecount;
1158 src += channel_stride;
1159 dst += channel_stride;
1164 int cnt = samplecount;
1167 src += channel_stride;
1168 dst += channel_stride;
1171 float *dst = (
float*)samples + 1;
1172 float *src = (
float*)samples;
1173 int cnt = samplecount;
1176 src += channel_stride;
1177 dst += channel_stride;
1184 return samplecount * bpp;
1197 int *got_frame_ptr,
AVPacket *avpkt)
1201 int buf_size = avpkt->
size;
1203 int samplecount = 0;
1218 frame_flags =
AV_RL32(buf + 8);
1221 frame_flags =
AV_RL32(buf + 4);
1230 if (frame_flags & 0x80) {
1232 }
else if ((frame_flags & 0x03) <= 1) {
1246 while (buf_size > 0) {
1248 frame_size = buf_size;
1251 frame_size =
AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1255 frame_size =
AV_RL32(buf + 8) + 12;
1258 if (frame_size < 0 || frame_size > buf_size) {
1260 "vs. %d bytes left)\n", s->
block, frame_size, buf_size);
1266 buf, frame_size)) < 0) {