1 |
|
|
/* |
2 |
|
|
* TTA (The Lossless True Audio) decoder |
3 |
|
|
* Copyright (c) 2006 Alex Beregszaszi |
4 |
|
|
* |
5 |
|
|
* This file is part of FFmpeg. |
6 |
|
|
* |
7 |
|
|
* FFmpeg is free software; you can redistribute it and/or |
8 |
|
|
* modify it under the terms of the GNU Lesser General Public |
9 |
|
|
* License as published by the Free Software Foundation; either |
10 |
|
|
* version 2.1 of the License, or (at your option) any later version. |
11 |
|
|
* |
12 |
|
|
* FFmpeg is distributed in the hope that it will be useful, |
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 |
18 |
|
|
* License along with FFmpeg; if not, write to the Free Software |
19 |
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
20 |
|
|
*/ |
21 |
|
|
|
22 |
|
|
/** |
23 |
|
|
* @file |
24 |
|
|
* TTA (The Lossless True Audio) decoder |
25 |
|
|
* @see http://www.true-audio.com/ |
26 |
|
|
* @see http://tta.corecodec.org/ |
27 |
|
|
* @author Alex Beregszaszi |
28 |
|
|
*/ |
29 |
|
|
|
30 |
|
|
#include <limits.h> |
31 |
|
|
|
32 |
|
|
#include "libavutil/crc.h" |
33 |
|
|
#include "libavutil/intreadwrite.h" |
34 |
|
|
#include "libavutil/opt.h" |
35 |
|
|
|
36 |
|
|
#define BITSTREAM_READER_LE |
37 |
|
|
#include "ttadata.h" |
38 |
|
|
#include "ttadsp.h" |
39 |
|
|
#include "avcodec.h" |
40 |
|
|
#include "get_bits.h" |
41 |
|
|
#include "thread.h" |
42 |
|
|
#include "unary.h" |
43 |
|
|
#include "internal.h" |
44 |
|
|
|
45 |
|
|
#define FORMAT_SIMPLE 1 |
46 |
|
|
#define FORMAT_ENCRYPTED 2 |
47 |
|
|
|
48 |
|
|
typedef struct TTAContext { |
49 |
|
|
AVClass *class; |
50 |
|
|
AVCodecContext *avctx; |
51 |
|
|
const AVCRC *crc_table; |
52 |
|
|
|
53 |
|
|
int format, channels, bps; |
54 |
|
|
unsigned data_length; |
55 |
|
|
int frame_length, last_frame_length; |
56 |
|
|
|
57 |
|
|
int32_t *decode_buffer; |
58 |
|
|
|
59 |
|
|
uint8_t crc_pass[8]; |
60 |
|
|
uint8_t *pass; |
61 |
|
|
TTAChannel *ch_ctx; |
62 |
|
|
TTADSPContext dsp; |
63 |
|
|
} TTAContext; |
64 |
|
|
|
65 |
|
|
static const int64_t tta_channel_layouts[7] = { |
66 |
|
|
AV_CH_LAYOUT_STEREO, |
67 |
|
|
AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY, |
68 |
|
|
AV_CH_LAYOUT_QUAD, |
69 |
|
|
0, |
70 |
|
|
AV_CH_LAYOUT_5POINT1_BACK, |
71 |
|
|
AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER, |
72 |
|
|
AV_CH_LAYOUT_7POINT1_WIDE |
73 |
|
|
}; |
74 |
|
|
|
75 |
|
|
static int tta_check_crc(TTAContext *s, const uint8_t *buf, int buf_size) |
76 |
|
|
{ |
77 |
|
|
uint32_t crc, CRC; |
78 |
|
|
|
79 |
|
|
CRC = AV_RL32(buf + buf_size); |
80 |
|
|
crc = av_crc(s->crc_table, 0xFFFFFFFFU, buf, buf_size); |
81 |
|
|
if (CRC != (crc ^ 0xFFFFFFFFU)) { |
82 |
|
|
av_log(s->avctx, AV_LOG_ERROR, "CRC error\n"); |
83 |
|
|
return AVERROR_INVALIDDATA; |
84 |
|
|
} |
85 |
|
|
|
86 |
|
|
return 0; |
87 |
|
|
} |
88 |
|
|
|
89 |
|
2 |
static uint64_t tta_check_crc64(uint8_t *pass) |
90 |
|
|
{ |
91 |
|
2 |
uint64_t crc = UINT64_MAX, poly = 0x42F0E1EBA9EA3693U; |
92 |
|
2 |
uint8_t *end = pass + strlen(pass); |
93 |
|
|
int i; |
94 |
|
|
|
95 |
✓✓ |
14 |
while (pass < end) { |
96 |
|
12 |
crc ^= (uint64_t)*pass++ << 56; |
97 |
✓✓ |
108 |
for (i = 0; i < 8; i++) |
98 |
|
96 |
crc = (crc << 1) ^ (poly & (((int64_t) crc) >> 63)); |
99 |
|
|
} |
100 |
|
|
|
101 |
|
2 |
return crc ^ UINT64_MAX; |
102 |
|
|
} |
103 |
|
|
|
104 |
|
20 |
static int allocate_buffers(AVCodecContext *avctx) |
105 |
|
|
{ |
106 |
|
20 |
TTAContext *s = avctx->priv_data; |
107 |
|
|
|
108 |
✓✗ |
20 |
if (s->bps < 3) { |
109 |
|
20 |
s->decode_buffer = av_mallocz_array(sizeof(int32_t)*s->frame_length, s->channels); |
110 |
✗✓ |
20 |
if (!s->decode_buffer) |
111 |
|
|
return AVERROR(ENOMEM); |
112 |
|
|
} else |
113 |
|
|
s->decode_buffer = NULL; |
114 |
|
20 |
s->ch_ctx = av_malloc_array(avctx->channels, sizeof(*s->ch_ctx)); |
115 |
✗✓ |
20 |
if (!s->ch_ctx) { |
116 |
|
|
av_freep(&s->decode_buffer); |
117 |
|
|
return AVERROR(ENOMEM); |
118 |
|
|
} |
119 |
|
|
|
120 |
|
20 |
return 0; |
121 |
|
|
} |
122 |
|
|
|
123 |
|
20 |
static av_cold int tta_decode_init(AVCodecContext * avctx) |
124 |
|
|
{ |
125 |
|
20 |
TTAContext *s = avctx->priv_data; |
126 |
|
|
GetBitContext gb; |
127 |
|
|
int total_frames; |
128 |
|
|
int ret; |
129 |
|
|
|
130 |
|
20 |
s->avctx = avctx; |
131 |
|
|
|
132 |
|
|
// 22 bytes for a TTA1 header |
133 |
✗✓ |
20 |
if (avctx->extradata_size < 22) |
134 |
|
|
return AVERROR_INVALIDDATA; |
135 |
|
|
|
136 |
|
20 |
s->crc_table = av_crc_get_table(AV_CRC_32_IEEE_LE); |
137 |
|
20 |
ret = init_get_bits8(&gb, avctx->extradata, avctx->extradata_size); |
138 |
✗✓ |
20 |
if (ret < 0) |
139 |
|
|
return ret; |
140 |
|
|
|
141 |
✓✗ |
20 |
if (show_bits_long(&gb, 32) == AV_RL32("TTA1")) { |
142 |
|
|
/* signature */ |
143 |
|
20 |
skip_bits_long(&gb, 32); |
144 |
|
|
|
145 |
|
20 |
s->format = get_bits(&gb, 16); |
146 |
✗✓ |
20 |
if (s->format > 2) { |
147 |
|
|
av_log(avctx, AV_LOG_ERROR, "Invalid format\n"); |
148 |
|
|
return AVERROR_INVALIDDATA; |
149 |
|
|
} |
150 |
✓✓ |
20 |
if (s->format == FORMAT_ENCRYPTED) { |
151 |
✗✓ |
2 |
if (!s->pass) { |
152 |
|
|
av_log(avctx, AV_LOG_ERROR, "Missing password for encrypted stream. Please use the -password option\n"); |
153 |
|
|
return AVERROR(EINVAL); |
154 |
|
|
} |
155 |
|
2 |
AV_WL64(s->crc_pass, tta_check_crc64(s->pass)); |
156 |
|
|
} |
157 |
|
20 |
avctx->channels = s->channels = get_bits(&gb, 16); |
158 |
✓✓✓✗
|
20 |
if (s->channels > 1 && s->channels < 9) |
159 |
|
16 |
avctx->channel_layout = tta_channel_layouts[s->channels-2]; |
160 |
|
20 |
avctx->bits_per_raw_sample = get_bits(&gb, 16); |
161 |
|
20 |
s->bps = (avctx->bits_per_raw_sample + 7) / 8; |
162 |
|
20 |
avctx->sample_rate = get_bits_long(&gb, 32); |
163 |
|
20 |
s->data_length = get_bits_long(&gb, 32); |
164 |
|
20 |
skip_bits_long(&gb, 32); // CRC32 of header |
165 |
|
|
|
166 |
✓✗✗✓
|
20 |
if (s->channels == 0 || s->channels > 16) { |
167 |
|
|
av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n"); |
168 |
|
|
return AVERROR_INVALIDDATA; |
169 |
✗✓ |
20 |
} else if (avctx->sample_rate == 0) { |
170 |
|
|
av_log(avctx, AV_LOG_ERROR, "Invalid samplerate\n"); |
171 |
|
|
return AVERROR_INVALIDDATA; |
172 |
|
|
} |
173 |
|
|
|
174 |
✗✓✗✗
|
20 |
switch(s->bps) { |
175 |
|
|
case 1: avctx->sample_fmt = AV_SAMPLE_FMT_U8; break; |
176 |
|
20 |
case 2: |
177 |
|
20 |
avctx->sample_fmt = AV_SAMPLE_FMT_S16; |
178 |
|
20 |
break; |
179 |
|
|
case 3: |
180 |
|
|
avctx->sample_fmt = AV_SAMPLE_FMT_S32; |
181 |
|
|
break; |
182 |
|
|
//case 4: avctx->sample_fmt = AV_SAMPLE_FMT_S32; break; |
183 |
|
|
default: |
184 |
|
|
av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported sample format.\n"); |
185 |
|
|
return AVERROR_INVALIDDATA; |
186 |
|
|
} |
187 |
|
|
|
188 |
|
|
// prevent overflow |
189 |
✗✓ |
20 |
if (avctx->sample_rate > 0x7FFFFFu) { |
190 |
|
|
av_log(avctx, AV_LOG_ERROR, "sample_rate too large\n"); |
191 |
|
|
return AVERROR(EINVAL); |
192 |
|
|
} |
193 |
|
20 |
s->frame_length = 256 * avctx->sample_rate / 245; |
194 |
|
|
|
195 |
|
20 |
s->last_frame_length = s->data_length % s->frame_length; |
196 |
|
40 |
total_frames = s->data_length / s->frame_length + |
197 |
✓✗ |
20 |
(s->last_frame_length ? 1 : 0); |
198 |
|
|
|
199 |
|
20 |
av_log(avctx, AV_LOG_DEBUG, "format: %d chans: %d bps: %d rate: %d block: %d\n", |
200 |
|
|
s->format, avctx->channels, avctx->bits_per_coded_sample, avctx->sample_rate, |
201 |
|
|
avctx->block_align); |
202 |
|
20 |
av_log(avctx, AV_LOG_DEBUG, "data_length: %d frame_length: %d last: %d total: %d\n", |
203 |
|
|
s->data_length, s->frame_length, s->last_frame_length, total_frames); |
204 |
|
|
|
205 |
✗✓ |
20 |
if(s->frame_length >= UINT_MAX / (s->channels * sizeof(int32_t))){ |
206 |
|
|
av_log(avctx, AV_LOG_ERROR, "frame_length too large\n"); |
207 |
|
|
return AVERROR_INVALIDDATA; |
208 |
|
|
} |
209 |
|
|
} else { |
210 |
|
|
av_log(avctx, AV_LOG_ERROR, "Wrong extradata present\n"); |
211 |
|
|
return AVERROR_INVALIDDATA; |
212 |
|
|
} |
213 |
|
|
|
214 |
|
20 |
ff_ttadsp_init(&s->dsp); |
215 |
|
|
|
216 |
|
20 |
return allocate_buffers(avctx); |
217 |
|
|
} |
218 |
|
|
|
219 |
|
46 |
static int tta_decode_frame(AVCodecContext *avctx, void *data, |
220 |
|
|
int *got_frame_ptr, AVPacket *avpkt) |
221 |
|
|
{ |
222 |
|
46 |
AVFrame *frame = data; |
223 |
|
46 |
ThreadFrame tframe = { .f = data }; |
224 |
|
46 |
const uint8_t *buf = avpkt->data; |
225 |
|
46 |
int buf_size = avpkt->size; |
226 |
|
46 |
TTAContext *s = avctx->priv_data; |
227 |
|
|
GetBitContext gb; |
228 |
|
|
int i, ret; |
229 |
|
46 |
int cur_chan = 0, framelen = s->frame_length; |
230 |
|
|
uint32_t *p; |
231 |
|
|
|
232 |
✗✓ |
46 |
if (avctx->err_recognition & AV_EF_CRCCHECK) { |
233 |
|
|
if (buf_size < 4 || |
234 |
|
|
(tta_check_crc(s, buf, buf_size - 4) && avctx->err_recognition & AV_EF_EXPLODE)) |
235 |
|
|
return AVERROR_INVALIDDATA; |
236 |
|
|
} |
237 |
|
|
|
238 |
✗✓ |
46 |
if ((ret = init_get_bits8(&gb, avpkt->data, avpkt->size)) < 0) |
239 |
|
|
return ret; |
240 |
|
|
|
241 |
|
|
/* get output buffer */ |
242 |
|
46 |
frame->nb_samples = framelen; |
243 |
✗✓ |
46 |
if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0) |
244 |
|
|
return ret; |
245 |
|
|
|
246 |
|
|
// decode directly to output buffer for 24-bit sample format |
247 |
✗✓ |
46 |
if (s->bps == 3) |
248 |
|
|
s->decode_buffer = (int32_t *)frame->data[0]; |
249 |
|
|
|
250 |
|
|
// init per channel states |
251 |
✓✓ |
134 |
for (i = 0; i < s->channels; i++) { |
252 |
|
88 |
TTAFilter *filter = &s->ch_ctx[i].filter; |
253 |
|
88 |
s->ch_ctx[i].predictor = 0; |
254 |
|
88 |
ff_tta_filter_init(filter, ff_tta_filter_configs[s->bps-1]); |
255 |
✓✓ |
88 |
if (s->format == FORMAT_ENCRYPTED) { |
256 |
|
|
int i; |
257 |
✓✓ |
162 |
for (i = 0; i < 8; i++) |
258 |
|
144 |
filter->qm[i] = sign_extend(s->crc_pass[i], 8); |
259 |
|
|
} |
260 |
|
88 |
ff_tta_rice_init(&s->ch_ctx[i].rice, 10, 10); |
261 |
|
|
} |
262 |
|
|
|
263 |
|
46 |
i = 0; |
264 |
✓✓ |
3824146 |
for (p = s->decode_buffer; (int32_t*)p < s->decode_buffer + (framelen * s->channels); p++) { |
265 |
|
3824108 |
int32_t *predictor = &s->ch_ctx[cur_chan].predictor; |
266 |
|
3824108 |
TTAFilter *filter = &s->ch_ctx[cur_chan].filter; |
267 |
|
3824108 |
TTARice *rice = &s->ch_ctx[cur_chan].rice; |
268 |
|
|
uint32_t unary, depth, k; |
269 |
|
|
int32_t value; |
270 |
|
|
|
271 |
|
3824108 |
unary = get_unary(&gb, 0, get_bits_left(&gb)); |
272 |
|
|
|
273 |
✓✓ |
3824108 |
if (unary == 0) { |
274 |
|
1800079 |
depth = 0; |
275 |
|
1800079 |
k = rice->k0; |
276 |
|
|
} else { |
277 |
|
2024029 |
depth = 1; |
278 |
|
2024029 |
k = rice->k1; |
279 |
|
2024029 |
unary--; |
280 |
|
|
} |
281 |
|
|
|
282 |
✗✓ |
3824108 |
if (get_bits_left(&gb) < k) { |
283 |
|
|
ret = AVERROR_INVALIDDATA; |
284 |
|
|
goto error; |
285 |
|
|
} |
286 |
|
|
|
287 |
✓✓ |
3824108 |
if (k) { |
288 |
✓✗✗✓
|
3602502 |
if (k > MIN_CACHE_BITS || unary > INT32_MAX >> k) { |
289 |
|
|
ret = AVERROR_INVALIDDATA; |
290 |
|
|
goto error; |
291 |
|
|
} |
292 |
|
3602502 |
value = (unary << k) + get_bits(&gb, k); |
293 |
|
|
} else |
294 |
|
221606 |
value = unary; |
295 |
|
|
|
296 |
|
|
// FIXME: copy paste from original |
297 |
✓✓ |
3824108 |
switch (depth) { |
298 |
|
2024029 |
case 1: |
299 |
|
2024029 |
rice->sum1 += value - (rice->sum1 >> 4); |
300 |
✓✓✓✓
|
2024029 |
if (rice->k1 > 0 && rice->sum1 < ff_tta_shift_16[rice->k1]) |
301 |
|
55307 |
rice->k1--; |
302 |
✓✓ |
1968722 |
else if(rice->sum1 > ff_tta_shift_16[rice->k1 + 1]) |
303 |
|
54952 |
rice->k1++; |
304 |
|
2024029 |
value += ff_tta_shift_1[rice->k0]; |
305 |
|
3824108 |
default: |
306 |
|
3824108 |
rice->sum0 += value - (rice->sum0 >> 4); |
307 |
✓✓✓✓
|
3824108 |
if (rice->k0 > 0 && rice->sum0 < ff_tta_shift_16[rice->k0]) |
308 |
|
105062 |
rice->k0--; |
309 |
✓✓ |
3719046 |
else if(rice->sum0 > ff_tta_shift_16[rice->k0 + 1]) |
310 |
|
104701 |
rice->k0++; |
311 |
|
|
} |
312 |
|
|
|
313 |
|
|
// extract coded value |
314 |
|
3824108 |
*p = 1 + ((value >> 1) ^ ((value & 1) - 1)); |
315 |
|
|
|
316 |
|
|
// run hybrid filter |
317 |
|
3824108 |
s->dsp.filter_process(filter->qm, filter->dx, filter->dl, &filter->error, p, |
318 |
|
|
filter->shift, filter->round); |
319 |
|
|
|
320 |
|
|
// fixed order prediction |
321 |
|
|
#define PRED(x, k) (int32_t)((((uint64_t)(x) << (k)) - (x)) >> (k)) |
322 |
✗✓✗✗
|
3824108 |
switch (s->bps) { |
323 |
|
|
case 1: *p += PRED(*predictor, 4); break; |
324 |
|
3824108 |
case 2: |
325 |
|
3824108 |
case 3: *p += PRED(*predictor, 5); break; |
326 |
|
|
case 4: *p += *predictor; break; |
327 |
|
|
} |
328 |
|
3824108 |
*predictor = *p; |
329 |
|
|
|
330 |
|
|
// flip channels |
331 |
✓✓ |
3824108 |
if (cur_chan < (s->channels-1)) |
332 |
|
1823854 |
cur_chan++; |
333 |
|
|
else { |
334 |
|
|
// decorrelate in case of multiple channels |
335 |
✓✓ |
2000254 |
if (s->channels > 1) { |
336 |
|
1823854 |
int32_t *r = p - 1; |
337 |
✓✓ |
3647708 |
for (*p += *r / 2; r > (int32_t*)p - s->channels; r--) |
338 |
|
1823854 |
*r = *(r + 1) - *r; |
339 |
|
|
} |
340 |
|
2000254 |
cur_chan = 0; |
341 |
|
2000254 |
i++; |
342 |
|
|
// check for last frame |
343 |
✓✓✓✓
|
2000254 |
if (i == s->last_frame_length && get_bits_left(&gb) / 8 == 4) { |
344 |
|
8 |
frame->nb_samples = framelen = s->last_frame_length; |
345 |
|
8 |
break; |
346 |
|
|
} |
347 |
|
|
} |
348 |
|
|
} |
349 |
|
|
|
350 |
|
46 |
align_get_bits(&gb); |
351 |
✗✓ |
46 |
if (get_bits_left(&gb) < 32) { |
352 |
|
|
ret = AVERROR_INVALIDDATA; |
353 |
|
|
goto error; |
354 |
|
|
} |
355 |
|
46 |
skip_bits_long(&gb, 32); // frame crc |
356 |
|
|
|
357 |
|
|
// convert to output buffer |
358 |
✗✓✗✗
|
46 |
switch (s->bps) { |
359 |
|
|
case 1: { |
360 |
|
|
uint8_t *samples = (uint8_t *)frame->data[0]; |
361 |
|
|
for (p = s->decode_buffer; (int32_t*)p < s->decode_buffer + (framelen * s->channels); p++) |
362 |
|
|
*samples++ = *p + 0x80; |
363 |
|
|
break; |
364 |
|
|
} |
365 |
|
46 |
case 2: { |
366 |
|
46 |
int16_t *samples = (int16_t *)frame->data[0]; |
367 |
✓✓ |
3824154 |
for (p = s->decode_buffer; (int32_t*)p < s->decode_buffer + (framelen * s->channels); p++) |
368 |
|
3824108 |
*samples++ = *p; |
369 |
|
46 |
break; |
370 |
|
|
} |
371 |
|
|
case 3: { |
372 |
|
|
// shift samples for 24-bit sample format |
373 |
|
|
int32_t *samples = (int32_t *)frame->data[0]; |
374 |
|
|
for (i = 0; i < framelen * s->channels; i++) |
375 |
|
|
*samples++ *= 256; |
376 |
|
|
// reset decode buffer |
377 |
|
|
s->decode_buffer = NULL; |
378 |
|
|
break; |
379 |
|
|
} |
380 |
|
|
} |
381 |
|
|
|
382 |
|
46 |
*got_frame_ptr = 1; |
383 |
|
|
|
384 |
|
46 |
return buf_size; |
385 |
|
|
error: |
386 |
|
|
// reset decode buffer |
387 |
|
|
if (s->bps == 3) |
388 |
|
|
s->decode_buffer = NULL; |
389 |
|
|
return ret; |
390 |
|
|
} |
391 |
|
|
|
392 |
|
20 |
static av_cold int tta_decode_close(AVCodecContext *avctx) { |
393 |
|
20 |
TTAContext *s = avctx->priv_data; |
394 |
|
|
|
395 |
✓✗ |
20 |
if (s->bps < 3) |
396 |
|
20 |
av_freep(&s->decode_buffer); |
397 |
|
20 |
s->decode_buffer = NULL; |
398 |
|
20 |
av_freep(&s->ch_ctx); |
399 |
|
|
|
400 |
|
20 |
return 0; |
401 |
|
|
} |
402 |
|
|
|
403 |
|
|
#define OFFSET(x) offsetof(TTAContext, x) |
404 |
|
|
#define DEC (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM) |
405 |
|
|
static const AVOption options[] = { |
406 |
|
|
{ "password", "Set decoding password", OFFSET(pass), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, DEC }, |
407 |
|
|
{ NULL }, |
408 |
|
|
}; |
409 |
|
|
|
410 |
|
|
static const AVClass tta_decoder_class = { |
411 |
|
|
.class_name = "TTA Decoder", |
412 |
|
|
.item_name = av_default_item_name, |
413 |
|
|
.option = options, |
414 |
|
|
.version = LIBAVUTIL_VERSION_INT, |
415 |
|
|
}; |
416 |
|
|
|
417 |
|
|
AVCodec ff_tta_decoder = { |
418 |
|
|
.name = "tta", |
419 |
|
|
.long_name = NULL_IF_CONFIG_SMALL("TTA (True Audio)"), |
420 |
|
|
.type = AVMEDIA_TYPE_AUDIO, |
421 |
|
|
.id = AV_CODEC_ID_TTA, |
422 |
|
|
.priv_data_size = sizeof(TTAContext), |
423 |
|
|
.init = tta_decode_init, |
424 |
|
|
.close = tta_decode_close, |
425 |
|
|
.decode = tta_decode_frame, |
426 |
|
|
.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_CHANNEL_CONF, |
427 |
|
|
.priv_class = &tta_decoder_class, |
428 |
|
|
}; |