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));
805 samples = (uint8_t*)samples + bpp * wc->
ch_offset;
823 while (buf < buf_end) {
827 size |= (*buf++) << 8;
828 size |= (*buf++) << 16;
838 if (buf + ssize > buf_end) {
855 for (i = 0; i < s->
terms; i++) {
873 for (i = 0; i < weights; i++) {
874 t = (int8_t)(*buf++);
880 t = (int8_t)(*buf++);
895 for (i = s->
terms - 1; (i >= 0) && (t < size); i--) {
928 for (i = 0; i < 3; i++) {
943 for (i = 0; i < (s->
stereo_in + 1); i++) {
949 for (i = 0; i < (s->
stereo_in + 1); i++) {
961 av_log(avctx,
AV_LOG_ERROR,
"Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
1028 case 0: chmask = *buf;
break;
1029 case 1: chmask =
AV_RL16(buf);
break;
1030 case 2: chmask =
AV_RL24(buf);
break;
1031 case 3: chmask =
AV_RL32(buf);
break;
1033 chan |= (buf[1] & 0xF) << 8;
1044 "Block reports total %d channels, "
1045 "decoder believes it's %d channels\n",
1056 if (
id & WP_IDF_ODD)
1076 if (s->
hybrid && !got_hybrid) {
1091 if (size < wanted) {
1105 if (samplecount < 0)
1110 const int channel_stride = avctx->
channels;
1119 if (samplecount < 0)
1123 int16_t *dst = (int16_t*)samples + 1;
1124 int16_t *src = (int16_t*)samples;
1125 int cnt = samplecount;
1128 src += channel_stride;
1129 dst += channel_stride;
1132 int32_t *dst = (int32_t*)samples + 1;
1133 int32_t *src = (int32_t*)samples;
1134 int cnt = samplecount;
1137 src += channel_stride;
1138 dst += channel_stride;
1141 float *dst = (
float*)samples + 1;
1142 float *src = (
float*)samples;
1143 int cnt = samplecount;
1146 src += channel_stride;
1147 dst += channel_stride;
1154 return samplecount * bpp;
1167 int *got_frame_ptr,
AVPacket *avpkt)
1170 const uint8_t *buf = avpkt->
data;
1171 int buf_size = avpkt->
size;
1172 int frame_size, ret, frame_flags;
1173 int samplecount = 0;
1188 frame_flags =
AV_RL32(buf + 8);
1191 frame_flags =
AV_RL32(buf + 4);
1200 if (frame_flags & 0x80) {
1202 }
else if ((frame_flags & 0x03) <= 1) {
1215 while (buf_size > 0) {
1217 frame_size = buf_size;
1220 frame_size =
AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1224 frame_size =
AV_RL32(buf + 8) + 12;
1227 if (frame_size < 0 || frame_size > buf_size) {
1229 "vs. %d bytes left)\n", s->
block, frame_size, buf_size);
1235 buf, frame_size)) < 0) {
1240 buf += frame_size; buf_size -= frame_size;