35 #define MAX_SUBFRAMES 8 // max number of subframes per channel
36 #define MAX_PREDICTORS 256
73 4, 8, 12, 16, 24, 32, 48, 64, 80, 96, 128, 160, 192, 224, 256, 0,
83 { 0x01, 0x0000001, 0x0000001, 0x0000003, 0x0000008 },
84 { 0x02, 0x0000003, 0x0000001, 0x0000007, 0x0000006 },
85 { 0x03, 0x0000005, 0x0000002, 0x000000E, 0x000000D },
86 { 0x03, 0x0000003, 0x0000003, 0x000000D, 0x0000018 },
87 { 0x04, 0x000000B, 0x0000004, 0x000001C, 0x0000019 },
88 { 0x04, 0x0000006, 0x0000006, 0x000001A, 0x0000030 },
89 { 0x05, 0x0000016, 0x0000008, 0x0000038, 0x0000032 },
90 { 0x05, 0x000000C, 0x000000C, 0x0000034, 0x0000060 },
91 { 0x06, 0x000002C, 0x0000010, 0x0000070, 0x0000064 },
92 { 0x06, 0x0000018, 0x0000018, 0x0000068, 0x00000C0 },
93 { 0x07, 0x0000058, 0x0000020, 0x00000E0, 0x00000C8 },
94 { 0x07, 0x0000030, 0x0000030, 0x00000D0, 0x0000180 },
95 { 0x08, 0x00000B0, 0x0000040, 0x00001C0, 0x0000190 },
96 { 0x08, 0x0000060, 0x0000060, 0x00001A0, 0x0000300 },
97 { 0x09, 0x0000160, 0x0000080, 0x0000380, 0x0000320 },
98 { 0x09, 0x00000C0, 0x00000C0, 0x0000340, 0x0000600 },
99 { 0x0A, 0x00002C0, 0x0000100, 0x0000700, 0x0000640 },
100 { 0x0A, 0x0000180, 0x0000180, 0x0000680, 0x0000C00 },
101 { 0x0B, 0x0000580, 0x0000200, 0x0000E00, 0x0000C80 },
102 { 0x0B, 0x0000300, 0x0000300, 0x0000D00, 0x0001800 },
103 { 0x0C, 0x0000B00, 0x0000400, 0x0001C00, 0x0001900 },
104 { 0x0C, 0x0000600, 0x0000600, 0x0001A00, 0x0003000 },
105 { 0x0D, 0x0001600, 0x0000800, 0x0003800, 0x0003200 },
106 { 0x0D, 0x0000C00, 0x0000C00, 0x0003400, 0x0006000 },
107 { 0x0E, 0x0002C00, 0x0001000, 0x0007000, 0x0006400 },
108 { 0x0E, 0x0001800, 0x0001800, 0x0006800, 0x000C000 },
109 { 0x0F, 0x0005800, 0x0002000, 0x000E000, 0x000C800 },
110 { 0x0F, 0x0003000, 0x0003000, 0x000D000, 0x0018000 },
111 { 0x10, 0x000B000, 0x0004000, 0x001C000, 0x0019000 },
112 { 0x10, 0x0006000, 0x0006000, 0x001A000, 0x0030000 },
113 { 0x11, 0x0016000, 0x0008000, 0x0038000, 0x0032000 },
114 { 0x11, 0x000C000, 0x000C000, 0x0034000, 0x0060000 },
115 { 0x12, 0x002C000, 0x0010000, 0x0070000, 0x0064000 },
116 { 0x12, 0x0018000, 0x0018000, 0x0068000, 0x00C0000 },
117 { 0x13, 0x0058000, 0x0020000, 0x00E0000, 0x00C8000 },
118 { 0x13, 0x0030000, 0x0030000, 0x00D0000, 0x0180000 },
119 { 0x14, 0x00B0000, 0x0040000, 0x01C0000, 0x0190000 },
120 { 0x14, 0x0060000, 0x0060000, 0x01A0000, 0x0300000 },
121 { 0x15, 0x0160000, 0x0080000, 0x0380000, 0x0320000 },
122 { 0x15, 0x00C0000, 0x00C0000, 0x0340000, 0x0600000 },
123 { 0x16, 0x02C0000, 0x0100000, 0x0700000, 0x0640000 },
124 { 0x16, 0x0180000, 0x0180000, 0x0680000, 0x0C00000 },
125 { 0x17, 0x0580000, 0x0200000, 0x0E00000, 0x0C80000 },
126 { 0x17, 0x0300000, 0x0300000, 0x0D00000, 0x1800000 },
127 { 0x18, 0x0B00000, 0x0400000, 0x1C00000, 0x1900000 },
128 { 0x18, 0x0600000, 0x0600000, 0x1A00000, 0x3000000 },
129 { 0x19, 0x1600000, 0x0800000, 0x3800000, 0x3200000 },
130 { 0x19, 0x0C00000, 0x0C00000, 0x3400000, 0x6000000 },
131 { 0x1A, 0x2C00000, 0x1000000, 0x7000000, 0x6400000 },
132 { 0x1A, 0x1800000, 0x1800000, 0x6800000, 0xC000000 },
166 shift =
FFMAX(0, shift);
195 for (i = 0; i < length - 1 >> 1; i++) {
203 }
else if (mode == 2) {
209 for (i = 0; i < length - 2 >> 1; i++) {
210 int a3 = *coeffs +
a1;
221 }
else if (mode == 3) {
230 for (i = 0; i < length - 3; i++) {
248 memset(decoded, 0, len *
sizeof(*decoded));
256 for (i = 0; i <
len; i++) {
264 if (scale_bits > 0) {
265 if (scale_bits == 7) {
279 decoded[i] = (x >> 1) ^ -(x & 1);
295 int coding_mode[128];
297 wlength = length / s->
uval;
299 rval = length - (wlength * s->
uval);
301 if (rval < s->uval / 2)
306 if (wlength <= 1 || wlength > 128)
309 coding_mode[0] = mode =
get_bits(gb, 6);
311 for (i = 1; i < wlength; i++) {
323 mode += (-sign ^ (c - 1)) + sign;
333 coding_mode[i] = mode;
337 while (i < wlength) {
340 mode = coding_mode[i];
342 if (i >= wlength - 1)
350 }
while (coding_mode[i] == mode);
374 int filter_quant, int16_t *
filter)
385 if (filter_order > 4) {
387 int code_size_base = size -
get_bits1(gb);
389 for (i = 4; i < filter_order; i++) {
391 code_size = code_size_base -
get_bits(gb, 2);
396 filter_tmp[0] = predictors[0] << 6;
397 for (i = 1; i < filter_order; i++) {
398 int *p1 = &filter_tmp[0];
399 int *p2 = &filter_tmp[i - 1];
401 for (j = 0; j < (i + 1) / 2; j++) {
402 int tmp = *p1 + (predictors[i] * *p2 + 256 >> 9);
403 *p2 = *p2 + (predictors[i] * *p1 + 256 >> 9);
409 filter_tmp[i] = predictors[i] << 6;
412 a = 1 << (32 - (15 - filter_quant));
413 b = 1 << ((15 - filter_quant) - 1);
414 for (i = 0, j = filter_order - 1; i < filter_order / 2; i++, j--) {
415 filter[j] = a - ((filter_tmp[i] +
b) >> (15 - filter_quant));
416 filter[i] = a - ((filter_tmp[j] +
b) >> (15 - filter_quant));
421 int subframe_size,
int prev_subframe_size)
426 int dshift,
size, filter_quant, filter_order;
435 if (prev_subframe_size > 0 &&
get_bits1(gb)) {
436 if (filter_order > prev_subframe_size)
439 decoded -= filter_order;
440 subframe_size += filter_order;
442 if (filter_order > subframe_size)
447 if (filter_order > subframe_size)
466 filter_quant -=
get_bits(gb, 3) + 1;
467 if (filter_quant < 3)
474 subframe_size - filter_order)) < 0)
483 for (i = 0; i < filter_order; i++)
484 s->
residues[i] = *decoded++ >> dshift;
486 for (i = 0; i < subframe_size - filter_order; i++) {
487 int v = 1 << (filter_quant - 1);
492 v = (av_clip(v >> filter_quant, -8192, 8191) << dshift) - *decoded;
494 s->
residues[filter_order + i] = v >> dshift;
508 int i, prev, ret, nb_subframes;
527 if (nb_subframes > 1) {
532 for (; i < nb_subframes - 1; i++) {
534 if (subframe_end <= prev)
536 subframe_len[i] = subframe_end - prev;
537 left -= subframe_len[i];
544 subframe_len[i] = left;
547 for (i = 0; i < nb_subframes; i++) {
550 decoded += subframe_len[i];
551 prev = subframe_len[i];
567 for (i = 0; i < length; i++) {
574 for (i = 0; i < length; i++) {
581 for (i = 0; i < length; i++) {
594 for (i = 0; i < length; i++) {
597 b = dfactor * (b >> dshift) + 128 >> 8 << dshift;
605 int length2, order_half, filter_order, dval1, dval2;
618 for (i = 0; i < filter_order; i++) {
624 order_half = filter_order / 2;
625 length2 = length - (filter_order - 1);
629 for (i = 0; i < order_half; i++) {
638 for (i = length2 + order_half; i < length; i++) {
651 for (i = 0; i < length; i++)
656 for (i = 0; i < length2; i++) {
662 p1[i] = (av_clip(v >> 10, -8192, 8191) << dshift) - p1[i];
678 int chan, i, ret, hsize;
713 "invalid number of channels: %d\n", s->
ti.
channels);
718 "unsupported number of channels: %d\n", s->
ti.
channels);
760 for (chan = 0; chan < avctx->
channels; chan++)
765 for (chan = 0; chan < avctx->
channels; chan++) {
772 for (chan = 0; chan < avctx->
channels; chan++)
794 for (i = 0; i < chan; i++) {
800 if (ch_mask & 1 << nbit)
819 ch_mask |= 1 << nbit;
823 for (i = 0; i < chan; i++) {
829 for (i = 0; i < chan; i++) {
848 for (chan = 0; chan < avctx->
channels; chan++) {
878 for (chan = 0; chan < avctx->
channels; chan++) {
882 samples[i] = decoded[i] + 0x80;
886 for (chan = 0; chan < avctx->
channels; chan++) {
890 samples[i] = decoded[i];
894 for (chan = 0; chan < avctx->
channels; chan++) {
static const int16_t coeffs[28]
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
static int set_bps_params(AVCodecContext *avctx)
static const uint16_t predictor_sizes[]
int ff_tak_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb, TAKStreamInfo *ti, int log_level_offset)
Validate and decode a frame header.
This structure describes decoded (raw) audio or video data.
int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Get the required buffer size for the given audio parameters.
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
AVFrame * coded_frame
the picture in the bitstream
static void align_get_bits(GetBitContext *s)
MCDParam mcdparams[TAK_MAX_CHANNELS]
static int decode_subframe(TAKDecContext *s, int32_t *decoded, int subframe_size, int prev_subframe_size)
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
static int get_sbits(GetBitContext *s, int n)
int8_t lpc_mode[TAK_MAX_CHANNELS]
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
int av_samples_fill_arrays(uint8_t **audio_data, int *linesize, const uint8_t *buf, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Fill channel data pointers and linesize for samples with sample format sample_fmt.
unsigned int decode_buffer_size
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
#define FFSWAP(type, a, b)
enum AVSampleFormat sample_fmt
audio sample format
static av_cold int tak_decode_close(AVCodecContext *avctx)
int ff_tak_check_crc(const uint8_t *buf, unsigned int buf_size)
static void decode_filter_coeffs(TAKDecContext *s, int filter_order, int size, int filter_quant, int16_t *filter)
static int get_bits_count(const GetBitContext *s)
#define LOCAL_ALIGNED_16(t, v,...)
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
static int decode_channel(TAKDecContext *s, int chan)
static int init(AVCodecParserContext *s)
static int get_bits_left(GetBitContext *gb)
int32_t(* scalarproduct_int16)(const int16_t *v1, const int16_t *v2, int len)
Calculate scalar product of two vectors.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
av_cold void ff_tak_init_crc(void)
void av_log(void *avcl, int level, const char *fmt,...)
const char * name
Name of the codec implementation.
static int decode_residues(TAKDecContext *s, int32_t *decoded, int length)
uint64_t channel_layout
Audio channel layout.
static void filter(MpegAudioContext *s, int ch, const short *samples, int incr)
static av_cold int tak_decode_init(AVCodecContext *avctx)
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
static const struct CParam xcodes[50]
unsigned int residues_buf_size
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
Get a buffer for a frame.
static int get_bits_esc4(GetBitContext *gb)
static int decorrelate(TAKDecContext *s, int c1, int c2, int length)
static void decode_lpc(int32_t *coeffs, int mode, int length)
#define TAK_FRAME_FLAG_HAS_METADATA
#define TAK_MIN_FRAME_HEADER_BYTES
int sample_rate
samples per second
main external API structure.
static void close(AVCodecParserContext *s)
struct TAKDecContext TAKDecContext
int32_t * decoded[TAK_MAX_CHANNELS]
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 void skip_bits(GetBitContext *s, int n)
#define FF_ARRAY_ELEMS(a)
void av_log_missing_feature(void *avc, const char *feature, int want_sample)
Log a generic warning message about a missing feature.
TAK (Tom's lossless Audio Kompressor) decoder/demuxer common functions.
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
static const uint16_t scale[4]
common internal api header.
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
static int decode_segment(GetBitContext *gb, int mode, int32_t *decoded, int len)
#define AVERROR_INVALIDDATA
AVSampleFormat
Audio Sample Formats.
static const int8_t mc_dmodes[]
#define AVERROR_PATCHWELCOME
static int tak_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *pkt)
int channels
number of audio channels
static void set_sample_rate_params(AVCodecContext *avctx)
int8_t sample_shift[TAK_MAX_CHANNELS]
static av_cold void tak_init_static_data(AVCodec *codec)
uint8_t ** extended_data
pointers to the data planes/channels.
This structure stores compressed data.
int nb_samples
number of audio samples (per channel) described by this frame