22 #define BITSTREAM_READER_LE
35 #define WV_MONO 0x00000004
36 #define WV_JOINT_STEREO 0x00000010
37 #define WV_FALSE_STEREO 0x40000000
39 #define WV_HYBRID_MODE 0x00000008
40 #define WV_HYBRID_SHAPE 0x00000008
41 #define WV_HYBRID_BITRATE 0x00000200
42 #define WV_HYBRID_BALANCE 0x00000400
44 #define WV_FLT_SHIFT_ONES 0x01
45 #define WV_FLT_SHIFT_SAME 0x02
46 #define WV_FLT_SHIFT_SENT 0x04
47 #define WV_FLT_ZERO_SENT 0x08
48 #define WV_FLT_ZERO_SIGN 0x10
126 #define WV_MAX_FRAME_DECODERS 14
144 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b,
145 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x16,
146 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x22, 0x23,
147 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
148 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x3b, 0x3c, 0x3d,
149 0x3e, 0x3f, 0x40, 0x41, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4a, 0x4b,
150 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
151 0x5b, 0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
152 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
153 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x87, 0x88, 0x89, 0x8a,
154 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
155 0x9c, 0x9d, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad,
156 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0,
157 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc8, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd3, 0xd4,
158 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xde, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe6, 0xe8, 0xe9,
159 0xea, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xff
163 0x00, 0x01, 0x03, 0x04, 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x14, 0x15,
164 0x16, 0x18, 0x19, 0x1a, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x24, 0x25, 0x26, 0x28, 0x29, 0x2a,
165 0x2c, 0x2d, 0x2e, 0x2f, 0x31, 0x32, 0x33, 0x34, 0x36, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3e,
166 0x3f, 0x41, 0x42, 0x43, 0x44, 0x45, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4d, 0x4e, 0x4f, 0x50, 0x51,
167 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63,
168 0x64, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x74, 0x75,
169 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85,
170 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
171 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4,
172 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb2,
173 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc0,
174 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce,
175 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xdb,
176 0xdc, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7,
177 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4,
178 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff
192 res = (val > 9) ? (res << (val - 9)) : (res >> (9 - val));
193 return neg ? -res : res;
205 bits = av_log2(val) + 1;
209 return (bits << 8) +
wp_log2_table[(val >> (bits - 9)) & 0xFF];
212 #define LEVEL_DECAY(a) ((a + 0x80) >> 8)
215 #define GET_MED(n) ((c->median[n] >> 4) + 1)
216 #define DEC_MED(n) c->median[n] -= ((c->median[n] + (128 >> n) - 2) / (128 >> n)) * 2
217 #define INC_MED(n) c->median[n] += ((c->median[n] + (128 >> n) ) / (128 >> n)) * 5
220 #define UPDATE_WEIGHT_CLIP(weight, delta, samples, in) \
221 if (samples && in) { \
222 if ((samples ^ in) < 0) { \
224 if (weight < -1024) \
241 e = (1 << (p + 1)) - k - 1;
258 int balance = (sl[1] - sl[0] + br[1] + 1) >> 1;
259 if (balance > br[0]) {
262 }
else if (-balance > br[0]) {
266 br[1] = br[0] + balance;
267 br[0] = br[0] - balance;
272 if (sl[i] - br[i] > -0x100)
283 int channel,
int *last)
286 int sign, base, add, ret;
304 t =
get_bits(gb, t - 1) | (1 << (t-1));
335 t +=
get_bits(gb, t2 - 1) | (1 << (t2 - 1));
349 if (ctx->
hybrid && !channel)
379 int mid = (base * 2 + add + 1) >> 1;
387 add = mid - base - 1;
388 mid = (base * 2 + add + 1) >> 1;
395 return sign ? ~ret : ret;
412 *crc = *crc * 9 + (S & 0xffff) * 3 + ((
unsigned)S >> 16);
416 bit = (S & s->
and) | s->
or;
417 bit = ((S + bit) << s->
shift) - bit;
436 const int max_bits = 1 + 23 + 8 + 1;
448 if (S >= 0x1000000) {
455 int shift = 23 - av_log2(S);
466 S |= (1 << shift) - 1;
492 *crc = *crc * 27 + S * 9 + exp * 3 + sign;
494 value.u = (sign << 31) | (exp << 23) |
S;
505 void *dst,
const int type)
509 int A,
B, L, L2,
R,
R2;
511 uint32_t crc = s->
sc.
crc;
513 int16_t *dst16 = dst;
514 int32_t *dst32 = dst;
526 for (i = 0; i < s->
terms; i++) {
556 }
else if (t == -1) {
594 L += (R -= (L >> 1));
595 crc = (crc * 3 + L) * 3 + R;
600 dstfl += channel_pad;
604 dst32 += channel_pad;
608 dst16 += channel_pad;
611 }
while (!last && count < s->
samples);
627 void *dst,
const int type)
633 uint32_t crc = s->
sc.
crc;
635 int16_t *dst16 = dst;
636 int32_t *dst32 = dst;
646 for (i = 0; i < s->
terms; i++) {
672 dstfl += channel_stride;
675 dst32 += channel_stride;
678 dst16 += channel_stride;
681 }
while (!last && count < s->
samples);
731 if (ver >= 0x402 && ver <= 0x410)
756 void *
data,
int *got_frame_ptr,
757 const uint8_t *buf,
int buf_size)
763 int got_terms = 0, got_weights = 0, got_samples = 0,
764 got_entropy = 0, got_bs = 0, got_float = 0, got_hybrid = 0;
765 const uint8_t *orig_buf = buf;
766 const uint8_t *buf_end = buf + buf_size;
767 int i, j,
id,
size, ssize, weights,
t;
768 int bpp, chan, chmask, orig_bpp;
780 s = wc->
fdec[block_no];
787 memset(s->
ch, 0,
sizeof(s->
ch));
806 samples = (uint8_t*)samples + bpp * wc->
ch_offset;
824 while (buf < buf_end) {
828 size |= (*buf++) << 8;
829 size |= (*buf++) << 16;
839 if (buf + ssize > buf_end) {
856 for (i = 0; i < s->
terms; i++) {
874 for (i = 0; i < weights; i++) {
875 t = (int8_t)(*buf++);
881 t = (int8_t)(*buf++);
896 for (i = s->
terms - 1; (i >= 0) && (t < size); i--) {
929 for (i = 0; i < 3; i++) {
944 for (i = 0; i < (s->
stereo_in + 1); i++) {
950 for (i = 0; i < (s->
stereo_in + 1); i++) {
962 av_log(avctx,
AV_LOG_ERROR,
"Invalid INT32INFO, size = %i, sent_bits = %i\n", size, *buf);
1029 case 0: chmask = *buf;
break;
1030 case 1: chmask =
AV_RL16(buf);
break;
1031 case 2: chmask =
AV_RL24(buf);
break;
1032 case 3: chmask =
AV_RL32(buf);
break;
1034 chan |= (buf[1] & 0xF) << 8;
1045 "Block reports total %d channels, "
1046 "decoder believes it's %d channels\n",
1057 if (
id & WP_IDF_ODD)
1077 if (s->
hybrid && !got_hybrid) {
1092 if (size < wanted) {
1106 if (samplecount < 0)
1111 const int channel_stride = avctx->
channels;
1120 if (samplecount < 0)
1124 int16_t *dst = (int16_t*)samples + 1;
1125 int16_t *src = (int16_t*)samples;
1126 int cnt = samplecount;
1129 src += channel_stride;
1130 dst += channel_stride;
1133 int32_t *dst = (int32_t*)samples + 1;
1134 int32_t *src = (int32_t*)samples;
1135 int cnt = samplecount;
1138 src += channel_stride;
1139 dst += channel_stride;
1142 float *dst = (
float*)samples + 1;
1143 float *src = (
float*)samples;
1144 int cnt = samplecount;
1147 src += channel_stride;
1148 dst += channel_stride;
1155 return samplecount * bpp;
1168 int *got_frame_ptr,
AVPacket *avpkt)
1171 const uint8_t *buf = avpkt->
data;
1172 int buf_size = avpkt->
size;
1173 int frame_size, ret, frame_flags;
1174 int samplecount = 0;
1189 frame_flags =
AV_RL32(buf + 8);
1192 frame_flags =
AV_RL32(buf + 4);
1201 if (frame_flags & 0x80) {
1203 }
else if ((frame_flags & 0x03) <= 1) {
1216 while (buf_size > 0) {
1218 frame_size = buf_size;
1221 frame_size =
AV_RL32(buf) - 12; buf += 4; buf_size -= 4;
1225 frame_size =
AV_RL32(buf + 8) + 12;
1228 if (frame_size < 0 || frame_size > buf_size) {
1230 "vs. %d bytes left)\n", s->
block, frame_size, buf_size);
1236 buf, frame_size)) < 0) {
1241 buf += frame_size; buf_size -= frame_size;