25 #include "libavutil/avassert.h"
26 #include "libavutil/channel_layout.h"
27 #include "libavutil/opt.h"
41 #define MAX_CHANNELS 2
42 #define MAX_BYTESPERSAMPLE 3
44 #define APE_FRAMECODE_MONO_SILENCE 1
45 #define APE_FRAMECODE_STEREO_SILENCE 3
46 #define APE_FRAMECODE_PSEUDO_STEREO 4
48 #define HISTORY_SIZE 512
49 #define PREDICTOR_ORDER 8
51 #define PREDICTOR_SIZE 50
53 #define YDELAYA (18 + PREDICTOR_ORDER*4)
54 #define YDELAYB (18 + PREDICTOR_ORDER*3)
55 #define XDELAYA (18 + PREDICTOR_ORDER*2)
56 #define XDELAYB (18 + PREDICTOR_ORDER)
58 #define YADAPTCOEFFSA 18
59 #define XADAPTCOEFFSA 14
60 #define YADAPTCOEFFSB 10
61 #define XADAPTCOEFFSB 5
76 #define APE_FILTER_LEVELS 3
223 *v1++ += mul * *v3++;
254 "%d bits per coded sample", s->
bps);
332 #define TOP_VALUE ((unsigned int)1 << (CODE_BITS-1))
333 #define SHIFT_BITS (CODE_BITS - 9)
334 #define EXTRA_BITS ((CODE_BITS-2) % 8 + 1)
335 #define BOTTOM_VALUE (TOP_VALUE >> 8)
408 #define MODEL_ELEMENTS 64
414 0, 14824, 28224, 39348, 47855, 53994, 58171, 60926,
415 62682, 63786, 64463, 64878, 65126, 65276, 65365, 65419,
416 65450, 65469, 65480, 65487, 65491, 65493,
423 14824, 13400, 11124, 8507, 6139, 4177, 2755, 1756,
424 1104, 677, 415, 248, 150, 89, 54, 31,
432 0, 19578, 36160, 48417, 56323, 60899, 63265, 64435,
433 64971, 65232, 65351, 65416, 65447, 65466, 65476, 65482,
434 65485, 65488, 65490, 65491, 65492, 65493,
441 19578, 16582, 12257, 7906, 4576, 2366, 1170, 536,
442 261, 119, 65, 31, 19, 10, 6, 3,
453 const uint16_t counts[],
454 const uint16_t counts_diff[])
461 symbol= cf - 65535 + 63;
468 for (symbol = 0; counts[symbol + 1] <= cf; symbol++);
478 int lim = rice->
k ? (1 << (rice->
k + 4)) : 0;
479 rice->
ksum += ((x + 1) / 2) - ((rice->
ksum + 16) >> 5);
481 if (rice->
ksum < lim)
483 else if (rice->
ksum >= (1 << (rice->
k + 5)))
502 unsigned int x, overflow;
507 while (overflow >= 16) {
516 x = (overflow << rice->
k) +
get_bits(gb, rice->
k);
518 rice->
ksum += x - (rice->
ksum + 8 >> 4);
519 if (rice->
ksum < (rice->
k ? 1 << (rice->
k + 4) : 0))
521 else if (rice->
ksum >= (1 << (rice->
k + 5)) && rice->
k < 24)
533 unsigned int x, overflow;
542 tmpk = (rice->
k < 1) ? 0 : rice->
k - 1;
546 else if (tmpk <= 32) {
553 x += overflow << tmpk;
566 unsigned int x, overflow;
569 pivot = rice->
ksum >> 5;
580 if (pivot < 0x10000) {
584 int base_hi = pivot, base_lo;
587 while (base_hi & ~0xFFFF) {
596 base = (base_hi << bbits) + base_lo;
599 x = base + overflow * pivot;
614 int ksummax, ksummin;
617 for (i = 0; i < 5; i++) {
619 rice->
ksum += out[i];
622 for (; i < 64; i++) {
624 rice->
ksum += out[i];
627 ksummax = 1 << rice->
k + 7;
628 ksummin = rice->
k ? (1 << rice->
k + 6) : 0;
629 for (; i < blockstodecode; i++) {
631 rice->
ksum += out[i] - out[i - 64];
632 while (rice->
ksum < ksummin) {
634 ksummin = rice->
k ? ksummin >> 1 : 0;
637 while (rice->
ksum >= ksummax) {
642 ksummin = ksummin ? ksummin << 1 : 128;
646 for (i = 0; i < blockstodecode; i++) {
648 out[i] = (out[i] >> 1) + 1;
650 out[i] = -(out[i] >> 1);
672 while (blockstodecode--)
680 int blocks = blockstodecode;
682 while (blockstodecode--)
692 while (blockstodecode--)
700 int blocks = blockstodecode;
702 while (blockstodecode--)
717 while (blockstodecode--) {
727 while (blockstodecode--)
736 while (blockstodecode--) {
748 ctx->
CRC = bytestream_get_be32(&ctx->
ptr);
756 ctx->
CRC &= ~0x80000000;
837 return (x < 0) - (x > 0);
853 predictionA = p->
buf[delayA] * 2 - p->
buf[delayA - 1];
856 if ((decoded ^ predictionA) > 0)
868 const int delayA,
const int delayB,
869 const int start,
const int shift)
871 int32_t predictionA, predictionB, sign;
884 d1 = (p->
buf[delayA] - p->
buf[delayA - 1]) << 1;
885 d0 = p->
buf[delayA] + ((p->
buf[delayA - 2] - p->
buf[delayA - 1]) << 3);
886 d3 = p->
buf[delayB] * 2 - p->
buf[delayB - 1];
917 memset(coeffs, 0, order *
sizeof(*coeffs));
918 for (i = 0; i < order; i++)
919 delay[i] = buffer[i];
920 for (i = order; i < length; i++) {
923 for (j = 0; j < order; j++) {
924 dotprod += delay[j] * coeffs[j];
925 coeffs[j] -= (((delay[j] >> 30) & 2) - 1) * sign;
927 buffer[i] -= dotprod >> shift;
928 for (j = 0; j < order - 1; j++)
929 delay[j] = delay[j + 1];
930 delay[order - 1] = buffer[i];
938 int32_t coeffs[8] = { 0 }, delay[8] = { 0 };
940 for (i = 0; i < length; i++) {
943 for (j = 7; j >= 0; j--) {
944 dotprod += delay[j] * coeffs[j];
945 coeffs[j] -= (((delay[j] >> 30) & 2) - 1) * sign;
947 for (j = 7; j > 0; j--)
948 delay[j] = delay[j - 1];
949 delay[0] = buffer[i];
950 buffer[i] -= dotprod >> 9;
959 int32_t coeffs[256], delay[256];
960 int start = 4, shift = 10;
967 int order = 128,
shift2 = 11;
982 int X = *decoded0,
Y = *decoded1;
1014 int32_t coeffs[256], delay[256];
1015 int start = 4, shift = 10;
1021 int order = 128,
shift2 = 11;
1064 d0 = p->
buf[delayA ];
1065 d1 = p->
buf[delayA ] - p->
buf[delayA - 1];
1066 d2 = p->
buf[delayA - 1] - p->
buf[delayA - 2];
1067 d3 = p->
buf[delayA - 2] - p->
buf[delayA - 3];
1096 int Y = *decoded1, X = *decoded0;
1138 const int delayA,
const int delayB,
1139 const int adaptA,
const int adaptB)
1141 int32_t predictionA, predictionB, sign;
1145 p->
buf[delayA - 1] = p->
buf[delayA] - p->
buf[delayA - 1];
1156 p->
buf[delayB - 1] = p->
buf[delayB] - p->
buf[delayB - 1];
1166 p->
lastA[
filter] = decoded + ((predictionA + (predictionB >> 1)) >> 10);
1216 int32_t predictionA, currentA,
A, sign;
1220 currentA = p->
lastA[0];
1233 currentA = A + (predictionA >> 10);
1254 *(decoded0++) = p->
filterA[0];
1257 p->
lastA[0] = currentA;
1279 int32_t *
data,
int count,
int order,
int fracbits)
1290 res = (res + (1 << (fracbits - 1))) >> fracbits;
1295 *f->
delay++ = av_clip_int16(res);
1297 if (version < 3980) {
1299 f->
adaptcoeffs[0] = (res == 0) ? 0 : ((res >> 28) & 8) - 4;
1306 absres =
FFABS(res);
1308 *f->
adaptcoeffs = ((res & (-1<<31)) ^ (-1<<30)) >>
1309 (25 + (absres <= f->
avg*3) + (absres <= f->avg*4/3));
1313 f->
avg += (absres - f->
avg) / 16;
1334 int count,
int order,
int fracbits)
1409 left = *decoded1 - (*decoded0 / 2);
1410 right = left + *decoded0;
1412 *(decoded0++) = left;
1413 *(decoded1++) = right;
1418 int *got_frame_ptr,
AVPacket *avpkt)
1434 uint32_t nblocks, offset;
1441 if (avpkt->
size < 8) {
1445 buf_size = avpkt->
size & ~3;
1446 if (buf_size != avpkt->
size) {
1448 "extra bytes at the end will be skipped.\n");
1457 memset(s->
data + (buf_size & ~3), 0, buf_size & 3);
1461 nblocks = bytestream_get_be32(&s->
ptr);
1462 offset = bytestream_get_be32(&s->
ptr);
1482 if (!nblocks || nblocks > INT_MAX) {
1540 for (ch = 0; ch < s->
channels; ch++) {
1542 for (i = 0; i < blockstodecode; i++)
1543 *sample8++ = (s->
decoded[ch][i] + 0x80) & 0xff;
1547 for (ch = 0; ch < s->
channels; ch++) {
1548 sample16 = (int16_t *)frame->
data[ch];
1549 for (i = 0; i < blockstodecode; i++)
1550 *sample16++ = s->
decoded[ch][i];
1554 for (ch = 0; ch < s->
channels; ch++) {
1556 for (i = 0; i < blockstodecode; i++)
1557 *sample24++ = s->
decoded[ch][i] << 8;
1575 #define OFFSET(x) offsetof(APEContext, x)
1576 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1579 {
"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)
static const int32_t initial_coeffs_3930[4]
static void decode_array_0000(APEContext *ctx, GetBitContext *gb, int32_t *out, APERice *rice, int blockstodecode)
int compression_level
compression levels
static av_always_inline int filter_3800(APEPredictor *p, const int decoded, const int filter, const int delayA, const int delayB, const int start, const int shift)
int32_t coeffsB[2][5]
adaption coefficients
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
This structure describes decoded (raw) audio or video data.
static void range_start_decoding(APEContext *ctx)
Start the decoder.
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
void ff_apedsp_init_arm(APEDSPContext *c)
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.
static void skip_bits_long(GetBitContext *s, int n)
void(* entropy_decode_mono)(struct APEContext *ctx, int blockstodecode)
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)
static void entropy_decode_stereo_3900(APEContext *ctx, int blockstodecode)
static av_cold int ape_decode_init(AVCodecContext *avctx)
unsigned int buffer
buffer for input/output
static int init_entropy_decoder(APEContext *ctx)
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
static void ape_flush(AVCodecContext *avctx)
static void entropy_decode_stereo_3930(APEContext *ctx, int blockstodecode)
void ff_apedsp_init_ppc(APEDSPContext *c)
static av_always_inline int predictor_update_3930(APEPredictor *p, const int decoded, const int filter, const int delayA)
#define AV_CH_LAYOUT_STEREO
int16_t * filterbuf[APE_FILTER_LEVELS]
filter memory
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
static void predictor_decode_mono_3800(APEContext *ctx, int count)
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
static int ape_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
enum AVSampleFormat sample_fmt
audio sample format
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.
int16_t * delay
filtered values
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
static void do_init_filter(APEFilter *f, int16_t *buf, int order)
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)
const char * name
Name of the codec implementation.
APERangecoder rc
rangecoder used to decode actual values
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
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.
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
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.
static av_cold int ape_decode_close(AVCodecContext *avctx)
#define CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
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.
static int range_decode_culshift(APEContext *ctx, int shift)
Decode value with given size in bits.
#define APE_FILTER_LEVELS
Libavcodec external API header.
uint64_t channel_layout
Audio channel layout.
static int range_decode_bits(APEContext *ctx, int n)
Decode n bits (n <= 16) without modelling.
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
static void filter(MpegAudioContext *s, int ch, const short *samples, int incr)
static void predictor_decode_mono_3930(APEContext *ctx, int count)
uint8_t * data
current frame data
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)
static void long_filter_high_3800(int32_t *buffer, int order, int shift, int32_t *coeffs, int32_t *delay, int length)
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 culmulative frequency for next symbol.
static void predictor_decode_stereo_3930(APEContext *ctx, int count)
uint32_t help
bytes_to_follow resp. intermediate value
static void entropy_decode_stereo_3990(APEContext *ctx, int blockstodecode)
#define APE_FRAMECODE_PSEUDO_STEREO
uint32_t range
length of interval
if(ac->has_optimized_func)
int samples
samples left to decode in current frame
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, 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
AVSampleFormat
Audio Sample Formats.
static void predictor_decode_stereo_3950(APEContext *ctx, int count)
static void predictor_decode_stereo_3800(APEContext *ctx, int count)
#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 void(WINAPI *cond_broadcast)(pthread_cond_t *cond)
static void close(AVCodecParserContext *s)
static int ape_decode_value_3990(APEContext *ctx, APERice *rice)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
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.
uint32_t low
low end of interval
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
int flags
global decoder flags
APECompressionLevel
Possible compression levels.
void(* predictor_decode_stereo)(struct APEContext *ctx, int count)
int32_t coeffsA[2][4]
adaption coefficients
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)
#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
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_dlog(ac->avr,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> out
#define CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
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.
#define FF_ALLOC_OR_GOTO(ctx, p, size, label)
static av_cold void flush(AVCodecContext *avctx)
Flush (reset) the frame ID after seeking.
APEFilter filters[APE_FILTER_LEVELS][2]
filters used for reconstruction
static av_always_inline int predictor_update_filter(APEPredictor *p, const int decoded, const int filter, const int delayA, const int delayB, const int adaptA, const int adaptB)
int16_t * coeffs
actual coefficients used in filtering
static av_cold int init(AVCodecParserContext *s)
static void init_predictor_decoder(APEContext *ctx)
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 int32_t scalarproduct_and_madd_int16_c(int16_t *v1, const int16_t *v2, const int16_t *v3, int order, int mul)
int32_t * decoded[MAX_CHANNELS]
decoded data for each channel
void ff_apedsp_init_x86(APEDSPContext *c)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
av_default_item_name
Return the context name.
int data_size
frame data allocated size
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
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
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)