22 #define BITSTREAM_READER_LE
34 #define WV_MONO 0x00000004
35 #define WV_JOINT_STEREO 0x00000010
36 #define WV_FALSE_STEREO 0x40000000
38 #define WV_HYBRID_MODE 0x00000008
39 #define WV_HYBRID_SHAPE 0x00000008
40 #define WV_HYBRID_BITRATE 0x00000200
41 #define WV_HYBRID_BALANCE 0x00000400
43 #define WV_FLT_SHIFT_ONES 0x01
44 #define WV_FLT_SHIFT_SAME 0x02
45 #define WV_FLT_SHIFT_SENT 0x04
46 #define WV_FLT_ZERO_SENT 0x08
47 #define WV_FLT_ZERO_SIGN 0x10
125 #define WV_MAX_FRAME_DECODERS 14
143 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
144 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
145 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
146 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
147 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
148 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
149 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
150 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
151 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
152 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
153 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
154 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
155 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
156 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
157 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
158 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
162 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
163 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
164 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
165 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
166 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
167 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
168 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
169 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
170 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
171 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
172 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
173 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
174 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
175 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
176 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
177 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
191 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
192 return neg ? -res : res;
204 bits = av_log2(val) + 1;
208 return (bits << 8) +
wp_log2_table[(val >> (bits - 9)) & 0xFF];
211 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
214 #define GET_MED(n) ((c->median[n] >> 4) + 1)
215 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> n) - 2) / (128 >> n)) * 2
216 #define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> n) ) / (128 >> n)) * 5
219 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
220 if (samples && in) { \
221 if ((samples ^ in) < 0) { \
223 if (weight < -1024) \
240 e = (1 << (p + 1)) - k - 1;
257 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
258 if (balance > br[0]) {
261 }
else if (-balance > br[0]) {
265 br[1] = br[0] + balance;
266 br[0] = br[0] - balance;
271 if (sl[i] - br[i] > -0x100)
282 int channel,
int *last)
285 int sign, base, add, ret;
303 t =
get_bits(gb, t - 1) | (1 << (t-1));
334 t +=
get_bits(gb, t2 - 1) | (1 << (t2 - 1));
348 if (ctx->
hybrid && !channel)
378 int mid = (base * 2 + add + 1) >> 1;
386 add = mid - base - 1;
387 mid = (base * 2 + add + 1) >> 1;
394 return sign ? ~ret : ret;
411 *crc = *crc * 9 + (S & 0xffff) * 3 + ((
unsigned)S >> 16);
415 bit = (S & s->
and) | s->
or;
416 bit = ((S + bit) << s->
shift) - bit;
435 const int max_bits = 1 + 23 + 8 + 1;
447 if (S >= 0x1000000) {
454 int shift = 23 - av_log2(S);
465 S |= (1 << shift) - 1;
491 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
493 value.u = (sign << 31) | (exp << 23) |
S;
504 void *dst,
const int type)
508 int A,
B, L, L2,
R,
R2;
510 uint32_t crc = s->
sc.
crc;
512 int16_t *dst16 = dst;
513 int32_t *dst32 = dst;
525 for (i = 0; i < s->
terms; i++) {
555 }
else if (t == -1) {
593 L += (R -= (L >> 1));
594 crc = (crc * 3 + L) * 3 + R;
599 dstfl += channel_pad;
603 dst32 += channel_pad;
607 dst16 += channel_pad;
610 }
while (!last && count < s->
samples);
626 void *dst,
const int type)
632 uint32_t crc = s->
sc.
crc;
634 int16_t *dst16 = dst;
635 int32_t *dst32 = dst;
645 for (i = 0; i < s->
terms; i++) {
671 dstfl += channel_stride;
674 dst32 += channel_stride;
677 dst16 += channel_stride;
680 }
while (!last && count < s->
samples);
730 if (ver >= 0x402 && ver <= 0x410)
755 void *
data,
int *got_frame_ptr,
756 const uint8_t *buf,
int buf_size)
762 int got_terms = 0, got_weights = 0, got_samples = 0,
763 got_entropy = 0, got_bs = 0, got_float = 0, got_hybrid = 0;
764 const uint8_t *orig_buf = buf;
765 const uint8_t *buf_end = buf + buf_size;
766 int i, j,
id,
size, ssize, weights,
t;
767 int bpp, chan, chmask, orig_bpp;
779 s = wc->
fdec[block_no];
786 memset(s->
ch, 0,
sizeof(s->
ch));
802 samples = (uint8_t*)samples + bpp * wc->
ch_offset;
820 while (buf < buf_end) {
824 size |= (*buf++) << 8;
825 size |= (*buf++) << 16;
835 if (buf + ssize > buf_end) {
852 for (i = 0; i < s->
terms; i++) {
870 for (i = 0; i < weights; i++) {
871 t = (int8_t)(*buf++);
877 t = (int8_t)(*buf++);
892 for (i = s->
terms - 1; (i >= 0) && (t < size); i--) {
925 for (i = 0; i < 3; i++) {
940 for (i = 0; i < (s->
stereo_in + 1); i++) {
946 for (i = 0; i < (s->
stereo_in + 1); i++) {
958 av_log(avctx,
AV_LOG_ERROR,
"Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
1025 case 0: chmask = *buf;
break;
1026 case 1: chmask =
AV_RL16(buf);
break;
1027 case 2: chmask =
AV_RL24(buf);
break;
1028 case 3: chmask =
AV_RL32(buf);
break;
1030 chan |= (buf[1] & 0xF) << 8;
1041 "decoder believes it's %d channels\n", chan,
1052 if (
id & WP_IDF_ODD)
1072 if (s->
hybrid && !got_hybrid) {
1087 if (size < wanted) {
1101 if (samplecount < 0)
1106 const int channel_stride = avctx->
channels;
1115 if (samplecount < 0)
1119 int16_t *dst = (int16_t*)samples + 1;
1120 int16_t *src = (int16_t*)samples;
1121 int cnt = samplecount;
1124 src += channel_stride;
1125 dst += channel_stride;
1128 int32_t *dst = (int32_t*)samples + 1;
1129 int32_t *src = (int32_t*)samples;
1130 int cnt = samplecount;
1133 src += channel_stride;
1134 dst += channel_stride;
1137 float *dst = (
float*)samples + 1;
1138 float *src = (
float*)samples;
1139 int cnt = samplecount;
1142 src += channel_stride;
1143 dst += channel_stride;
1150 return samplecount * bpp;
1163 int *got_frame_ptr,
AVPacket *avpkt)
1166 const uint8_t *buf = avpkt->
data;
1167 int buf_size = avpkt->
size;
1168 int frame_size, ret, frame_flags;
1169 int samplecount = 0;
1181 frame_flags =
AV_RL32(buf + 8);
1184 frame_flags =
AV_RL32(buf + 4);
1193 if (frame_flags & 0x80) {
1195 }
else if ((frame_flags & 0x03) <= 1) {
1208 while (buf_size > 0) {
1210 frame_size = buf_size;
1213 frame_size =
AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1217 frame_size =
AV_RL32(buf + 8) + 12;
1220 if (frame_size < 0 || frame_size > buf_size) {
1222 "vs. %d bytes left)\n", s->
block, frame_size, buf_size);
1228 buf, frame_size)) < 0) {
1233 buf += frame_size; buf_size -= frame_size;