x86: cabac: add operand size suffixes missing from 6c32576
[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
AB
35
36#define FORMAT_INT 1
37#define FORMAT_FLOAT 3
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
61 int flags, channels, bps, is_float, data_length;
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
185 while(get_bits1(gb))
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
201 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size);
2bb6eba2 202 if (show_bits_long(&s->gb, 32) == AV_RL32("TTA1"))
a24c4a2a
AB
203 {
204 /* signature */
205 skip_bits(&s->gb, 32);
8fc0162a 206// if (get_bits_long(&s->gb, 32) != av_bswap32(AV_RL32("TTA1"))) {
a24c4a2a
AB
207// av_log(s->avctx, AV_LOG_ERROR, "Missing magic\n");
208// return -1;
209// }
210
1a174c28 211 s->flags = get_bits(&s->gb, 16);
a24c4a2a
AB
212 if (s->flags != 1 && s->flags != 3)
213 {
214 av_log(s->avctx, AV_LOG_ERROR, "Invalid flags\n");
215 return -1;
216 }
217 s->is_float = (s->flags == FORMAT_FLOAT);
1a174c28 218 avctx->channels = s->channels = get_bits(&s->gb, 16);
dd1c8f3e
LA
219 avctx->bits_per_coded_sample = get_bits(&s->gb, 16);
220 s->bps = (avctx->bits_per_coded_sample + 7) / 8;
1a174c28 221 avctx->sample_rate = get_bits_long(&s->gb, 32);
3a1a7e32
MN
222 if(avctx->sample_rate > 1000000){ //prevent FRAME_TIME * avctx->sample_rate from overflowing and sanity check
223 av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n");
224 return -1;
225 }
1a174c28 226 s->data_length = get_bits_long(&s->gb, 32);
a24c4a2a
AB
227 skip_bits(&s->gb, 32); // CRC32 of header
228
229 if (s->is_float)
230 {
5d6e4c16 231 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
70fb031c 232 av_log_ask_for_sample(s->avctx, "Unsupported sample format.\n");
a24c4a2a
AB
233 return -1;
234 }
235 else switch(s->bps) {
5d6e4c16
SS
236// case 1: avctx->sample_fmt = AV_SAMPLE_FMT_U8; break;
237 case 2: avctx->sample_fmt = AV_SAMPLE_FMT_S16; break;
238// case 3: avctx->sample_fmt = AV_SAMPLE_FMT_S24; break;
239 case 4: avctx->sample_fmt = AV_SAMPLE_FMT_S32; break;
a24c4a2a 240 default:
70fb031c
DB
241 av_log_ask_for_sample(s->avctx,
242 "Invalid/unsupported sample format.\n");
a24c4a2a
AB
243 return -1;
244 }
245
246 // FIXME: horribly broken, but directly from reference source
247#define FRAME_TIME 1.04489795918367346939
248 s->frame_length = (int)(FRAME_TIME * avctx->sample_rate);
249
250 s->last_frame_length = s->data_length % s->frame_length;
251 s->total_frames = s->data_length / s->frame_length +
252 (s->last_frame_length ? 1 : 0);
253
254 av_log(s->avctx, AV_LOG_DEBUG, "flags: %x chans: %d bps: %d rate: %d block: %d\n",
dd1c8f3e 255 s->flags, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate,
a24c4a2a
AB
256 avctx->block_align);
257 av_log(s->avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n",
258 s->data_length, s->frame_length, s->last_frame_length, s->total_frames);
259
260 // FIXME: seek table
261 for (i = 0; i < s->total_frames; i++)
262 skip_bits(&s->gb, 32);
263 skip_bits(&s->gb, 32); // CRC32 of seektable
264
3a1a7e32
MN
265 if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){
266 av_log(avctx, AV_LOG_ERROR, "frame_length too large\n");
267 return -1;
268 }
269
79a32e3b 270 s->decode_buffer = av_mallocz(sizeof(int32_t)*s->frame_length*s->channels);
5113b3bd
MR
271 s->ch_ctx = av_malloc(avctx->channels * sizeof(*s->ch_ctx));
272 if (!s->ch_ctx)
273 return AVERROR(ENOMEM);
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
AB
288 TTAContext *s = avctx->priv_data;
289 int i;
290
291 init_get_bits(&s->gb, buf, buf_size*8);
292 {
a24c4a2a 293 int cur_chan = 0, framelen = s->frame_length;
79a32e3b 294 int32_t *p;
a24c4a2a 295
bac6ed4a 296 if (*data_size < (framelen * s->channels * 2)) {
a0d5f3d3 297 av_log(avctx, AV_LOG_ERROR, "Output buffer size is too small.\n");
bac6ed4a
JM
298 return -1;
299 }
a24c4a2a
AB
300 // FIXME: seeking
301 s->total_frames--;
302 if (!s->total_frames && s->last_frame_length)
303 framelen = s->last_frame_length;
304
305 // init per channel states
306 for (i = 0; i < s->channels; i++) {
5113b3bd
MR
307 s->ch_ctx[i].predictor = 0;
308 ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1][0], ttafilter_configs[s->bps-1][1]);
309 rice_init(&s->ch_ctx[i].rice, 10, 10);
a24c4a2a
AB
310 }
311
312 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
5113b3bd
MR
313 int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
314 TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
315 TTARice *rice = &s->ch_ctx[cur_chan].rice;
79a32e3b
BL
316 uint32_t unary, depth, k;
317 int32_t value;
a24c4a2a
AB
318
319 unary = tta_get_unary(&s->gb);
320
321 if (unary == 0) {
322 depth = 0;
323 k = rice->k0;
324 } else {
325 depth = 1;
326 k = rice->k1;
327 unary--;
328 }
329
a9837b58
LA
330 if (get_bits_left(&s->gb) < k)
331 return -1;
332
333 if (k) {
334 if (k > MIN_CACHE_BITS)
335 return -1;
a24c4a2a 336 value = (unary << k) + get_bits(&s->gb, k);
a9837b58 337 } else
a24c4a2a
AB
338 value = unary;
339
340 // FIXME: copy paste from original
341 switch (depth) {
342 case 1:
343 rice->sum1 += value - (rice->sum1 >> 4);
344 if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
345 rice->k1--;
346 else if(rice->sum1 > shift_16[rice->k1 + 1])
347 rice->k1++;
348 value += shift_1[rice->k0];
349 default:
350 rice->sum0 += value - (rice->sum0 >> 4);
351 if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
352 rice->k0--;
353 else if(rice->sum0 > shift_16[rice->k0 + 1])
354 rice->k0++;
355 }
356
15e35274
DB
357 // extract coded value
358#define UNFOLD(x) (((x)&1) ? (++(x)>>1) : (-(x)>>1))
359 *p = UNFOLD(value);
a24c4a2a
AB
360
361 // run hybrid filter
362 ttafilter_process(filter, p, 0);
363
364 // fixed order prediction
79a32e3b 365#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
a24c4a2a
AB
366 switch (s->bps) {
367 case 1: *p += PRED(*predictor, 4); break;
368 case 2:
369 case 3: *p += PRED(*predictor, 5); break;
370 case 4: *p += *predictor; break;
371 }
372 *predictor = *p;
373
a24c4a2a
AB
374 /*if ((get_bits_count(&s->gb)+7)/8 > buf_size)
375 {
376 av_log(NULL, AV_LOG_INFO, "overread!!\n");
377 break;
378 }*/
379
380 // flip channels
381 if (cur_chan < (s->channels-1))
382 cur_chan++;
383 else {
384 // decorrelate in case of stereo integer
385 if (!s->is_float && (s->channels > 1)) {
79a32e3b 386 int32_t *r = p - 1;
a24c4a2a
AB
387 for (*p += *r / 2; r > p - s->channels; r--)
388 *r = *(r + 1) - *r;
389 }
390 cur_chan = 0;
391 }
392 }
393
a9837b58
LA
394 if (get_bits_left(&s->gb) < 32)
395 return -1;
a24c4a2a
AB
396 skip_bits(&s->gb, 32); // frame crc
397
398 // convert to output buffer
399 switch(s->bps) {
400 case 2: {
401 uint16_t *samples = data;
402 for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
403// *samples++ = (unsigned char)*p;
404// *samples++ = (unsigned char)(*p >> 8);
405 *samples++ = *p;
406 }
407 *data_size = (uint8_t *)samples - (uint8_t *)data;
408 break;
409 }
410 default:
411 av_log(s->avctx, AV_LOG_ERROR, "Error, only 16bit samples supported!\n");
412 }
413 }
414
415// return get_bits_count(&s->gb)+7)/8;
416 return buf_size;
417}
418
98a6fff9 419static av_cold int tta_decode_close(AVCodecContext *avctx) {
a24c4a2a
AB
420 TTAContext *s = avctx->priv_data;
421
437fb1c8 422 av_free(s->decode_buffer);
5113b3bd 423 av_freep(&s->ch_ctx);
a24c4a2a
AB
424
425 return 0;
426}
427
d36beb3f 428AVCodec ff_tta_decoder = {
a24c4a2a 429 "tta",
72415b2a 430 AVMEDIA_TYPE_AUDIO,
a24c4a2a
AB
431 CODEC_ID_TTA,
432 sizeof(TTAContext),
433 tta_decode_init,
434 NULL,
435 tta_decode_close,
436 tta_decode_frame,
68dddf53 437 .long_name = NULL_IF_CONFIG_SMALL("True Audio (TTA)"),
a24c4a2a 438};