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;
static av_always_inline int wp_exp2(int16_t val)
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static void wavpack_decode_flush(AVCodecContext *avctx)
struct WavpackFrameContext WavpackFrameContext
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
AVFrame * coded_frame
the picture in the bitstream
#define WV_FLT_SHIFT_SAME
#define AV_CH_LAYOUT_STEREO
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
static int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc, int S)
static int get_unary_0_33(GetBitContext *gb)
Get unary code terminated by a 0 with a maximum length of 33.
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
enum AVSampleFormat sample_fmt
audio sample format
AVCodec ff_wavpack_decoder
static av_always_inline int wp_log2(int32_t val)
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
bitstream reader API header.
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
static int init(AVCodecParserContext *s)
WavpackFrameContext * fdec[WV_MAX_FRAME_DECODERS]
struct WvChannel WvChannel
audio conversion routines
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
#define WV_FLT_SHIFT_ONES
static int get_bits_left(GetBitContext *gb)
struct WavpackContext WavpackContext
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
void av_log(void *avcl, int level, const char *fmt,...)
const char * name
Name of the codec implementation.
uint64_t channel_layout
Audio channel layout.
static int wavpack_decode_block(AVCodecContext *avctx, int block_no, void *data, int *got_frame_ptr, const uint8_t *buf, int buf_size)
static void wv_reset_saved_context(WavpackFrameContext *s)
static int wv_unpack_mono(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
#define UPDATE_WEIGHT_CLIP(weight, delta, samples, in)
struct SavedContext SavedContext
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
static av_cold int wavpack_decode_end(AVCodecContext *avctx)
main external API structure.
static void close(AVCodecParserContext *s)
static float wv_get_value_float(WavpackFrameContext *s, uint32_t *crc, int S)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static const uint8_t wp_log2_table[]
static unsigned int get_bits1(GetBitContext *s)
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static const uint8_t wp_exp2_table[256]
static int wavpack_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
#define WV_HYBRID_BITRATE
static int wv_get_value(WavpackFrameContext *ctx, GetBitContext *gb, int channel, int *last)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static av_always_inline int get_tail(GetBitContext *gb, int k)
#define WV_FLT_SHIFT_SENT
static int wv_unpack_stereo(WavpackFrameContext *s, GetBitContext *gb, void *dst, const int type)
common internal api header.
static av_cold void flush(AVCodecContext *avctx)
Flush (reset) the frame ID after seeking.
GetBitContext gb_extra_bits
int channels
number of audio channels
#define CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
void avcodec_get_frame_defaults(AVFrame *pic)
Set the fields of the given AVFrame to default values.
static av_cold int wv_alloc_frame_context(WavpackContext *c)
static av_cold int wavpack_decode_init(AVCodecContext *avctx)
#define WV_MAX_FRAME_DECODERS
#define AV_CH_LAYOUT_MONO
int nb_samples
number of audio samples (per channel) described by this frame
static void update_error_limit(WavpackFrameContext *ctx)