avcodec: change number of plane pointers from 4 to 8 at next major bump.
[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;
59 GetBitContext gb;
60
b16960a8 61 int format, channels, bps, data_length;
a24c4a2a
AB
62 int frame_length, last_frame_length, total_frames;
63
79a32e3b 64 int32_t *decode_buffer;
5113b3bd 65
c058dc22 66 TTAChannel *ch_ctx;
a24c4a2a
AB
67} TTAContext;
68
79a32e3b 69static const uint32_t shift_1[] = {
a24c4a2a
AB
70 0x00000001, 0x00000002, 0x00000004, 0x00000008,
71 0x00000010, 0x00000020, 0x00000040, 0x00000080,
72 0x00000100, 0x00000200, 0x00000400, 0x00000800,
73 0x00001000, 0x00002000, 0x00004000, 0x00008000,
74 0x00010000, 0x00020000, 0x00040000, 0x00080000,
75 0x00100000, 0x00200000, 0x00400000, 0x00800000,
76 0x01000000, 0x02000000, 0x04000000, 0x08000000,
77 0x10000000, 0x20000000, 0x40000000, 0x80000000,
78 0x80000000, 0x80000000, 0x80000000, 0x80000000,
79 0x80000000, 0x80000000, 0x80000000, 0x80000000
80};
81
cf2baeb3 82static const uint32_t * const shift_16 = shift_1 + 4;
a24c4a2a 83
cf2baeb3 84static const int32_t ttafilter_configs[4][2] = {
a24c4a2a
AB
85 {10, 1},
86 {9, 1},
87 {10, 1},
88 {12, 0}
89};
90
79a32e3b 91static void ttafilter_init(TTAFilter *c, int32_t shift, int32_t mode) {
a24c4a2a
AB
92 memset(c, 0, sizeof(TTAFilter));
93 c->shift = shift;
94 c->round = shift_1[shift-1];
95// c->round = 1 << (shift - 1);
96 c->mode = mode;
97}
98
99// FIXME: copy paste from original
79a32e3b 100static inline void memshl(register int32_t *a, register int32_t *b) {
a24c4a2a
AB
101 *a++ = *b++;
102 *a++ = *b++;
103 *a++ = *b++;
104 *a++ = *b++;
105 *a++ = *b++;
106 *a++ = *b++;
107 *a++ = *b++;
108 *a = *b;
109}
110
111// FIXME: copy paste from original
112// mode=1 encoder, mode=0 decoder
79a32e3b
BL
113static inline void ttafilter_process(TTAFilter *c, int32_t *in, int32_t mode) {
114 register int32_t *dl = c->dl, *qm = c->qm, *dx = c->dx, sum = c->round;
a24c4a2a
AB
115
116 if (!c->error) {
117 sum += *dl++ * *qm, qm++;
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 dx += 8;
126 } else if(c->error < 0) {
127 sum += *dl++ * (*qm -= *dx++), qm++;
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 } else {
136 sum += *dl++ * (*qm += *dx++), qm++;
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 }
145
146 *(dx-0) = ((*(dl-1) >> 30) | 1) << 2;
147 *(dx-1) = ((*(dl-2) >> 30) | 1) << 1;
148 *(dx-2) = ((*(dl-3) >> 30) | 1) << 1;
149 *(dx-3) = ((*(dl-4) >> 30) | 1);
150
151 // compress
152 if (mode) {
153 *dl = *in;
154 *in -= (sum >> c->shift);
155 c->error = *in;
156 } else {
157 c->error = *in;
158 *in += (sum >> c->shift);
159 *dl = *in;
160 }
161
162 if (c->mode) {
163 *(dl-1) = *dl - *(dl-1);
164 *(dl-2) = *(dl-1) - *(dl-2);
165 *(dl-3) = *(dl-2) - *(dl-3);
166 }
167
168 memshl(c->dl, c->dl + 1);
169 memshl(c->dx, c->dx + 1);
170}
171
79a32e3b 172static void rice_init(TTARice *c, uint32_t k0, uint32_t k1)
a24c4a2a
AB
173{
174 c->k0 = k0;
175 c->k1 = k1;
176 c->sum0 = shift_16[k0];
177 c->sum1 = shift_16[k1];
178}
179
180static int tta_get_unary(GetBitContext *gb)
181{
182 int ret = 0;
183
184 // count ones
35f9d8c2 185 while (get_bits_left(gb) > 0 && get_bits1(gb))
a24c4a2a
AB
186 ret++;
187 return ret;
188}
189
98a6fff9 190static av_cold int tta_decode_init(AVCodecContext * avctx)
a24c4a2a
AB
191{
192 TTAContext *s = avctx->priv_data;
193 int i;
194
195 s->avctx = avctx;
196
197 // 30bytes includes a seektable with one frame
198 if (avctx->extradata_size < 30)
199 return -1;
200
b59efc94 201 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);
2bb6eba2 202 if (show_bits_long(&s->gb, 32) == AV_RL32("TTA1"))
a24c4a2a
AB
203 {
204 /* signature */
205 skip_bits(&s->gb, 32);
a24c4a2a 206
b16960a8
JR
207 s->format = get_bits(&s->gb, 16);
208 if (s->format > 2) {
209 av_log(s->avctx, AV_LOG_ERROR, "Invalid format\n");
a24c4a2a
AB
210 return -1;
211 }
b16960a8
JR
212 if (s->format == FORMAT_ENCRYPTED) {
213 av_log_missing_feature(s->avctx, "Encrypted TTA", 0);
214 return AVERROR(EINVAL);
215 }
1a174c28 216 avctx->channels = s->channels = get_bits(&s->gb, 16);
dd1c8f3e
LA
217 avctx->bits_per_coded_sample = get_bits(&s->gb, 16);
218 s->bps = (avctx->bits_per_coded_sample + 7) / 8;
1a174c28 219 avctx->sample_rate = get_bits_long(&s->gb, 32);
1a174c28 220 s->data_length = get_bits_long(&s->gb, 32);
a24c4a2a
AB
221 skip_bits(&s->gb, 32); // CRC32 of header
222
b16960a8 223 switch(s->bps) {
c6056d40
JR
224 case 2:
225 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
226 avctx->bits_per_raw_sample = 16;
227 break;
228 case 3:
229 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
230 avctx->bits_per_raw_sample = 24;
231 break;
232 default:
233 av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported sample format.\n");
234 return AVERROR_INVALIDDATA;
a24c4a2a
AB
235 }
236
b5050539
JR
237 // prevent overflow
238 if (avctx->sample_rate > 0x7FFFFF) {
239 av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n");
240 return AVERROR(EINVAL);
241 }
242 s->frame_length = 256 * avctx->sample_rate / 245;
a24c4a2a
AB
243
244 s->last_frame_length = s->data_length % s->frame_length;
245 s->total_frames = s->data_length / s->frame_length +
246 (s->last_frame_length ? 1 : 0);
247
b16960a8
JR
248 av_log(s->avctx, AV_LOG_DEBUG, "format: %d chans: %d bps: %d rate: %d block: %d\n",
249 s->format, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate,
a24c4a2a
AB
250 avctx->block_align);
251 av_log(s->avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",
252 s->data_length, s->frame_length, s->last_frame_length, s->total_frames);
253
254 // FIXME: seek table
255 for (i = 0; i < s->total_frames; i++)
256 skip_bits(&s->gb, 32);
257 skip_bits(&s->gb, 32); // CRC32 of seektable
258
3a1a7e32
MN
259 if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){
260 av_log(avctx, AV_LOG_ERROR, "frame_length too large\n");
261 return -1;
262 }
263
c6056d40
JR
264 if (s->bps == 2) {
265 s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels);
2f1d212f
JR
266 if (!s->decode_buffer)
267 return AVERROR(ENOMEM);
c6056d40 268 }
5113b3bd 269 s->ch_ctx = av_malloc(avctx->channels * sizeof(*s->ch_ctx));
2f1d212f
JR
270 if (!s->ch_ctx) {
271 av_freep(&s->decode_buffer);
5113b3bd 272 return AVERROR(ENOMEM);
2f1d212f 273 }
a24c4a2a
AB
274 } else {
275 av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n");
276 return -1;
277 }
278
279 return 0;
280}
281
282static int tta_decode_frame(AVCodecContext *avctx,
283 void *data, int *data_size,
7a00bbad 284 AVPacket *avpkt)
a24c4a2a 285{
7a00bbad
TB
286 const uint8_t *buf = avpkt->data;
287 int buf_size = avpkt->size;
a24c4a2a 288 TTAContext *s = avctx->priv_data;
c6056d40 289 int i, out_size;
7b7a74a1
JR
290 int cur_chan = 0, framelen = s->frame_length;
291 int32_t *p;
a24c4a2a
AB
292
293 init_get_bits(&s->gb, buf, buf_size*8);
a24c4a2a 294
8664682d
JR
295 // FIXME: seeking
296 s->total_frames--;
297 if (!s->total_frames && s->last_frame_length)
298 framelen = s->last_frame_length;
a24c4a2a 299
c6056d40
JR
300 out_size = framelen * s->channels * av_get_bytes_per_sample(avctx->sample_fmt);
301 if (*data_size < out_size) {
8664682d
JR
302 av_log(avctx, AV_LOG_ERROR, "Output buffer size is too small.\n");
303 return -1;
304 }
305
c6056d40
JR
306 // decode directly to output buffer for 24-bit sample format
307 if (s->bps == 3)
308 s->decode_buffer = data;
309
8664682d
JR
310 // init per channel states
311 for (i = 0; i < s->channels; i++) {
312 s->ch_ctx[i].predictor = 0;
313 ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1][0], ttafilter_configs[s->bps-1][1]);
314 rice_init(&s->ch_ctx[i].rice, 10, 10);
315 }
e6923f68 316
8664682d
JR
317 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
318 int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
319 TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
320 TTARice *rice = &s->ch_ctx[cur_chan].rice;
321 uint32_t unary, depth, k;
322 int32_t value;
323
324 unary = tta_get_unary(&s->gb);
325
326 if (unary == 0) {
327 depth = 0;
328 k = rice->k0;
329 } else {
330 depth = 1;
331 k = rice->k1;
332 unary--;
a24c4a2a
AB
333 }
334
8664682d
JR
335 if (get_bits_left(&s->gb) < k)
336 return -1;
a24c4a2a 337
8664682d
JR
338 if (k) {
339 if (k > MIN_CACHE_BITS)
a9837b58 340 return -1;
8664682d
JR
341 value = (unary << k) + get_bits(&s->gb, k);
342 } else
343 value = unary;
344
345 // FIXME: copy paste from original
346 switch (depth) {
347 case 1:
348 rice->sum1 += value - (rice->sum1 >> 4);
349 if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
350 rice->k1--;
351 else if(rice->sum1 > shift_16[rice->k1 + 1])
352 rice->k1++;
353 value += shift_1[rice->k0];
354 default:
355 rice->sum0 += value - (rice->sum0 >> 4);
356 if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
357 rice->k0--;
358 else if(rice->sum0 > shift_16[rice->k0 + 1])
359 rice->k0++;
360 }
a9837b58 361
8664682d 362 // extract coded value
15e35274 363#define UNFOLD(x) (((x)&1) ? (++(x)>>1) : (-(x)>>1))
8664682d 364 *p = UNFOLD(value);
a24c4a2a 365
8664682d
JR
366 // run hybrid filter
367 ttafilter_process(filter, p, 0);
a24c4a2a 368
8664682d 369 // fixed order prediction
79a32e3b 370#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
8664682d
JR
371 switch (s->bps) {
372 case 1: *p += PRED(*predictor, 4); break;
373 case 2:
374 case 3: *p += PRED(*predictor, 5); break;
375 case 4: *p += *predictor; break;
376 }
377 *predictor = *p;
378
379 // flip channels
380 if (cur_chan < (s->channels-1))
381 cur_chan++;
382 else {
383 // decorrelate in case of stereo integer
384 if (s->channels > 1) {
385 int32_t *r = p - 1;
386 for (*p += *r / 2; r > p - s->channels; r--)
387 *r = *(r + 1) - *r;
a24c4a2a 388 }
8664682d 389 cur_chan = 0;
a24c4a2a 390 }
8664682d 391 }
a24c4a2a 392
8664682d
JR
393 if (get_bits_left(&s->gb) < 32)
394 return -1;
395 skip_bits(&s->gb, 32); // frame crc
396
397 // convert to output buffer
c6056d40
JR
398 if (s->bps == 2) {
399 int16_t *samples = data;
400 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
401 *samples++ = *p;
402 } else {
403 // shift samples for 24-bit sample format
404 int32_t *samples = data;
b656c4d0 405 for (i = 0; i < framelen * s->channels; i++)
c6056d40
JR
406 *samples++ <<= 8;
407 // reset decode buffer
408 s->decode_buffer = NULL;
8664682d 409 }
a24c4a2a 410
c6056d40
JR
411 *data_size = out_size;
412
a24c4a2a
AB
413 return buf_size;
414}
415
98a6fff9 416static av_cold int tta_decode_close(AVCodecContext *avctx) {
a24c4a2a
AB
417 TTAContext *s = avctx->priv_data;
418
437fb1c8 419 av_free(s->decode_buffer);
5113b3bd 420 av_freep(&s->ch_ctx);
a24c4a2a
AB
421
422 return 0;
423}
424
d36beb3f 425AVCodec ff_tta_decoder = {
ec6402b7
AK
426 .name = "tta",
427 .type = AVMEDIA_TYPE_AUDIO,
428 .id = CODEC_ID_TTA,
429 .priv_data_size = sizeof(TTAContext),
430 .init = tta_decode_init,
431 .close = tta_decode_close,
432 .decode = tta_decode_frame,
68dddf53 433 .long_name = NULL_IF_CONFIG_SMALL("True Audio (TTA)"),
a24c4a2a 434};