42 #define MAX_CHANNELS 2 43 #define MAX_BYTESPERSAMPLE 3 45 #define APE_FRAMECODE_MONO_SILENCE 1 46 #define APE_FRAMECODE_STEREO_SILENCE 3 47 #define APE_FRAMECODE_PSEUDO_STEREO 4 49 #define HISTORY_SIZE 512 50 #define PREDICTOR_ORDER 8 52 #define PREDICTOR_SIZE 50 54 #define YDELAYA (18 + PREDICTOR_ORDER*4) 55 #define YDELAYB (18 + PREDICTOR_ORDER*3) 56 #define XDELAYA (18 + PREDICTOR_ORDER*2) 57 #define XDELAYB (18 + PREDICTOR_ORDER) 59 #define YADAPTCOEFFSA 18 60 #define XADAPTCOEFFSA 14 61 #define YADAPTCOEFFSB 10 62 #define XADAPTCOEFFSB 5 77 #define APE_FILTER_LEVELS 3 129 uint32_t coeffsA[2][4];
130 uint32_t coeffsB[2][5];
144 uint64_t coeffsA[2][4];
145 uint64_t coeffsB[2][5];
260 "%d bits per coded sample", s->
bps);
327 #define TOP_VALUE ((unsigned int)1 << (CODE_BITS-1)) 328 #define SHIFT_BITS (CODE_BITS - 9) 329 #define EXTRA_BITS ((CODE_BITS-2) % 8 + 1) 330 #define BOTTOM_VALUE (TOP_VALUE >> 8) 403 #define MODEL_ELEMENTS 64 409 0, 14824, 28224, 39348, 47855, 53994, 58171, 60926,
410 62682, 63786, 64463, 64878, 65126, 65276, 65365, 65419,
411 65450, 65469, 65480, 65487, 65491, 65493,
418 14824, 13400, 11124, 8507, 6139, 4177, 2755, 1756,
419 1104, 677, 415, 248, 150, 89, 54, 31,
427 0, 19578, 36160, 48417, 56323, 60899, 63265, 64435,
428 64971, 65232, 65351, 65416, 65447, 65466, 65476, 65482,
429 65485, 65488, 65490, 65491, 65492, 65493,
436 19578, 16582, 12257, 7906, 4576, 2366, 1170, 536,
437 261, 119, 65, 31, 19, 10, 6, 3,
448 const uint16_t counts[],
449 const uint16_t counts_diff[])
456 symbol= cf - 65535 + 63;
463 for (symbol = 0; counts[symbol + 1] <= cf; symbol++);
473 int lim = rice->
k ? (1 << (rice->
k + 4)) : 0;
474 rice->
ksum += ((x + 1) / 2) - ((rice->
ksum + 16) >> 5);
476 if (rice->
ksum < lim)
478 else if (rice->
ksum >= (1 << (rice->
k + 5)) && rice->
k < 24)
502 while (overflow >= 16) {
511 x = (overflow << rice->
k) +
get_bits(gb, rice->
k);
517 rice->
ksum += x - (rice->
ksum + 8 >> 4);
518 if (rice->
ksum < (rice->
k ? 1 << (rice->
k + 4) : 0))
520 else if (rice->
ksum >= (1 << (rice->
k + 5)) && rice->
k < 24)
524 return ((x >> 1) ^ ((x & 1) - 1)) + 1;
538 tmpk = (rice->
k < 1) ? 0 : rice->
k - 1;
546 }
else if (tmpk <= 31) {
553 x += overflow << tmpk;
558 return ((x >> 1) ^ ((x & 1) - 1)) + 1;
575 if (pivot < 0x10000) {
579 int base_hi = pivot, base_lo;
582 while (base_hi & ~0xFFFF) {
591 base = (base_hi << bbits) + base_lo;
594 x = base + overflow * pivot;
599 return ((x >> 1) ^ ((x & 1) - 1)) + 1;
611 unsigned ksummax, ksummin;
614 for (i = 0; i <
FFMIN(blockstodecode, 5); i++) {
616 rice->
ksum += out[
i];
619 if (blockstodecode <= 5)
625 for (; i <
FFMIN(blockstodecode, 64); i++) {
627 rice->
ksum += out[
i];
633 if (blockstodecode <= 64)
637 ksummax = 1 << rice->
k + 7;
638 ksummin = rice->
k ? (1 << rice->
k + 6) : 0;
639 for (; i < blockstodecode; i++) {
645 rice->
ksum += out[
i] - (unsigned)out[i - 64];
646 while (rice->
ksum < ksummin) {
648 ksummin = rice->
k ? ksummin >> 1 : 0;
651 while (rice->
ksum >= ksummax) {
656 ksummin = ksummin ? ksummin << 1 : 128;
661 for (i = 0; i < blockstodecode; i++)
662 out[i] = ((out[i] >> 1) ^ ((out[
i] & 1) - 1)) + 1;
683 while (blockstodecode--)
691 int blocks = blockstodecode;
693 while (blockstodecode--)
703 while (blockstodecode--)
711 int blocks = blockstodecode;
713 while (blockstodecode--)
728 while (blockstodecode--) {
738 while (blockstodecode--)
747 while (blockstodecode--) {
759 ctx->
CRC = bytestream_get_be32(&ctx->
ptr);
768 ctx->
CRC &= ~0x80000000;
865 return (x < 0) - (x > 0);
881 predictionA = p->
buf[delayA] * 2
U - p->
buf[delayA - 1];
884 if ((decoded ^ predictionA) > 0)
896 const int delayA,
const int delayB,
897 const int start,
const int shift)
899 int32_t predictionA, predictionB, sign;
912 d1 = (p->
buf[delayA] - p->
buf[delayA - 1]) * 2
U;
913 d0 = p->
buf[delayA] + ((p->
buf[delayA - 2] - p->
buf[delayA - 1]) * 8
U);
914 d3 = p->
buf[delayB] * 2
U - p->
buf[delayB - 1];
948 memset(coeffs, 0, order *
sizeof(*coeffs));
949 for (i = 0; i < order; i++)
950 delay[i] = buffer[i];
951 for (i = order; i <
length; i++) {
954 for (j = 0; j < order; j++) {
955 dotprod += delay[j] * (unsigned)coeffs[j];
956 coeffs[j] += ((delay[j] >> 31) | 1) * sign;
958 buffer[
i] -= dotprod >>
shift;
959 for (j = 0; j < order - 1; j++)
960 delay[j] = delay[j + 1];
961 delay[order - 1] = buffer[
i];
970 uint32_t
coeffs[8] = { 0 };
972 for (i = 0; i <
length; i++) {
975 for (j = 7; j >= 0; j--) {
976 dotprod += delay[j] * coeffs[j];
977 coeffs[j] += ((delay[j] >> 31) | 1) * sign;
979 for (j = 7; j > 0; j--)
980 delay[j] = delay[j - 1];
981 delay[0] = buffer[
i];
982 buffer[
i] -= dotprod >> 9;
991 int start = 4,
shift = 10;
998 int order = 128,
shift2 = 11;
1013 int X = *decoded0,
Y = *decoded1;
1045 int start = 4,
shift = 10;
1051 int order = 128,
shift2 = 11;
1094 d0 = p->
buf[delayA ];
1095 d1 = p->
buf[delayA ] - p->
buf[delayA - 1];
1096 d2 = p->
buf[delayA - 1] - p->
buf[delayA - 2];
1097 d3 = p->
buf[delayA - 2] - p->
buf[delayA - 3];
1126 int Y = *decoded1,
X = *decoded0;
1168 const int delayA,
const int delayB,
1169 const int adaptA,
const int adaptB)
1171 int64_t predictionA, predictionB;
1176 p->
buf[delayA - 1] = p->
buf[delayA] - (uint64_t)p->
buf[delayA - 1];
1185 p->
buf[delayB] = p->
filterA[filter ^ 1] - ((int64_t)(p->
filterB[filter] * 31ULL) >> 5);
1187 p->
buf[delayB - 1] = p->
buf[delayB] - (uint64_t)p->
buf[delayB - 1];
1197 p->
lastA[
filter] = decoded + ((int64_t)((uint64_t)predictionA + (predictionB >> 1)) >> 10);
1247 int32_t predictionA, currentA,
A, sign;
1251 currentA = p->
lastA[0];
1264 currentA = A + (uint64_t)(predictionA >> 10);
1284 p->
filterA[0] = currentA + (uint64_t)((int64_t)(p->
filterA[0] * 31
U) >> 5);
1285 *(decoded0++) = p->
filterA[0];
1288 p->
lastA[0] = currentA;
1321 res = (int64_t)(res + (1LL << (fracbits - 1))) >> fracbits;
1322 res += (unsigned)*data;
1328 if (version < 3980) {
1330 f->
adaptcoeffs[0] = (res == 0) ? 0 : ((res >> 28) & 8) - 4;
1340 (8 << ((absres > f->
avg * 3) + (absres > f->
avg * 4 / 3)));
1352 f->
avg += (
int)(absres - (
unsigned)f->
avg) / 16;
1373 int count,
int order,
int fracbits)
1433 unsigned left, right;
1452 left = *decoded1 - (unsigned)(*decoded0 / 2);
1453 right = left + *decoded0;
1455 *(decoded0++) = left;
1456 *(decoded1++) = right;
1461 int *got_frame_ptr,
AVPacket *avpkt)
1471 uint64_t decoded_buffer_size;
1478 uint32_t nblocks,
offset;
1485 if (avpkt->
size < 8) {
1489 buf_size = avpkt->
size & ~3;
1490 if (buf_size != avpkt->
size) {
1492 "extra bytes at the end will be skipped.\n");
1501 memset(s->
data + (buf_size & ~3), 0, buf_size & 3);
1505 nblocks = bytestream_get_be32(&s->
ptr);
1506 offset = bytestream_get_be32(&s->
ptr);
1528 if (!nblocks || nblocks > INT_MAX / 2 /
sizeof(*s->
decoded_buffer) - 8) {
1587 for (ch = 0; ch < s->
channels; ch++) {
1589 for (i = 0; i < blockstodecode; i++)
1590 *sample8++ = (s->
decoded[ch][i] + 0x80) & 0xff;
1594 for (ch = 0; ch < s->
channels; ch++) {
1595 sample16 = (int16_t *)frame->
data[ch];
1596 for (i = 0; i < blockstodecode; i++)
1597 *sample16++ = s->
decoded[ch][i];
1601 for (ch = 0; ch < s->
channels; ch++) {
1603 for (i = 0; i < blockstodecode; i++)
1604 *sample24++ = s->
decoded[ch][i] * 256
U;
1615 for (i = 0; i < blockstodecode; i++) {
1616 for (ch = 0; ch < s->
channels; ch++) {
1618 crc =
av_crc(crc_tab, crc, smp, s->
bps >> 3);
1624 "frames may have been affected as well.\n");
1643 #define OFFSET(x) offsetof(APEContext, x) 1644 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM) 1647 {
"all",
"no maximum. decode all samples for each packet at once", 0,
AV_OPT_TYPE_CONST, { .i64 = INT_MAX }, INT_MIN, INT_MAX,
PAR,
"max_samples" },
static int init_frame_decoder(APEContext *ctx)
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
static const int32_t initial_coeffs_3930[4]
uint64_t coeffsB[2][5]
adaption coefficients
static void decode_array_0000(APEContext *ctx, GetBitContext *gb, int32_t *out, APERice *rice, int blockstodecode)
int compression_level
compression levels
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static int shift(int a, int b)
This structure describes decoded (raw) audio or video data.
static void range_start_decoding(APEContext *ctx)
Start the decoder.
ptrdiff_t const GLvoid * data
static void flush(AVCodecContext *avctx)
static void apply_filter(APEContext *ctx, APEFilter *f, int32_t *data0, int32_t *data1, int count, int order, int fracbits)
int fileversion
codec version, very important in decoding process
uint64_t coeffsA[2][4]
adaption coefficients
static void entropy_decode_stereo_0000(APEContext *ctx, int blockstodecode)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define LIBAVUTIL_VERSION_INT
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
void(* entropy_decode_mono)(struct APEContext *ctx, int blockstodecode)
static av_cold int init(AVCodecContext *avctx)
#define avpriv_request_sample(...)
void(* entropy_decode_stereo)(struct APEContext *ctx, int blockstodecode)
static int APESIGN(int32_t x)
Get inverse sign of integer (-1 for positive, 1 for negative and 0 for zero)
static void update_rice(APERice *rice, unsigned int x)
APEPredictor64 predictor64
64bit predictor used for final reconstruction
static void entropy_decode_stereo_3900(APEContext *ctx, int blockstodecode)
const char * av_default_item_name(void *ptr)
Return the context name.
static av_cold int ape_decode_init(AVCodecContext *avctx)
unsigned int buffer
buffer for input/output
static void long_filter_high_3800(int32_t *buffer, int order, int shift, int length)
static int init_entropy_decoder(APEContext *ctx)
static void ape_flush(AVCodecContext *avctx)
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
static void entropy_decode_stereo_3930(APEContext *ctx, int blockstodecode)
static int get_k(int ksum)
static av_always_inline int predictor_update_3930(APEPredictor *p, const int decoded, const int filter, const int delayA)
#define AV_CH_LAYOUT_STEREO
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Undefined Behavior In the C some operations are like signed integer overflow
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
int16_t * filterbuf[APE_FILTER_LEVELS]
filter memory
static void predictor_decode_mono_3800(APEContext *ctx, int count)
uint32_t CRC_state
accumulated CRC
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static int ape_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
enum AVSampleFormat sample_fmt
audio sample format
int16_t * delay
filtered values
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
static void do_init_filter(APEFilter *f, int16_t *buf, int order)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
static const int32_t initial_coeffs_a_3800[3]
static void entropy_decode_stereo_3860(APEContext *ctx, int blockstodecode)
static void entropy_decode_mono_3990(APEContext *ctx, int blockstodecode)
static void ape_unpack_mono(APEContext *ctx, int count)
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
APERangecoder rc
rangecoder used to decode actual values
Public header for CRC hash function implementation.
static const uint8_t ape_filter_fracbits[5][APE_FILTER_LEVELS]
Filter fraction bits depending on compression level.
static void ape_apply_filters(APEContext *ctx, int32_t *decoded0, int32_t *decoded1, int count)
bitstream reader API header.
#define AV_LOG_VERBOSE
Detailed information.
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
static const int64_t initial_coeffs_3930_64bit[4]
static const uint16_t counts_3970[22]
Fixed probabilities for symbols in Monkey Audio version 3.97.
static void range_dec_normalize(APEContext *ctx)
Perform normalization.
static int get_bits_left(GetBitContext *gb)
static const uint16_t counts_diff_3980[21]
Probability ranges for symbols in Monkey Audio version 3.98.
void(* predictor_decode_mono)(struct APEContext *ctx, int count)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
static av_cold int ape_decode_close(AVCodecContext *avctx)
static av_always_inline int predictor_update_filter(APEPredictor64 *p, const int decoded, const int filter, const int delayA, const int delayB, const int adaptA, const int adaptB)
static int ape_decode_value_3900(APEContext *ctx, APERice *rice)
int32_t historybuffer[HISTORY_SIZE+PREDICTOR_SIZE]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
static int range_decode_culshift(APEContext *ctx, int shift)
Decode value with given size in bits.
#define APE_FILTER_LEVELS
uint64_t channel_layout
Audio channel layout.
static int range_decode_bits(APEContext *ctx, int n)
Decode n bits (n <= 16) without modelling.
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
audio channel layout utility functions
static void predictor_decode_mono_3930(APEContext *ctx, int count)
uint8_t * data
current frame data
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
static const uint16_t ape_filter_orders[5][APE_FILTER_LEVELS]
Filter orders depending on compression level.
static int get_rice_ook(GetBitContext *gb, int k)
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
static av_always_inline int filter_fast_3320(APEPredictor *p, const int decoded, const int filter, const int delayA)
static void ape_unpack_stereo(APEContext *ctx, int count)
const uint8_t * ptr
current position in frame data
static int range_decode_culfreq(APEContext *ctx, int tot_f)
Calculate cumulative frequency for next symbol.
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define AV_EF_EXPLODE
abort decoding on minor error detection
int32_t(* scalarproduct_and_madd_int16)(int16_t *v1, const int16_t *v2, const int16_t *v3, int len, int mul)
Calculate scalar product of v1 and v2, and v1[i] += v3[i] * mul.
static void predictor_decode_stereo_3930(APEContext *ctx, int count)
av_cold void ff_llauddsp_init(LLAudDSPContext *c)
#define FFABSU(a)
Unsigned Absolute value.
uint32_t help
bytes_to_follow resp. intermediate value
uint32_t coeffsA[2][4]
adaption coefficients
int64_t historybuffer[HISTORY_SIZE+PREDICTOR_SIZE]
static void entropy_decode_stereo_3990(APEContext *ctx, int blockstodecode)
#define APE_FRAMECODE_PSEUDO_STEREO
uint32_t range
length of interval
int samples
samples left to decode in current frame
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
int fset
which filter set to use (calculated from compression level)
static int ape_decode_value_3860(APEContext *ctx, GetBitContext *gb, APERice *rice)
APERice riceX
rice code parameters for the second channel
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
static void predictor_decode_stereo_3950(APEContext *ctx, int count)
static void predictor_decode_stereo_3800(APEContext *ctx, int count)
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
#define APE_FRAMECODE_STEREO_SILENCE
static void init_filter(APEContext *ctx, APEFilter *f, int16_t *buf, int order)
int frameflags
frame flags
main external API structure.
static av_always_inline int filter_3800(APEPredictor *p, const unsigned decoded, const int filter, const int delayA, const int delayB, const int start, const int shift)
static int ape_decode_value_3990(APEContext *ctx, APERice *rice)
uint32_t CRC
signalled frame CRC
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
static const uint16_t counts_3980[22]
Fixed probabilities for symbols in Monkey Audio version 3.98.
static int range_get_symbol(APEContext *ctx, const uint16_t counts[], const uint16_t counts_diff[])
Decode symbol.
Describe the class of an AVClass context structure.
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
uint32_t low
low end of interval
int flags
global decoder flags
APECompressionLevel
Possible compression levels.
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data...
void(* predictor_decode_stereo)(struct APEContext *ctx, int count)
static void range_decode_update(APEContext *ctx, int sy_f, int lt_f)
Update decoding state.
static void entropy_decode_mono_3900(APEContext *ctx, int blockstodecode)
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
static const int32_t initial_coeffs_fast_3320[1]
static void do_apply_filter(APEContext *ctx, int version, APEFilter *f, int32_t *data, int count, int order, int fracbits)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
#define PREDICTOR_SIZE
Total size of all predictor histories.
static const uint16_t counts_diff_3970[21]
Probability ranges for symbols in Monkey Audio version 3.97.
int blocks_per_loop
maximum number of samples to decode for each call
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
uint8_t * data_end
frame data end
common internal api header.
APERice riceY
rice code parameters for the first channel
static const int shift2[6]
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
APEFilter filters[APE_FILTER_LEVELS][2]
filters used for reconstruction
int16_t * coeffs
actual coefficients used in filtering
static void init_predictor_decoder(APEContext *ctx)
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
static const int32_t initial_coeffs_b_3800[2]
APEPredictor predictor
predictor used for final reconstruction
static const AVClass ape_decoder_class
int channels
number of audio channels
static void long_filter_ehigh_3830(int32_t *buffer, int length)
static void predictor_decode_mono_3950(APEContext *ctx, int count)
Filters applied to the decoded data.
static const struct PPFilter filters[]
uint32_t coeffsB[2][5]
adaption coefficients
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a it should return
static enum AVSampleFormat sample_fmts[]
int32_t * decoded[MAX_CHANNELS]
decoded data for each channel
int data_size
frame data allocated size
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
static const AVOption options[]
#define AV_CH_LAYOUT_MONO
int16_t * adaptcoeffs
adaptive filter coefficients used for correcting of actual filter coefficients
This structure stores compressed data.
int nb_samples
number of audio samples (per channel) described by this frame
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
static void entropy_decode_mono_0000(APEContext *ctx, int blockstodecode)
int16_t * historybuffer
filter memory
static void entropy_decode_mono_3860(APEContext *ctx, int blockstodecode)