31 #define BITSTREAM_READER_LE
40 #define MAX_SUBFRAMES 8
41 #define MAX_PREDICTORS 256
82 4, 8, 12, 16, 24, 32, 48, 64, 80, 96, 128, 160, 192, 224, 256, 0,
92 { 0x01, 0x0000001, 0x0000001, 0x0000003, 0x0000008 },
93 { 0x02, 0x0000003, 0x0000001, 0x0000007, 0x0000006 },
94 { 0x03, 0x0000005, 0x0000002, 0x000000E, 0x000000D },
95 { 0x03, 0x0000003, 0x0000003, 0x000000D, 0x0000018 },
96 { 0x04, 0x000000B, 0x0000004, 0x000001C, 0x0000019 },
97 { 0x04, 0x0000006, 0x0000006, 0x000001A, 0x0000030 },
98 { 0x05, 0x0000016, 0x0000008, 0x0000038, 0x0000032 },
99 { 0x05, 0x000000C, 0x000000C, 0x0000034, 0x0000060 },
100 { 0x06, 0x000002C, 0x0000010, 0x0000070, 0x0000064 },
101 { 0x06, 0x0000018, 0x0000018, 0x0000068, 0x00000C0 },
102 { 0x07, 0x0000058, 0x0000020, 0x00000E0, 0x00000C8 },
103 { 0x07, 0x0000030, 0x0000030, 0x00000D0, 0x0000180 },
104 { 0x08, 0x00000B0, 0x0000040, 0x00001C0, 0x0000190 },
105 { 0x08, 0x0000060, 0x0000060, 0x00001A0, 0x0000300 },
106 { 0x09, 0x0000160, 0x0000080, 0x0000380, 0x0000320 },
107 { 0x09, 0x00000C0, 0x00000C0, 0x0000340, 0x0000600 },
108 { 0x0A, 0x00002C0, 0x0000100, 0x0000700, 0x0000640 },
109 { 0x0A, 0x0000180, 0x0000180, 0x0000680, 0x0000C00 },
110 { 0x0B, 0x0000580, 0x0000200, 0x0000E00, 0x0000C80 },
111 { 0x0B, 0x0000300, 0x0000300, 0x0000D00, 0x0001800 },
112 { 0x0C, 0x0000B00, 0x0000400, 0x0001C00, 0x0001900 },
113 { 0x0C, 0x0000600, 0x0000600, 0x0001A00, 0x0003000 },
114 { 0x0D, 0x0001600, 0x0000800, 0x0003800, 0x0003200 },
115 { 0x0D, 0x0000C00, 0x0000C00, 0x0003400, 0x0006000 },
116 { 0x0E, 0x0002C00, 0x0001000, 0x0007000, 0x0006400 },
117 { 0x0E, 0x0001800, 0x0001800, 0x0006800, 0x000C000 },
118 { 0x0F, 0x0005800, 0x0002000, 0x000E000, 0x000C800 },
119 { 0x0F, 0x0003000, 0x0003000, 0x000D000, 0x0018000 },
120 { 0x10, 0x000B000, 0x0004000, 0x001C000, 0x0019000 },
121 { 0x10, 0x0006000, 0x0006000, 0x001A000, 0x0030000 },
122 { 0x11, 0x0016000, 0x0008000, 0x0038000, 0x0032000 },
123 { 0x11, 0x000C000, 0x000C000, 0x0034000, 0x0060000 },
124 { 0x12, 0x002C000, 0x0010000, 0x0070000, 0x0064000 },
125 { 0x12, 0x0018000, 0x0018000, 0x0068000, 0x00C0000 },
126 { 0x13, 0x0058000, 0x0020000, 0x00E0000, 0x00C8000 },
127 { 0x13, 0x0030000, 0x0030000, 0x00D0000, 0x0180000 },
128 { 0x14, 0x00B0000, 0x0040000, 0x01C0000, 0x0190000 },
129 { 0x14, 0x0060000, 0x0060000, 0x01A0000, 0x0300000 },
130 { 0x15, 0x0160000, 0x0080000, 0x0380000, 0x0320000 },
131 { 0x15, 0x00C0000, 0x00C0000, 0x0340000, 0x0600000 },
132 { 0x16, 0x02C0000, 0x0100000, 0x0700000, 0x0640000 },
133 { 0x16, 0x0180000, 0x0180000, 0x0680000, 0x0C00000 },
134 { 0x17, 0x0580000, 0x0200000, 0x0E00000, 0x0C80000 },
135 { 0x17, 0x0300000, 0x0300000, 0x0D00000, 0x1800000 },
136 { 0x18, 0x0B00000, 0x0400000, 0x1C00000, 0x1900000 },
137 { 0x18, 0x0600000, 0x0600000, 0x1A00000, 0x3000000 },
138 { 0x19, 0x1600000, 0x0800000, 0x3800000, 0x3200000 },
139 { 0x19, 0x0C00000, 0x0C00000, 0x3400000, 0x6000000 },
140 { 0x1A, 0x2C00000, 0x1000000, 0x7000000, 0x6400000 },
141 { 0x1A, 0x1800000, 0x1800000, 0x6800000, 0xC000000 },
207 for (i = 0; i < length - 1 >> 1; i++) {
209 coeffs[1] += (unsigned)*coeffs;
215 }
else if (mode == 2) {
221 for (i = 0; i < length - 2 >> 1; i++) {
222 int a3 = *coeffs +
a1;
233 }
else if (mode == 3) {
243 for (i = 0; i < length - 3; i++) {
261 memset(decoded, 0, len *
sizeof(*decoded));
269 for (i = 0; i <
len; i++) {
277 if (scale_bits > 0) {
278 if (scale_bits == 7) {
292 decoded[i] = (x >> 1) ^ -(x & 1);
309 wlength = length / s->
uval;
311 rval = length - (wlength * s->
uval);
313 if (rval < s->uval / 2)
318 if (wlength <= 1 || wlength > 128)
323 for (i = 1; i < wlength; i++) {
335 mode += (-sign ^ (c - 1)) + sign;
349 while (i < wlength) {
354 if (i >= wlength - 1)
386 int subframe_size,
int prev_subframe_size)
389 int x, y, i, j, ret = 0;
390 int dshift,
size, filter_quant, filter_order;
398 if (prev_subframe_size > 0 &&
get_bits1(gb)) {
399 if (filter_order > prev_subframe_size)
402 decoded -= filter_order;
403 subframe_size += filter_order;
405 if (filter_order > subframe_size)
410 if (filter_order > subframe_size)
429 filter_quant -=
get_bits(gb, 3) + 1;
430 if (filter_quant < 3)
438 if (filter_order > 4) {
441 for (i = 4; i < filter_order; i++) {
449 for (i = 1; i < filter_order; i++) {
453 for (j = 0; j < (i + 1) / 2; j++) {
454 x = *p1 + (s->
predictors[i] * *p2 + 256 >> 9);
463 x = 1 << (32 - (15 - filter_quant));
464 y = 1 << ((15 - filter_quant) - 1);
465 for (i = 0, j = filter_order - 1; i < filter_order / 2; i++, j--) {
466 s->
filter[j] = x - ((tfilter[i] + y) >> (15 - filter_quant));
467 s->
filter[i] = x - ((tfilter[j] + y) >> (15 - filter_quant));
471 subframe_size - filter_order)) < 0)
474 for (i = 0; i < filter_order; i++)
475 s->
residues[i] = *decoded++ >> dshift;
478 x = subframe_size - filter_order;
482 for (i = 0; i <
tmp; i++) {
483 int v = 1 << (filter_quant - 1);
485 if (filter_order & -16)
488 for (j = filter_order & -16; j < filter_order; j += 4) {
494 v = (av_clip_intp2(v >> filter_quant, 13) * (1 << dshift)) - (unsigned)*decoded;
496 s->
residues[filter_order + i] = v >> dshift;
515 int i = 0, ret, prev = 0;
566 length += s->
dmode < 6;
589 int length2, order_half, filter_order, dval1, dval2;
590 int tmp, x, code_size;
600 for (i = 0; i < filter_order; i++) {
606 order_half = filter_order / 2;
607 length2 = length - (filter_order - 1);
611 for (i = 0; i < order_half; i++) {
620 for (i = length2 + order_half; i <
length; i++) {
628 for (i = 0; i < filter_order; i++)
633 for (; length2 > 0; length2 -=
tmp) {
634 tmp =
FFMIN(length2, x);
636 for (i = 0; i < tmp - (tmp == length2); i++)
637 s->
residues[filter_order + i] = *p2++ >> dshift;
639 for (i = 0; i <
tmp; i++) {
642 if (filter_order == 16) {
656 v = (av_clip_intp2(v >> 10, 13) << dshift) - *p1;
683 int chan, i, ret, hsize;
715 "invalid number of channels: %d\n", s->
ti.
channels);
720 "unsupported number of channels: %d\n", s->
ti.
channels);
763 for (chan = 0; chan < avctx->
channels; chan++)
768 for (chan = 0; chan < avctx->
channels; chan++) {
775 for (chan = 0; chan < avctx->
channels; chan++)
797 for (i = 0; i < chan; i++) {
803 if (ch_mask & 1 << nbit)
812 "invalid channel 2 (%d) for %d channel(s)\n",
828 ch_mask |= 1 << nbit;
832 for (i = 0; i < chan; i++) {
838 for (i = 0; i < chan; i++) {
857 for (chan = 0; chan < avctx->
channels; chan++) {
888 for (chan = 0; chan < avctx->
channels; chan++) {
892 samples[i] = decoded[i] + 0x80U;
896 for (chan = 0; chan < avctx->
channels; chan++) {
900 samples[i] = decoded[i];
904 for (chan = 0; chan < avctx->
channels; chan++) {
907 samples[i] *= 1
U << 8;
static int set_bps_params(AVCodecContext *avctx)
static const uint16_t predictor_sizes[]
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
int ff_tak_decode_frame_header(AVCodecContext *avctx, GetBitContext *gb, TAKStreamInfo *ti, int log_level_offset)
Validate and decode a frame header.
int32_t(* scalarproduct_int16)(const int16_t *v1, const int16_t *v2, int len)
Calculate scalar product of two vectors.
static int shift(int a, int b)
int16_t subframe_len[MAX_SUBFRAMES]
subframe length in samples
This structure describes decoded (raw) audio or video data.
ptrdiff_t const GLvoid * data
av_cold void ff_takdsp_init(TAKDSPContext *c)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static int init_thread_copy(AVCodecContext *avctx)
static av_cold int init(AVCodecContext *avctx)
MCDParam mcdparams[TAK_MAX_CHANNELS]
multichannel decorrelation parameters
int16_t filter[MAX_PREDICTORS]
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
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 decode_segment(TAKDecContext *s, int8_t mode, int32_t *decoded, int len)
void(* decorrelate_ls)(int32_t *p1, int32_t *p2, int length)
static int get_sbits(GetBitContext *s, int n)
int8_t lpc_mode[TAK_MAX_CHANNELS]
unsigned int decode_buffer_size
enum AVSampleFormat sample_fmt
audio sample format
av_cold void ff_audiodsp_init(AudioDSPContext *c)
static av_cold int tak_decode_close(AVCodecContext *avctx)
Multithreading support functions.
int ff_tak_check_crc(const uint8_t *buf, unsigned int buf_size)
AVCodecContext * avctx
parent AVCodecContext
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
static int get_bits_count(const GetBitContext *s)
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
void ff_thread_finish_setup(AVCodecContext *avctx)
If the codec defines update_thread_context(), call this when they are ready for the next thread to st...
static int decode_channel(TAKDecContext *s, int chan)
#define MAX_SUBFRAMES
max number of subframes per channel
int8_t index
index into array of decorrelation types
static int get_bits_left(GetBitContext *gb)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#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.
const char * name
Name of the codec implementation.
int8_t present
decorrelation parameter availability for this channel
static int decode_residues(TAKDecContext *s, int32_t *decoded, int length)
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
uint64_t channel_layout
Audio channel layout.
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
common internal API header
static av_cold int tak_decode_init(AVCodecContext *avctx)
void(* decorrelate_sr)(int32_t *p1, int32_t *p2, int length)
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
static const struct CParam xcodes[50]
void(* decorrelate_sm)(int32_t *p1, int32_t *p2, int length)
static int get_bits_esc4(GetBitContext *gb)
void(* decorrelate_sf)(int32_t *p1, int32_t *p2, int length, int dshift, int dfactor)
#define AV_EF_EXPLODE
abort decoding on minor error detection
static int decorrelate(TAKDecContext *s, int c1, int c2, int length)
static void decode_lpc(int32_t *coeffs, int mode, int length)
#define FF_ARRAY_ELEMS(a)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Libavcodec external API header.
AVSampleFormat
Audio sample formats.
#define TAK_MIN_FRAME_HEADER_BYTES
int sample_rate
samples per second
int16_t predictors[MAX_PREDICTORS]
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
main external API structure.
int32_t * decoded[TAK_MAX_CHANNELS]
decoded samples for each channel
static unsigned int get_bits1(GetBitContext *s)
static void skip_bits(GetBitContext *s, int n)
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.
TAK (Tom's lossless Audio Kompressor) decoder/demuxer common functions.
GetBitContext gb
bitstream reader initialized to start at the current frame
int8_t dmode
channel decorrelation type in the current frame
#define AV_EF_CRCCHECK
Verify checksums embedded in the bitstream (could be of either encoded or decoded data...
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
int nb_samples
number of samples in the current frame
common internal api header.
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
static const int8_t mc_dmodes[]
int nb_subframes
number of subframes in the current frame
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 plane data pointers and linesize for samples with sample format sample_fmt.
static int tak_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *pkt)
static const int16_t coeffs[]
int channels
number of audio channels
static const uint8_t * align_get_bits(GetBitContext *s)
static void set_sample_rate_params(AVCodecContext *avctx)
int8_t sample_shift[TAK_MAX_CHANNELS]
shift applied to every sample in the channel
static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
#define FFSWAP(type, a, b)
uint8_t ** extended_data
pointers to the data planes/channels.
This structure stores compressed data.
mode
Use these values in ebur128_init (or'ed).
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.