wavpack: add needed braces for 2 statements inside an if block
[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
aaf47bcd 30#define BITSTREAM_READER_LE
a24c4a2a
AB
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;
a24c4a2a
AB
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 */
9aff2d17 205 skip_bits_long(&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);
9aff2d17 221 skip_bits_long(&s->gb, 32); // CRC32 of header
a24c4a2a 222
8bd1f1a4
SG
223 if (s->channels == 0) {
224 av_log(s->avctx, AV_LOG_ERROR, "Invalid number of channels\n");
225 return AVERROR_INVALIDDATA;
226 }
227
b16960a8 228 switch(s->bps) {
c6056d40
JR
229 case 2:
230 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
231 avctx->bits_per_raw_sample = 16;
232 break;
233 case 3:
234 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
235 avctx->bits_per_raw_sample = 24;
236 break;
237 default:
238 av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported sample format.\n");
239 return AVERROR_INVALIDDATA;
a24c4a2a
AB
240 }
241
b5050539
JR
242 // prevent overflow
243 if (avctx->sample_rate > 0x7FFFFF) {
244 av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n");
245 return AVERROR(EINVAL);
246 }
247 s->frame_length = 256 * avctx->sample_rate / 245;
a24c4a2a
AB
248
249 s->last_frame_length = s->data_length % s->frame_length;
250 s->total_frames = s->data_length / s->frame_length +
251 (s->last_frame_length ? 1 : 0);
252
b16960a8
JR
253 av_log(s->avctx, AV_LOG_DEBUG, "format: %d chans: %d bps: %d rate: %d block: %d\n",
254 s->format, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate,
a24c4a2a
AB
255 avctx->block_align);
256 av_log(s->avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",
257 s->data_length, s->frame_length, s->last_frame_length, s->total_frames);
258
259 // FIXME: seek table
9aff2d17
PM
260 skip_bits_long(&s->gb, 32 * s->total_frames);
261 skip_bits_long(&s->gb, 32); // CRC32 of seektable
a24c4a2a 262
3a1a7e32
MN
263 if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){
264 av_log(avctx, AV_LOG_ERROR, "frame_length too large\n");
265 return -1;
266 }
267
c6056d40
JR
268 if (s->bps == 2) {
269 s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels);
2f1d212f
JR
270 if (!s->decode_buffer)
271 return AVERROR(ENOMEM);
c6056d40 272 }
5113b3bd 273 s->ch_ctx = av_malloc(avctx->channels * sizeof(*s->ch_ctx));
2f1d212f
JR
274 if (!s->ch_ctx) {
275 av_freep(&s->decode_buffer);
5113b3bd 276 return AVERROR(ENOMEM);
2f1d212f 277 }
a24c4a2a
AB
278 } else {
279 av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n");
280 return -1;
281 }
282
0eea2129
JR
283 avcodec_get_frame_defaults(&s->frame);
284 avctx->coded_frame = &s->frame;
285
a24c4a2a
AB
286 return 0;
287}
288
0eea2129
JR
289static int tta_decode_frame(AVCodecContext *avctx, void *data,
290 int *got_frame_ptr, AVPacket *avpkt)
a24c4a2a 291{
7a00bbad
TB
292 const uint8_t *buf = avpkt->data;
293 int buf_size = avpkt->size;
a24c4a2a 294 TTAContext *s = avctx->priv_data;
0eea2129 295 int i, ret;
7b7a74a1
JR
296 int cur_chan = 0, framelen = s->frame_length;
297 int32_t *p;
a24c4a2a
AB
298
299 init_get_bits(&s->gb, buf, buf_size*8);
a24c4a2a 300
8664682d
JR
301 // FIXME: seeking
302 s->total_frames--;
303 if (!s->total_frames && s->last_frame_length)
304 framelen = s->last_frame_length;
a24c4a2a 305
0eea2129
JR
306 /* get output buffer */
307 s->frame.nb_samples = framelen;
308 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
309 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
310 return ret;
8664682d
JR
311 }
312
c6056d40
JR
313 // decode directly to output buffer for 24-bit sample format
314 if (s->bps == 3)
01ed1c39 315 s->decode_buffer = (int32_t *)s->frame.data[0];
c6056d40 316
8664682d
JR
317 // init per channel states
318 for (i = 0; i < s->channels; i++) {
319 s->ch_ctx[i].predictor = 0;
320 ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1][0], ttafilter_configs[s->bps-1][1]);
321 rice_init(&s->ch_ctx[i].rice, 10, 10);
322 }
e6923f68 323
8664682d
JR
324 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
325 int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
326 TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
327 TTARice *rice = &s->ch_ctx[cur_chan].rice;
328 uint32_t unary, depth, k;
329 int32_t value;
330
331 unary = tta_get_unary(&s->gb);
332
333 if (unary == 0) {
334 depth = 0;
335 k = rice->k0;
336 } else {
337 depth = 1;
338 k = rice->k1;
339 unary--;
a24c4a2a
AB
340 }
341
8664682d
JR
342 if (get_bits_left(&s->gb) < k)
343 return -1;
a24c4a2a 344
8664682d
JR
345 if (k) {
346 if (k > MIN_CACHE_BITS)
a9837b58 347 return -1;
8664682d
JR
348 value = (unary << k) + get_bits(&s->gb, k);
349 } else
350 value = unary;
351
352 // FIXME: copy paste from original
353 switch (depth) {
354 case 1:
355 rice->sum1 += value - (rice->sum1 >> 4);
356 if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
357 rice->k1--;
358 else if(rice->sum1 > shift_16[rice->k1 + 1])
359 rice->k1++;
360 value += shift_1[rice->k0];
361 default:
362 rice->sum0 += value - (rice->sum0 >> 4);
363 if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
364 rice->k0--;
365 else if(rice->sum0 > shift_16[rice->k0 + 1])
366 rice->k0++;
367 }
a9837b58 368
8664682d 369 // extract coded value
15e35274 370#define UNFOLD(x) (((x)&1) ? (++(x)>>1) : (-(x)>>1))
8664682d 371 *p = UNFOLD(value);
a24c4a2a 372
8664682d
JR
373 // run hybrid filter
374 ttafilter_process(filter, p, 0);
a24c4a2a 375
8664682d 376 // fixed order prediction
79a32e3b 377#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
8664682d
JR
378 switch (s->bps) {
379 case 1: *p += PRED(*predictor, 4); break;
380 case 2:
381 case 3: *p += PRED(*predictor, 5); break;
382 case 4: *p += *predictor; break;
383 }
384 *predictor = *p;
385
386 // flip channels
387 if (cur_chan < (s->channels-1))
388 cur_chan++;
389 else {
390 // decorrelate in case of stereo integer
391 if (s->channels > 1) {
392 int32_t *r = p - 1;
393 for (*p += *r / 2; r > p - s->channels; r--)
394 *r = *(r + 1) - *r;
a24c4a2a 395 }
8664682d 396 cur_chan = 0;
a24c4a2a 397 }
8664682d 398 }
a24c4a2a 399
8664682d
JR
400 if (get_bits_left(&s->gb) < 32)
401 return -1;
9aff2d17 402 skip_bits_long(&s->gb, 32); // frame crc
8664682d
JR
403
404 // convert to output buffer
c6056d40 405 if (s->bps == 2) {
0eea2129 406 int16_t *samples = (int16_t *)s->frame.data[0];
c6056d40
JR
407 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
408 *samples++ = *p;
409 } else {
410 // shift samples for 24-bit sample format
0eea2129 411 int32_t *samples = (int32_t *)s->frame.data[0];
b656c4d0 412 for (i = 0; i < framelen * s->channels; i++)
c6056d40
JR
413 *samples++ <<= 8;
414 // reset decode buffer
415 s->decode_buffer = NULL;
8664682d 416 }
a24c4a2a 417
0eea2129
JR
418 *got_frame_ptr = 1;
419 *(AVFrame *)data = s->frame;
c6056d40 420
a24c4a2a
AB
421 return buf_size;
422}
423
98a6fff9 424static av_cold int tta_decode_close(AVCodecContext *avctx) {
a24c4a2a
AB
425 TTAContext *s = avctx->priv_data;
426
437fb1c8 427 av_free(s->decode_buffer);
5113b3bd 428 av_freep(&s->ch_ctx);
a24c4a2a
AB
429
430 return 0;
431}
432
d36beb3f 433AVCodec ff_tta_decoder = {
ec6402b7
AK
434 .name = "tta",
435 .type = AVMEDIA_TYPE_AUDIO,
436 .id = CODEC_ID_TTA,
437 .priv_data_size = sizeof(TTAContext),
438 .init = tta_decode_init,
439 .close = tta_decode_close,
440 .decode = tta_decode_frame,
0eea2129 441 .capabilities = CODEC_CAP_DR1,
68dddf53 442 .long_name = NULL_IF_CONFIG_SMALL("True Audio (TTA)"),
a24c4a2a 443};