Add CLJR encoding and decoding regression tests
[libav.git] / libavcodec / tta.c
CommitLineData
a24c4a2a
AB
1/*
2 * TTA (The Lossless True Audio) decoder
3 * Copyright (c) 2006 Alex Beregszaszi
4 *
2912e87a 5 * This file is part of Libav.
b78e7197 6 *
2912e87a 7 * Libav is free software; you can redistribute it and/or
a24c4a2a
AB
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
a24c4a2a 11 *
2912e87a 12 * Libav is distributed in the hope that it will be useful,
a24c4a2a
AB
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
2912e87a 18 * License along with Libav; if not, write to the Free Software
e5a389a1 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
a24c4a2a
AB
20 */
21
22/**
ba87f080 23 * @file
a24c4a2a 24 * TTA (The Lossless True Audio) decoder
ad4cd0c2
DB
25 * @see http://www.true-audio.com/
26 * @see http://tta.corecodec.org/
a24c4a2a 27 * @author Alex Beregszaszi
a24c4a2a
AB
28 */
29
30#define ALT_BITSTREAM_READER_LE
31//#define DEBUG
32#include <limits.h>
33#include "avcodec.h"
9106a698 34#include "get_bits.h"
a24c4a2a 35
b16960a8
JR
36#define FORMAT_SIMPLE 1
37#define FORMAT_ENCRYPTED 2
a24c4a2a 38
5113b3bd
MR
39#define MAX_ORDER 16
40typedef struct TTAFilter {
41 int32_t shift, round, error, mode;
42 int32_t qm[MAX_ORDER];
43 int32_t dx[MAX_ORDER];
44 int32_t dl[MAX_ORDER];
45} TTAFilter;
46
47typedef struct TTARice {
48 uint32_t k0, k1, sum0, sum1;
49} TTARice;
50
51typedef struct TTAChannel {
52 int32_t predictor;
53 TTAFilter filter;
54 TTARice rice;
55} TTAChannel;
56
a24c4a2a
AB
57typedef struct TTAContext {
58 AVCodecContext *avctx;
0eea2129 59 AVFrame frame;
a24c4a2a
AB
60 GetBitContext gb;
61
b16960a8 62 int format, channels, bps, data_length;
a24c4a2a
AB
63 int frame_length, last_frame_length, total_frames;
64
79a32e3b 65 int32_t *decode_buffer;
5113b3bd 66
c058dc22 67 TTAChannel *ch_ctx;
a24c4a2a
AB
68} TTAContext;
69
79a32e3b 70static const uint32_t shift_1[] = {
a24c4a2a
AB
71 0x00000001, 0x00000002, 0x00000004, 0x00000008,
72 0x00000010, 0x00000020, 0x00000040, 0x00000080,
73 0x00000100, 0x00000200, 0x00000400, 0x00000800,
74 0x00001000, 0x00002000, 0x00004000, 0x00008000,
75 0x00010000, 0x00020000, 0x00040000, 0x00080000,
76 0x00100000, 0x00200000, 0x00400000, 0x00800000,
77 0x01000000, 0x02000000, 0x04000000, 0x08000000,
78 0x10000000, 0x20000000, 0x40000000, 0x80000000,
79 0x80000000, 0x80000000, 0x80000000, 0x80000000,
80 0x80000000, 0x80000000, 0x80000000, 0x80000000
81};
82
cf2baeb3 83static const uint32_t * const shift_16 = shift_1 + 4;
a24c4a2a 84
cf2baeb3 85static const int32_t ttafilter_configs[4][2] = {
a24c4a2a
AB
86 {10, 1},
87 {9, 1},
88 {10, 1},
89 {12, 0}
90};
91
79a32e3b 92static void ttafilter_init(TTAFilter *c, int32_t shift, int32_t mode) {
a24c4a2a
AB
93 memset(c, 0, sizeof(TTAFilter));
94 c->shift = shift;
95 c->round = shift_1[shift-1];
96// c->round = 1 << (shift - 1);
97 c->mode = mode;
98}
99
100// FIXME: copy paste from original
79a32e3b 101static inline void memshl(register int32_t *a, register int32_t *b) {
a24c4a2a
AB
102 *a++ = *b++;
103 *a++ = *b++;
104 *a++ = *b++;
105 *a++ = *b++;
106 *a++ = *b++;
107 *a++ = *b++;
108 *a++ = *b++;
109 *a = *b;
110}
111
112// FIXME: copy paste from original
113// mode=1 encoder, mode=0 decoder
79a32e3b
BL
114static inline void ttafilter_process(TTAFilter *c, int32_t *in, int32_t mode) {
115 register int32_t *dl = c->dl, *qm = c->qm, *dx = c->dx, sum = c->round;
a24c4a2a
AB
116
117 if (!c->error) {
118 sum += *dl++ * *qm, qm++;
119 sum += *dl++ * *qm, qm++;
120 sum += *dl++ * *qm, qm++;
121 sum += *dl++ * *qm, qm++;
122 sum += *dl++ * *qm, qm++;
123 sum += *dl++ * *qm, qm++;
124 sum += *dl++ * *qm, qm++;
125 sum += *dl++ * *qm, qm++;
126 dx += 8;
127 } else if(c->error < 0) {
128 sum += *dl++ * (*qm -= *dx++), qm++;
129 sum += *dl++ * (*qm -= *dx++), qm++;
130 sum += *dl++ * (*qm -= *dx++), qm++;
131 sum += *dl++ * (*qm -= *dx++), qm++;
132 sum += *dl++ * (*qm -= *dx++), qm++;
133 sum += *dl++ * (*qm -= *dx++), qm++;
134 sum += *dl++ * (*qm -= *dx++), qm++;
135 sum += *dl++ * (*qm -= *dx++), qm++;
136 } else {
137 sum += *dl++ * (*qm += *dx++), qm++;
138 sum += *dl++ * (*qm += *dx++), qm++;
139 sum += *dl++ * (*qm += *dx++), qm++;
140 sum += *dl++ * (*qm += *dx++), qm++;
141 sum += *dl++ * (*qm += *dx++), qm++;
142 sum += *dl++ * (*qm += *dx++), qm++;
143 sum += *dl++ * (*qm += *dx++), qm++;
144 sum += *dl++ * (*qm += *dx++), qm++;
145 }
146
147 *(dx-0) = ((*(dl-1) >> 30) | 1) << 2;
148 *(dx-1) = ((*(dl-2) >> 30) | 1) << 1;
149 *(dx-2) = ((*(dl-3) >> 30) | 1) << 1;
150 *(dx-3) = ((*(dl-4) >> 30) | 1);
151
152 // compress
153 if (mode) {
154 *dl = *in;
155 *in -= (sum >> c->shift);
156 c->error = *in;
157 } else {
158 c->error = *in;
159 *in += (sum >> c->shift);
160 *dl = *in;
161 }
162
163 if (c->mode) {
164 *(dl-1) = *dl - *(dl-1);
165 *(dl-2) = *(dl-1) - *(dl-2);
166 *(dl-3) = *(dl-2) - *(dl-3);
167 }
168
169 memshl(c->dl, c->dl + 1);
170 memshl(c->dx, c->dx + 1);
171}
172
79a32e3b 173static void rice_init(TTARice *c, uint32_t k0, uint32_t k1)
a24c4a2a
AB
174{
175 c->k0 = k0;
176 c->k1 = k1;
177 c->sum0 = shift_16[k0];
178 c->sum1 = shift_16[k1];
179}
180
181static int tta_get_unary(GetBitContext *gb)
182{
183 int ret = 0;
184
185 // count ones
35f9d8c2 186 while (get_bits_left(gb) > 0 && get_bits1(gb))
a24c4a2a
AB
187 ret++;
188 return ret;
189}
190
98a6fff9 191static av_cold int tta_decode_init(AVCodecContext * avctx)
a24c4a2a
AB
192{
193 TTAContext *s = avctx->priv_data;
194 int i;
195
196 s->avctx = avctx;
197
198 // 30bytes includes a seektable with one frame
199 if (avctx->extradata_size < 30)
200 return -1;
201
b59efc94 202 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);
2bb6eba2 203 if (show_bits_long(&s->gb, 32) == AV_RL32("TTA1"))
a24c4a2a
AB
204 {
205 /* signature */
206 skip_bits(&s->gb, 32);
a24c4a2a 207
b16960a8
JR
208 s->format = get_bits(&s->gb, 16);
209 if (s->format > 2) {
210 av_log(s->avctx, AV_LOG_ERROR, "Invalid format\n");
a24c4a2a
AB
211 return -1;
212 }
b16960a8
JR
213 if (s->format == FORMAT_ENCRYPTED) {
214 av_log_missing_feature(s->avctx, "Encrypted TTA", 0);
215 return AVERROR(EINVAL);
216 }
1a174c28 217 avctx->channels = s->channels = get_bits(&s->gb, 16);
dd1c8f3e
LA
218 avctx->bits_per_coded_sample = get_bits(&s->gb, 16);
219 s->bps = (avctx->bits_per_coded_sample + 7) / 8;
1a174c28 220 avctx->sample_rate = get_bits_long(&s->gb, 32);
1a174c28 221 s->data_length = get_bits_long(&s->gb, 32);
a24c4a2a
AB
222 skip_bits(&s->gb, 32); // CRC32 of header
223
b16960a8 224 switch(s->bps) {
c6056d40
JR
225 case 2:
226 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
227 avctx->bits_per_raw_sample = 16;
228 break;
229 case 3:
230 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
231 avctx->bits_per_raw_sample = 24;
232 break;
233 default:
234 av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported sample format.\n");
235 return AVERROR_INVALIDDATA;
a24c4a2a
AB
236 }
237
b5050539
JR
238 // prevent overflow
239 if (avctx->sample_rate > 0x7FFFFF) {
240 av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n");
241 return AVERROR(EINVAL);
242 }
243 s->frame_length = 256 * avctx->sample_rate / 245;
a24c4a2a
AB
244
245 s->last_frame_length = s->data_length % s->frame_length;
246 s->total_frames = s->data_length / s->frame_length +
247 (s->last_frame_length ? 1 : 0);
248
b16960a8
JR
249 av_log(s->avctx, AV_LOG_DEBUG, "format: %d chans: %d bps: %d rate: %d block: %d\n",
250 s->format, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate,
a24c4a2a
AB
251 avctx->block_align);
252 av_log(s->avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",
253 s->data_length, s->frame_length, s->last_frame_length, s->total_frames);
254
255 // FIXME: seek table
256 for (i = 0; i < s->total_frames; i++)
257 skip_bits(&s->gb, 32);
258 skip_bits(&s->gb, 32); // CRC32 of seektable
259
3a1a7e32
MN
260 if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){
261 av_log(avctx, AV_LOG_ERROR, "frame_length too large\n");
262 return -1;
263 }
264
c6056d40
JR
265 if (s->bps == 2) {
266 s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels);
2f1d212f
JR
267 if (!s->decode_buffer)
268 return AVERROR(ENOMEM);
c6056d40 269 }
5113b3bd 270 s->ch_ctx = av_malloc(avctx->channels * sizeof(*s->ch_ctx));
2f1d212f
JR
271 if (!s->ch_ctx) {
272 av_freep(&s->decode_buffer);
5113b3bd 273 return AVERROR(ENOMEM);
2f1d212f 274 }
a24c4a2a
AB
275 } else {
276 av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n");
277 return -1;
278 }
279
0eea2129
JR
280 avcodec_get_frame_defaults(&s->frame);
281 avctx->coded_frame = &s->frame;
282
a24c4a2a
AB
283 return 0;
284}
285
0eea2129
JR
286static int tta_decode_frame(AVCodecContext *avctx, void *data,
287 int *got_frame_ptr, AVPacket *avpkt)
a24c4a2a 288{
7a00bbad
TB
289 const uint8_t *buf = avpkt->data;
290 int buf_size = avpkt->size;
a24c4a2a 291 TTAContext *s = avctx->priv_data;
0eea2129 292 int i, ret;
7b7a74a1
JR
293 int cur_chan = 0, framelen = s->frame_length;
294 int32_t *p;
a24c4a2a
AB
295
296 init_get_bits(&s->gb, buf, buf_size*8);
a24c4a2a 297
8664682d
JR
298 // FIXME: seeking
299 s->total_frames--;
300 if (!s->total_frames && s->last_frame_length)
301 framelen = s->last_frame_length;
a24c4a2a 302
0eea2129
JR
303 /* get output buffer */
304 s->frame.nb_samples = framelen;
305 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
306 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
307 return ret;
8664682d
JR
308 }
309
c6056d40
JR
310 // decode directly to output buffer for 24-bit sample format
311 if (s->bps == 3)
312 s->decode_buffer = data;
313
8664682d
JR
314 // init per channel states
315 for (i = 0; i < s->channels; i++) {
316 s->ch_ctx[i].predictor = 0;
317 ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1][0], ttafilter_configs[s->bps-1][1]);
318 rice_init(&s->ch_ctx[i].rice, 10, 10);
319 }
e6923f68 320
8664682d
JR
321 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
322 int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
323 TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
324 TTARice *rice = &s->ch_ctx[cur_chan].rice;
325 uint32_t unary, depth, k;
326 int32_t value;
327
328 unary = tta_get_unary(&s->gb);
329
330 if (unary == 0) {
331 depth = 0;
332 k = rice->k0;
333 } else {
334 depth = 1;
335 k = rice->k1;
336 unary--;
a24c4a2a
AB
337 }
338
8664682d
JR
339 if (get_bits_left(&s->gb) < k)
340 return -1;
a24c4a2a 341
8664682d
JR
342 if (k) {
343 if (k > MIN_CACHE_BITS)
a9837b58 344 return -1;
8664682d
JR
345 value = (unary << k) + get_bits(&s->gb, k);
346 } else
347 value = unary;
348
349 // FIXME: copy paste from original
350 switch (depth) {
351 case 1:
352 rice->sum1 += value - (rice->sum1 >> 4);
353 if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
354 rice->k1--;
355 else if(rice->sum1 > shift_16[rice->k1 + 1])
356 rice->k1++;
357 value += shift_1[rice->k0];
358 default:
359 rice->sum0 += value - (rice->sum0 >> 4);
360 if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
361 rice->k0--;
362 else if(rice->sum0 > shift_16[rice->k0 + 1])
363 rice->k0++;
364 }
a9837b58 365
8664682d 366 // extract coded value
15e35274 367#define UNFOLD(x) (((x)&1) ? (++(x)>>1) : (-(x)>>1))
8664682d 368 *p = UNFOLD(value);
a24c4a2a 369
8664682d
JR
370 // run hybrid filter
371 ttafilter_process(filter, p, 0);
a24c4a2a 372
8664682d 373 // fixed order prediction
79a32e3b 374#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
8664682d
JR
375 switch (s->bps) {
376 case 1: *p += PRED(*predictor, 4); break;
377 case 2:
378 case 3: *p += PRED(*predictor, 5); break;
379 case 4: *p += *predictor; break;
380 }
381 *predictor = *p;
382
383 // flip channels
384 if (cur_chan < (s->channels-1))
385 cur_chan++;
386 else {
387 // decorrelate in case of stereo integer
388 if (s->channels > 1) {
389 int32_t *r = p - 1;
390 for (*p += *r / 2; r > p - s->channels; r--)
391 *r = *(r + 1) - *r;
a24c4a2a 392 }
8664682d 393 cur_chan = 0;
a24c4a2a 394 }
8664682d 395 }
a24c4a2a 396
8664682d
JR
397 if (get_bits_left(&s->gb) < 32)
398 return -1;
399 skip_bits(&s->gb, 32); // frame crc
400
401 // convert to output buffer
c6056d40 402 if (s->bps == 2) {
0eea2129 403 int16_t *samples = (int16_t *)s->frame.data[0];
c6056d40
JR
404 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
405 *samples++ = *p;
406 } else {
407 // shift samples for 24-bit sample format
0eea2129 408 int32_t *samples = (int32_t *)s->frame.data[0];
b656c4d0 409 for (i = 0; i < framelen * s->channels; i++)
c6056d40
JR
410 *samples++ <<= 8;
411 // reset decode buffer
412 s->decode_buffer = NULL;
8664682d 413 }
a24c4a2a 414
0eea2129
JR
415 *got_frame_ptr = 1;
416 *(AVFrame *)data = s->frame;
c6056d40 417
a24c4a2a
AB
418 return buf_size;
419}
420
98a6fff9 421static av_cold int tta_decode_close(AVCodecContext *avctx) {
a24c4a2a
AB
422 TTAContext *s = avctx->priv_data;
423
437fb1c8 424 av_free(s->decode_buffer);
5113b3bd 425 av_freep(&s->ch_ctx);
a24c4a2a
AB
426
427 return 0;
428}
429
d36beb3f 430AVCodec ff_tta_decoder = {
ec6402b7
AK
431 .name = "tta",
432 .type = AVMEDIA_TYPE_AUDIO,
433 .id = CODEC_ID_TTA,
434 .priv_data_size = sizeof(TTAContext),
435 .init = tta_decode_init,
436 .close = tta_decode_close,
437 .decode = tta_decode_frame,
0eea2129 438 .capabilities = CODEC_CAP_DR1,
68dddf53 439 .long_name = NULL_IF_CONFIG_SMALL("True Audio (TTA)"),
a24c4a2a 440};