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) {
static av_always_inline int wp_exp2(int16_t val)
This structure describes decoded (raw) audio or video data.
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
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
#define WV_FLT_SHIFT_SAME
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
#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
static const uint8_t frame_size[4]
#define WV_FLT_SHIFT_ONES
static int get_bits_left(GetBitContext *gb)
struct WavpackContext WavpackContext
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
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)
audio channel layout utility functions
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
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)
Get a buffer for a frame.
#define CODEC_CAP_SUBFRAMES
#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_always_inline int bytestream2_tell(GetByteContext *g)
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)
static const uint8_t wp_log2_table[]
static unsigned int get_bits1(GetBitContext *s)
void avcodec_get_frame_defaults(AVFrame *frame)
Set the fields of the given AVFrame to default values.
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static const uint8_t wp_exp2_table[256]
#define FF_INPUT_BUFFER_PADDING_SIZE
static int wavpack_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
static int wv_check_crc(WavpackFrameContext *s, uint32_t crc, uint32_t crc_extra_bits)
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.
#define AVERROR_INVALIDDATA
GetBitContext gb_extra_bits
int channels
number of audio channels
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
This structure stores compressed data.
int nb_samples
number of audio samples (per channel) described by this frame
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
static void update_error_limit(WavpackFrameContext *ctx)