Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * TAK decoder | ||
3 | * Copyright (c) 2012 Paul B Mahol | ||
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 | * TAK (Tom's lossless Audio Kompressor) decoder | ||
25 | * @author Paul B Mahol | ||
26 | */ | ||
27 | |||
28 | #include "libavutil/internal.h" | ||
29 | #include "libavutil/mem.h" | ||
30 | #include "libavutil/mem_internal.h" | ||
31 | #include "libavutil/samplefmt.h" | ||
32 | |||
33 | #define CACHED_BITSTREAM_READER !ARCH_X86_32 | ||
34 | #define BITSTREAM_READER_LE | ||
35 | #include "audiodsp.h" | ||
36 | #include "thread.h" | ||
37 | #include "avcodec.h" | ||
38 | #include "codec_internal.h" | ||
39 | #include "unary.h" | ||
40 | #include "tak.h" | ||
41 | #include "takdsp.h" | ||
42 | |||
43 | #define MAX_SUBFRAMES 8 ///< max number of subframes per channel | ||
44 | #define MAX_PREDICTORS 256 | ||
45 | |||
46 | typedef struct MCDParam { | ||
47 | int8_t present; ///< decorrelation parameter availability for this channel | ||
48 | int8_t index; ///< index into array of decorrelation types | ||
49 | int8_t chan1; | ||
50 | int8_t chan2; | ||
51 | } MCDParam; | ||
52 | |||
53 | typedef struct TAKDecContext { | ||
54 | AVCodecContext *avctx; ///< parent AVCodecContext | ||
55 | AudioDSPContext adsp; | ||
56 | TAKDSPContext tdsp; | ||
57 | TAKStreamInfo ti; | ||
58 | GetBitContext gb; ///< bitstream reader initialized to start at the current frame | ||
59 | |||
60 | int uval; | ||
61 | int nb_samples; ///< number of samples in the current frame | ||
62 | uint8_t *decode_buffer; | ||
63 | unsigned int decode_buffer_size; | ||
64 | int32_t *decoded[TAK_MAX_CHANNELS]; ///< decoded samples for each channel | ||
65 | |||
66 | int8_t lpc_mode[TAK_MAX_CHANNELS]; | ||
67 | int8_t sample_shift[TAK_MAX_CHANNELS]; ///< shift applied to every sample in the channel | ||
68 | int16_t predictors[MAX_PREDICTORS]; | ||
69 | int nb_subframes; ///< number of subframes in the current frame | ||
70 | int16_t subframe_len[MAX_SUBFRAMES]; ///< subframe length in samples | ||
71 | int subframe_scale; | ||
72 | |||
73 | int8_t dmode; ///< channel decorrelation type in the current frame | ||
74 | |||
75 | MCDParam mcdparams[TAK_MAX_CHANNELS]; ///< multichannel decorrelation parameters | ||
76 | |||
77 | int8_t coding_mode[128]; | ||
78 | DECLARE_ALIGNED(16, int16_t, filter)[MAX_PREDICTORS]; | ||
79 | DECLARE_ALIGNED(16, int16_t, residues)[544]; | ||
80 | } TAKDecContext; | ||
81 | |||
82 | static const int8_t mc_dmodes[] = { 1, 3, 4, 6, }; | ||
83 | |||
84 | static const uint16_t predictor_sizes[] = { | ||
85 | 4, 8, 12, 16, 24, 32, 48, 64, 80, 96, 128, 160, 192, 224, 256, 0, | ||
86 | }; | ||
87 | |||
88 | static const struct CParam { | ||
89 | int init; | ||
90 | int escape; | ||
91 | int scale; | ||
92 | int aescape; | ||
93 | int bias; | ||
94 | } xcodes[50] = { | ||
95 | { 0x01, 0x0000001, 0x0000001, 0x0000003, 0x0000008 }, | ||
96 | { 0x02, 0x0000003, 0x0000001, 0x0000007, 0x0000006 }, | ||
97 | { 0x03, 0x0000005, 0x0000002, 0x000000E, 0x000000D }, | ||
98 | { 0x03, 0x0000003, 0x0000003, 0x000000D, 0x0000018 }, | ||
99 | { 0x04, 0x000000B, 0x0000004, 0x000001C, 0x0000019 }, | ||
100 | { 0x04, 0x0000006, 0x0000006, 0x000001A, 0x0000030 }, | ||
101 | { 0x05, 0x0000016, 0x0000008, 0x0000038, 0x0000032 }, | ||
102 | { 0x05, 0x000000C, 0x000000C, 0x0000034, 0x0000060 }, | ||
103 | { 0x06, 0x000002C, 0x0000010, 0x0000070, 0x0000064 }, | ||
104 | { 0x06, 0x0000018, 0x0000018, 0x0000068, 0x00000C0 }, | ||
105 | { 0x07, 0x0000058, 0x0000020, 0x00000E0, 0x00000C8 }, | ||
106 | { 0x07, 0x0000030, 0x0000030, 0x00000D0, 0x0000180 }, | ||
107 | { 0x08, 0x00000B0, 0x0000040, 0x00001C0, 0x0000190 }, | ||
108 | { 0x08, 0x0000060, 0x0000060, 0x00001A0, 0x0000300 }, | ||
109 | { 0x09, 0x0000160, 0x0000080, 0x0000380, 0x0000320 }, | ||
110 | { 0x09, 0x00000C0, 0x00000C0, 0x0000340, 0x0000600 }, | ||
111 | { 0x0A, 0x00002C0, 0x0000100, 0x0000700, 0x0000640 }, | ||
112 | { 0x0A, 0x0000180, 0x0000180, 0x0000680, 0x0000C00 }, | ||
113 | { 0x0B, 0x0000580, 0x0000200, 0x0000E00, 0x0000C80 }, | ||
114 | { 0x0B, 0x0000300, 0x0000300, 0x0000D00, 0x0001800 }, | ||
115 | { 0x0C, 0x0000B00, 0x0000400, 0x0001C00, 0x0001900 }, | ||
116 | { 0x0C, 0x0000600, 0x0000600, 0x0001A00, 0x0003000 }, | ||
117 | { 0x0D, 0x0001600, 0x0000800, 0x0003800, 0x0003200 }, | ||
118 | { 0x0D, 0x0000C00, 0x0000C00, 0x0003400, 0x0006000 }, | ||
119 | { 0x0E, 0x0002C00, 0x0001000, 0x0007000, 0x0006400 }, | ||
120 | { 0x0E, 0x0001800, 0x0001800, 0x0006800, 0x000C000 }, | ||
121 | { 0x0F, 0x0005800, 0x0002000, 0x000E000, 0x000C800 }, | ||
122 | { 0x0F, 0x0003000, 0x0003000, 0x000D000, 0x0018000 }, | ||
123 | { 0x10, 0x000B000, 0x0004000, 0x001C000, 0x0019000 }, | ||
124 | { 0x10, 0x0006000, 0x0006000, 0x001A000, 0x0030000 }, | ||
125 | { 0x11, 0x0016000, 0x0008000, 0x0038000, 0x0032000 }, | ||
126 | { 0x11, 0x000C000, 0x000C000, 0x0034000, 0x0060000 }, | ||
127 | { 0x12, 0x002C000, 0x0010000, 0x0070000, 0x0064000 }, | ||
128 | { 0x12, 0x0018000, 0x0018000, 0x0068000, 0x00C0000 }, | ||
129 | { 0x13, 0x0058000, 0x0020000, 0x00E0000, 0x00C8000 }, | ||
130 | { 0x13, 0x0030000, 0x0030000, 0x00D0000, 0x0180000 }, | ||
131 | { 0x14, 0x00B0000, 0x0040000, 0x01C0000, 0x0190000 }, | ||
132 | { 0x14, 0x0060000, 0x0060000, 0x01A0000, 0x0300000 }, | ||
133 | { 0x15, 0x0160000, 0x0080000, 0x0380000, 0x0320000 }, | ||
134 | { 0x15, 0x00C0000, 0x00C0000, 0x0340000, 0x0600000 }, | ||
135 | { 0x16, 0x02C0000, 0x0100000, 0x0700000, 0x0640000 }, | ||
136 | { 0x16, 0x0180000, 0x0180000, 0x0680000, 0x0C00000 }, | ||
137 | { 0x17, 0x0580000, 0x0200000, 0x0E00000, 0x0C80000 }, | ||
138 | { 0x17, 0x0300000, 0x0300000, 0x0D00000, 0x1800000 }, | ||
139 | { 0x18, 0x0B00000, 0x0400000, 0x1C00000, 0x1900000 }, | ||
140 | { 0x18, 0x0600000, 0x0600000, 0x1A00000, 0x3000000 }, | ||
141 | { 0x19, 0x1600000, 0x0800000, 0x3800000, 0x3200000 }, | ||
142 | { 0x19, 0x0C00000, 0x0C00000, 0x3400000, 0x6000000 }, | ||
143 | { 0x1A, 0x2C00000, 0x1000000, 0x7000000, 0x6400000 }, | ||
144 | { 0x1A, 0x1800000, 0x1800000, 0x6800000, 0xC000000 }, | ||
145 | }; | ||
146 | |||
147 | 41 | static int set_bps_params(AVCodecContext *avctx) | |
148 | { | ||
149 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 41 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
41 | switch (avctx->bits_per_raw_sample) { |
150 | ✗ | case 8: | |
151 | ✗ | avctx->sample_fmt = AV_SAMPLE_FMT_U8P; | |
152 | ✗ | break; | |
153 | 41 | case 16: | |
154 | 41 | avctx->sample_fmt = AV_SAMPLE_FMT_S16P; | |
155 | 41 | break; | |
156 | ✗ | case 24: | |
157 | ✗ | avctx->sample_fmt = AV_SAMPLE_FMT_S32P; | |
158 | ✗ | break; | |
159 | ✗ | default: | |
160 | ✗ | av_log(avctx, AV_LOG_ERROR, "invalid/unsupported bits per sample: %d\n", | |
161 | avctx->bits_per_raw_sample); | ||
162 | ✗ | return AVERROR_INVALIDDATA; | |
163 | } | ||
164 | |||
165 | 41 | return 0; | |
166 | } | ||
167 | |||
168 | 2 | static void set_sample_rate_params(AVCodecContext *avctx) | |
169 | { | ||
170 | 2 | TAKDecContext *s = avctx->priv_data; | |
171 | int shift; | ||
172 | |||
173 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (avctx->sample_rate < 11025) { |
174 | ✗ | shift = 3; | |
175 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | } else if (avctx->sample_rate < 22050) { |
176 | ✗ | shift = 2; | |
177 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | } else if (avctx->sample_rate < 44100) { |
178 | ✗ | shift = 1; | |
179 | } else { | ||
180 | 2 | shift = 0; | |
181 | } | ||
182 | 2 | s->uval = FFALIGN(avctx->sample_rate + 511LL >> 9, 4) << shift; | |
183 | 2 | s->subframe_scale = FFALIGN(avctx->sample_rate + 511LL >> 9, 4) << 1; | |
184 | 2 | } | |
185 | |||
186 | 2 | static av_cold int tak_decode_init(AVCodecContext *avctx) | |
187 | { | ||
188 | 2 | TAKDecContext *s = avctx->priv_data; | |
189 | |||
190 | 2 | ff_audiodsp_init(&s->adsp); | |
191 | 2 | ff_takdsp_init(&s->tdsp); | |
192 | |||
193 | 2 | s->avctx = avctx; | |
194 | 2 | avctx->bits_per_raw_sample = avctx->bits_per_coded_sample; | |
195 | |||
196 | 2 | set_sample_rate_params(avctx); | |
197 | |||
198 | 2 | return set_bps_params(avctx); | |
199 | } | ||
200 | |||
201 | 124 | static void decode_lpc(int32_t *coeffs, int mode, int length) | |
202 | { | ||
203 | int i; | ||
204 | |||
205 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 124 times.
|
124 | if (length < 2) |
206 | ✗ | return; | |
207 | |||
208 |
2/2✓ Branch 0 taken 117 times.
✓ Branch 1 taken 7 times.
|
124 | if (mode == 1) { |
209 | 117 | unsigned a1 = *coeffs++; | |
210 |
2/2✓ Branch 0 taken 431059 times.
✓ Branch 1 taken 117 times.
|
431176 | for (i = 0; i < length - 1 >> 1; i++) { |
211 | 431059 | *coeffs += a1; | |
212 | 431059 | coeffs[1] += (unsigned)*coeffs; | |
213 | 431059 | a1 = coeffs[1]; | |
214 | 431059 | coeffs += 2; | |
215 | } | ||
216 |
2/2✓ Branch 0 taken 39 times.
✓ Branch 1 taken 78 times.
|
117 | if (length - 1 & 1) |
217 | 39 | *coeffs += a1; | |
218 |
1/2✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
|
7 | } else if (mode == 2) { |
219 | 7 | unsigned a1 = coeffs[1]; | |
220 | 7 | unsigned a2 = a1 + *coeffs; | |
221 | 7 | coeffs[1] = a2; | |
222 |
1/2✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
|
7 | if (length > 2) { |
223 | 7 | coeffs += 2; | |
224 |
2/2✓ Branch 0 taken 251 times.
✓ Branch 1 taken 7 times.
|
258 | for (i = 0; i < length - 2 >> 1; i++) { |
225 | 251 | unsigned a3 = *coeffs + a1; | |
226 | 251 | unsigned a4 = a3 + a2; | |
227 | 251 | *coeffs = a4; | |
228 | 251 | a1 = coeffs[1] + a3; | |
229 | 251 | a2 = a1 + a4; | |
230 | 251 | coeffs[1] = a2; | |
231 | 251 | coeffs += 2; | |
232 | } | ||
233 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
|
7 | if (length & 1) |
234 | ✗ | *coeffs += a1 + a2; | |
235 | } | ||
236 | ✗ | } else if (mode == 3) { | |
237 | ✗ | unsigned a1 = coeffs[1]; | |
238 | ✗ | unsigned a2 = a1 + *coeffs; | |
239 | ✗ | coeffs[1] = a2; | |
240 | ✗ | if (length > 2) { | |
241 | ✗ | unsigned a3 = coeffs[2]; | |
242 | ✗ | unsigned a4 = a3 + a1; | |
243 | ✗ | unsigned a5 = a4 + a2; | |
244 | ✗ | coeffs[2] = a5; | |
245 | ✗ | coeffs += 3; | |
246 | ✗ | for (i = 0; i < length - 3; i++) { | |
247 | ✗ | a3 += *coeffs; | |
248 | ✗ | a4 += a3; | |
249 | ✗ | a5 += a4; | |
250 | ✗ | *coeffs = a5; | |
251 | ✗ | coeffs++; | |
252 | } | ||
253 | } | ||
254 | } | ||
255 | } | ||
256 | |||
257 | 3970 | static int decode_segment(TAKDecContext *s, int8_t mode, int32_t *decoded, int len) | |
258 | { | ||
259 | struct CParam code; | ||
260 | 3970 | GetBitContext *gb = &s->gb; | |
261 | int i; | ||
262 | |||
263 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3970 times.
|
3970 | if (!mode) { |
264 | ✗ | memset(decoded, 0, len * sizeof(*decoded)); | |
265 | ✗ | return 0; | |
266 | } | ||
267 | |||
268 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3970 times.
|
3970 | if (mode > FF_ARRAY_ELEMS(xcodes)) |
269 | ✗ | return AVERROR_INVALIDDATA; | |
270 | 3970 | code = xcodes[mode - 1]; | |
271 | |||
272 |
2/2✓ Branch 0 taken 859872 times.
✓ Branch 1 taken 3970 times.
|
863842 | for (i = 0; i < len; i++) { |
273 | 859872 | unsigned x = get_bits_long(gb, code.init); | |
274 |
4/4✓ Branch 0 taken 404333 times.
✓ Branch 1 taken 455539 times.
✓ Branch 3 taken 186781 times.
✓ Branch 4 taken 217552 times.
|
859872 | if (x >= code.escape && get_bits1(gb)) { |
275 | 186781 | x |= 1 << code.init; | |
276 |
2/2✓ Branch 0 taken 138466 times.
✓ Branch 1 taken 48315 times.
|
186781 | if (x >= code.aescape) { |
277 | 138466 | unsigned scale = get_unary(gb, 1, 9); | |
278 |
2/2✓ Branch 0 taken 164 times.
✓ Branch 1 taken 138302 times.
|
138466 | if (scale == 9) { |
279 | 164 | int scale_bits = get_bits(gb, 3); | |
280 |
2/2✓ Branch 0 taken 109 times.
✓ Branch 1 taken 55 times.
|
164 | if (scale_bits > 0) { |
281 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 109 times.
|
109 | if (scale_bits == 7) { |
282 | ✗ | scale_bits += get_bits(gb, 5); | |
283 | ✗ | if (scale_bits > 29) | |
284 | ✗ | return AVERROR_INVALIDDATA; | |
285 | } | ||
286 | 109 | scale = get_bits_long(gb, scale_bits) + 1; | |
287 | 109 | x += code.scale * scale; | |
288 | } | ||
289 | 164 | x += code.bias; | |
290 | } else | ||
291 | 138302 | x += code.scale * scale - code.escape; | |
292 | } else | ||
293 | 48315 | x -= code.escape; | |
294 | } | ||
295 | 859872 | decoded[i] = (x >> 1) ^ -(x & 1); | |
296 | } | ||
297 | |||
298 | 3970 | return 0; | |
299 | } | ||
300 | |||
301 | 346 | static int decode_residues(TAKDecContext *s, int32_t *decoded, int length) | |
302 | { | ||
303 | 346 | GetBitContext *gb = &s->gb; | |
304 | int i, mode, ret; | ||
305 | |||
306 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 346 times.
|
346 | if (length > s->nb_samples) |
307 | ✗ | return AVERROR_INVALIDDATA; | |
308 | |||
309 |
2/2✓ Branch 1 taken 252 times.
✓ Branch 2 taken 94 times.
|
346 | if (get_bits1(gb)) { |
310 | int wlength, rval; | ||
311 | |||
312 | 252 | wlength = length / s->uval; | |
313 | |||
314 | 252 | rval = length - (wlength * s->uval); | |
315 | |||
316 |
2/2✓ Branch 0 taken 210 times.
✓ Branch 1 taken 42 times.
|
252 | if (rval < s->uval / 2) |
317 | 210 | rval += s->uval; | |
318 | else | ||
319 | 42 | wlength++; | |
320 | |||
321 |
2/4✓ Branch 0 taken 252 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 252 times.
|
252 | if (wlength <= 1 || wlength > 128) |
322 | ✗ | return AVERROR_INVALIDDATA; | |
323 | |||
324 | 252 | s->coding_mode[0] = mode = get_bits(gb, 6); | |
325 | |||
326 |
2/2✓ Branch 0 taken 8799 times.
✓ Branch 1 taken 252 times.
|
9051 | for (i = 1; i < wlength; i++) { |
327 | 8799 | int c = get_unary(gb, 1, 6); | |
328 | |||
329 |
4/5✗ Branch 0 not taken.
✓ Branch 1 taken 238 times.
✓ Branch 2 taken 1625 times.
✓ Branch 3 taken 1761 times.
✓ Branch 4 taken 5175 times.
|
8799 | switch (c) { |
330 | ✗ | case 6: | |
331 | ✗ | mode = get_bits(gb, 6); | |
332 | ✗ | break; | |
333 | 238 | case 5: | |
334 | case 4: | ||
335 | case 3: { | ||
336 | /* mode += sign ? (1 - c) : (c - 1) */ | ||
337 | 238 | int sign = get_bits1(gb); | |
338 | 238 | mode += (-sign ^ (c - 1)) + sign; | |
339 | 238 | break; | |
340 | } | ||
341 | 1625 | case 2: | |
342 | 1625 | mode++; | |
343 | 1625 | break; | |
344 | 1761 | case 1: | |
345 | 1761 | mode--; | |
346 | 1761 | break; | |
347 | } | ||
348 | 8799 | s->coding_mode[i] = mode; | |
349 | } | ||
350 | |||
351 | 252 | i = 0; | |
352 |
2/2✓ Branch 0 taken 3876 times.
✓ Branch 1 taken 252 times.
|
4128 | while (i < wlength) { |
353 | 3876 | int len = 0; | |
354 | |||
355 | 3876 | mode = s->coding_mode[i]; | |
356 | do { | ||
357 |
2/2✓ Branch 0 taken 252 times.
✓ Branch 1 taken 8799 times.
|
9051 | if (i >= wlength - 1) |
358 | 252 | len += rval; | |
359 | else | ||
360 | 8799 | len += s->uval; | |
361 | 9051 | i++; | |
362 | |||
363 |
2/2✓ Branch 0 taken 252 times.
✓ Branch 1 taken 8799 times.
|
9051 | if (i == wlength) |
364 | 252 | break; | |
365 |
2/2✓ Branch 0 taken 5175 times.
✓ Branch 1 taken 3624 times.
|
8799 | } while (s->coding_mode[i] == mode); |
366 | |||
367 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 3876 times.
|
3876 | if ((ret = decode_segment(s, mode, decoded, len)) < 0) |
368 | ✗ | return ret; | |
369 | 3876 | decoded += len; | |
370 | } | ||
371 | } else { | ||
372 | 94 | mode = get_bits(gb, 6); | |
373 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 94 times.
|
94 | if ((ret = decode_segment(s, mode, decoded, length)) < 0) |
374 | ✗ | return ret; | |
375 | } | ||
376 | |||
377 | 346 | return 0; | |
378 | } | ||
379 | |||
380 | 382 | static int get_bits_esc4(GetBitContext *gb) | |
381 | { | ||
382 |
2/2✓ Branch 1 taken 25 times.
✓ Branch 2 taken 357 times.
|
382 | if (get_bits1(gb)) |
383 | 25 | return get_bits(gb, 4) + 1; | |
384 | else | ||
385 | 357 | return 0; | |
386 | } | ||
387 | |||
388 | 268 | static int decode_subframe(TAKDecContext *s, int32_t *decoded, | |
389 | int subframe_size, int prev_subframe_size) | ||
390 | { | ||
391 | 268 | GetBitContext *gb = &s->gb; | |
392 | 268 | int x, y, i, j, ret = 0; | |
393 | int dshift, size, filter_quant, filter_order; | ||
394 | int tfilter[MAX_PREDICTORS]; | ||
395 | |||
396 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 268 times.
|
268 | if (!get_bits1(gb)) |
397 | ✗ | return decode_residues(s, decoded, subframe_size); | |
398 | |||
399 | 268 | filter_order = predictor_sizes[get_bits(gb, 4)]; | |
400 | |||
401 |
3/4✓ Branch 0 taken 190 times.
✓ Branch 1 taken 78 times.
✓ Branch 3 taken 190 times.
✗ Branch 4 not taken.
|
268 | if (prev_subframe_size > 0 && get_bits1(gb)) { |
402 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 190 times.
|
190 | if (filter_order > prev_subframe_size) |
403 | ✗ | return AVERROR_INVALIDDATA; | |
404 | |||
405 | 190 | decoded -= filter_order; | |
406 | 190 | subframe_size += filter_order; | |
407 | |||
408 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 190 times.
|
190 | if (filter_order > subframe_size) |
409 | ✗ | return AVERROR_INVALIDDATA; | |
410 | } else { | ||
411 | int lpc_mode; | ||
412 | |||
413 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 78 times.
|
78 | if (filter_order > subframe_size) |
414 | ✗ | return AVERROR_INVALIDDATA; | |
415 | |||
416 | 78 | lpc_mode = get_bits(gb, 2); | |
417 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 78 times.
|
78 | if (lpc_mode > 2) |
418 | ✗ | return AVERROR_INVALIDDATA; | |
419 | |||
420 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 78 times.
|
78 | if ((ret = decode_residues(s, decoded, filter_order)) < 0) |
421 | ✗ | return ret; | |
422 | |||
423 |
2/2✓ Branch 0 taken 46 times.
✓ Branch 1 taken 32 times.
|
78 | if (lpc_mode) |
424 | 46 | decode_lpc(decoded, lpc_mode, filter_order); | |
425 | } | ||
426 | |||
427 | 268 | dshift = get_bits_esc4(gb); | |
428 | 268 | size = get_bits1(gb) + 6; | |
429 | |||
430 | 268 | filter_quant = 10; | |
431 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 268 times.
|
268 | if (get_bits1(gb)) { |
432 | ✗ | filter_quant -= get_bits(gb, 3) + 1; | |
433 | ✗ | if (filter_quant < 3) | |
434 | ✗ | return AVERROR_INVALIDDATA; | |
435 | } | ||
436 | |||
437 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 268 times.
|
268 | if (get_bits_left(gb) < 2*10 + 2*size) |
438 | ✗ | return AVERROR_INVALIDDATA; | |
439 | |||
440 | 268 | s->predictors[0] = get_sbits(gb, 10); | |
441 | 268 | s->predictors[1] = get_sbits(gb, 10); | |
442 | 268 | s->predictors[2] = get_sbits(gb, size) * (1 << (10 - size)); | |
443 | 268 | s->predictors[3] = get_sbits(gb, size) * (1 << (10 - size)); | |
444 |
2/2✓ Branch 0 taken 245 times.
✓ Branch 1 taken 23 times.
|
268 | if (filter_order > 4) { |
445 | 245 | int tmp = size - get_bits1(gb); | |
446 | |||
447 |
2/2✓ Branch 0 taken 8868 times.
✓ Branch 1 taken 245 times.
|
9113 | for (i = 4; i < filter_order; i++) { |
448 |
2/2✓ Branch 0 taken 2217 times.
✓ Branch 1 taken 6651 times.
|
8868 | if (!(i & 3)) |
449 | 2217 | x = tmp - get_bits(gb, 2); | |
450 | 8868 | s->predictors[i] = get_sbits(gb, x) * (1 << (10 - size)); | |
451 | } | ||
452 | } | ||
453 | |||
454 | 268 | tfilter[0] = s->predictors[0] * 64; | |
455 |
2/2✓ Branch 0 taken 9672 times.
✓ Branch 1 taken 268 times.
|
9940 | for (i = 1; i < filter_order; i++) { |
456 | 9672 | uint32_t *p1 = &tfilter[0]; | |
457 | 9672 | uint32_t *p2 = &tfilter[i - 1]; | |
458 | |||
459 |
2/2✓ Branch 0 taken 206508 times.
✓ Branch 1 taken 9672 times.
|
216180 | for (j = 0; j < (i + 1) / 2; j++) { |
460 | 206508 | x = *p1 + ((int32_t)(s->predictors[i] * *p2 + 256) >> 9); | |
461 | 206508 | *p2 += (int32_t)(s->predictors[i] * *p1 + 256) >> 9; | |
462 | 206508 | *p1++ = x; | |
463 | 206508 | p2--; | |
464 | } | ||
465 | |||
466 | 9672 | tfilter[i] = s->predictors[i] * 64; | |
467 | } | ||
468 | |||
469 | 268 | x = 1 << (32 - (15 - filter_quant)); | |
470 | 268 | y = 1 << ((15 - filter_quant) - 1); | |
471 |
2/2✓ Branch 0 taken 4970 times.
✓ Branch 1 taken 268 times.
|
5238 | for (i = 0, j = filter_order - 1; i < filter_order / 2; i++, j--) { |
472 | 4970 | s->filter[j] = x - ((tfilter[i] + y) >> (15 - filter_quant)); | |
473 | 4970 | s->filter[i] = x - ((tfilter[j] + y) >> (15 - filter_quant)); | |
474 | } | ||
475 | |||
476 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 268 times.
|
268 | if ((ret = decode_residues(s, &decoded[filter_order], |
477 | subframe_size - filter_order)) < 0) | ||
478 | ✗ | return ret; | |
479 | |||
480 |
2/2✓ Branch 0 taken 9940 times.
✓ Branch 1 taken 268 times.
|
10208 | for (i = 0; i < filter_order; i++) |
481 | 9940 | s->residues[i] = *decoded++ >> dshift; | |
482 | |||
483 | 268 | y = FF_ARRAY_ELEMS(s->residues) - filter_order; | |
484 | 268 | x = subframe_size - filter_order; | |
485 |
2/2✓ Branch 0 taken 1892 times.
✓ Branch 1 taken 268 times.
|
2160 | while (x > 0) { |
486 | 1892 | int tmp = FFMIN(y, x); | |
487 | |||
488 |
2/2✓ Branch 0 taken 855940 times.
✓ Branch 1 taken 1892 times.
|
857832 | for (i = 0; i < tmp; i++) { |
489 | 855940 | int v = 1 << (filter_quant - 1); | |
490 | |||
491 |
2/2✓ Branch 0 taken 703880 times.
✓ Branch 1 taken 152060 times.
|
855940 | if (filter_order & -16) |
492 | 703880 | v += (unsigned)s->adsp.scalarproduct_int16(&s->residues[i], s->filter, | |
493 | filter_order & -16); | ||
494 |
2/2✓ Branch 0 taken 495532 times.
✓ Branch 1 taken 855940 times.
|
1351472 | for (j = filter_order & -16; j < filter_order; j += 4) { |
495 | 495532 | v += s->residues[i + j + 3] * (unsigned)s->filter[j + 3] + | |
496 | 495532 | s->residues[i + j + 2] * (unsigned)s->filter[j + 2] + | |
497 | 495532 | s->residues[i + j + 1] * (unsigned)s->filter[j + 1] + | |
498 | 495532 | s->residues[i + j ] * (unsigned)s->filter[j ]; | |
499 | } | ||
500 | 855940 | v = (av_clip_intp2(v >> filter_quant, 13) * (1 << dshift)) - (unsigned)*decoded; | |
501 | 855940 | *decoded++ = v; | |
502 | 855940 | s->residues[filter_order + i] = v >> dshift; | |
503 | } | ||
504 | |||
505 | 1892 | x -= tmp; | |
506 |
2/2✓ Branch 0 taken 1624 times.
✓ Branch 1 taken 268 times.
|
1892 | if (x > 0) |
507 | 1624 | memcpy(s->residues, &s->residues[y], 2 * filter_order); | |
508 | } | ||
509 | |||
510 | 268 | return 0; | |
511 | } | ||
512 | |||
513 | 78 | static int decode_channel(TAKDecContext *s, int chan) | |
514 | { | ||
515 | 78 | AVCodecContext *avctx = s->avctx; | |
516 | 78 | GetBitContext *gb = &s->gb; | |
517 | 78 | int32_t *decoded = s->decoded[chan]; | |
518 | 78 | int left = s->nb_samples - 1; | |
519 | 78 | int i = 0, ret, prev = 0; | |
520 | |||
521 | 78 | s->sample_shift[chan] = get_bits_esc4(gb); | |
522 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 78 times.
|
78 | if (s->sample_shift[chan] >= avctx->bits_per_raw_sample) |
523 | ✗ | return AVERROR_INVALIDDATA; | |
524 | |||
525 | 78 | *decoded++ = get_sbits(gb, avctx->bits_per_raw_sample - s->sample_shift[chan]); | |
526 | 78 | s->lpc_mode[chan] = get_bits(gb, 2); | |
527 | 78 | s->nb_subframes = get_bits(gb, 3) + 1; | |
528 | |||
529 |
2/2✓ Branch 0 taken 69 times.
✓ Branch 1 taken 9 times.
|
78 | if (s->nb_subframes > 1) { |
530 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 69 times.
|
69 | if (get_bits_left(gb) < (s->nb_subframes - 1) * 6) |
531 | ✗ | return AVERROR_INVALIDDATA; | |
532 | |||
533 |
2/2✓ Branch 0 taken 190 times.
✓ Branch 1 taken 69 times.
|
259 | for (; i < s->nb_subframes - 1; i++) { |
534 | 190 | int v = get_bits(gb, 6); | |
535 | |||
536 | 190 | s->subframe_len[i] = (v - prev) * s->subframe_scale; | |
537 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 190 times.
|
190 | if (s->subframe_len[i] <= 0) |
538 | ✗ | return AVERROR_INVALIDDATA; | |
539 | |||
540 | 190 | left -= s->subframe_len[i]; | |
541 | 190 | prev = v; | |
542 | } | ||
543 | |||
544 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
|
69 | if (left <= 0) |
545 | ✗ | return AVERROR_INVALIDDATA; | |
546 | } | ||
547 | 78 | s->subframe_len[i] = left; | |
548 | |||
549 | 78 | prev = 0; | |
550 |
2/2✓ Branch 0 taken 268 times.
✓ Branch 1 taken 78 times.
|
346 | for (i = 0; i < s->nb_subframes; i++) { |
551 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 268 times.
|
268 | if ((ret = decode_subframe(s, decoded, s->subframe_len[i], prev)) < 0) |
552 | ✗ | return ret; | |
553 | 268 | decoded += s->subframe_len[i]; | |
554 | 268 | prev = s->subframe_len[i]; | |
555 | } | ||
556 | |||
557 | 78 | return 0; | |
558 | } | ||
559 | |||
560 | 39 | static int decorrelate(TAKDecContext *s, int c1, int c2, int length) | |
561 | { | ||
562 | 39 | GetBitContext *gb = &s->gb; | |
563 |
2/2✓ Branch 0 taken 30 times.
✓ Branch 1 taken 9 times.
|
39 | int32_t *p1 = s->decoded[c1] + (s->dmode > 5); |
564 |
2/2✓ Branch 0 taken 30 times.
✓ Branch 1 taken 9 times.
|
39 | int32_t *p2 = s->decoded[c2] + (s->dmode > 5); |
565 | 39 | int32_t bp1 = p1[0]; | |
566 | 39 | int32_t bp2 = p2[0]; | |
567 | int i; | ||
568 | int dshift, dfactor; | ||
569 | |||
570 | 39 | length += s->dmode < 6; | |
571 | |||
572 |
6/8✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 13 times.
✓ Branch 6 taken 17 times.
✗ Branch 7 not taken.
|
39 | switch (s->dmode) { |
573 | 1 | case 1: /* left/side */ | |
574 | 1 | s->tdsp.decorrelate_ls(p1, p2, length); | |
575 | 1 | break; | |
576 | ✗ | case 2: /* side/right */ | |
577 | ✗ | s->tdsp.decorrelate_sr(p1, p2, length); | |
578 | ✗ | break; | |
579 | 2 | case 3: /* side/mid */ | |
580 | 2 | s->tdsp.decorrelate_sm(p1, p2, length); | |
581 | 2 | break; | |
582 | 4 | case 4: /* side/left with scale factor */ | |
583 | 4 | FFSWAP(int32_t*, p1, p2); | |
584 | 4 | FFSWAP(int32_t, bp1, bp2); | |
585 | 6 | case 5: /* side/right with scale factor */ | |
586 | 6 | dshift = get_bits_esc4(gb); | |
587 | 6 | dfactor = get_sbits(gb, 10); | |
588 | 6 | s->tdsp.decorrelate_sf(p1, p2, length, dshift, dfactor); | |
589 | 6 | break; | |
590 | 13 | case 6: | |
591 | 13 | FFSWAP(int32_t*, p1, p2); | |
592 | 30 | case 7: { | |
593 | int length2, order_half, filter_order, dval1, dval2; | ||
594 | int tmp, x, code_size; | ||
595 | |||
596 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
|
30 | if (length < 256) |
597 | ✗ | return AVERROR_INVALIDDATA; | |
598 | |||
599 | 30 | dshift = get_bits_esc4(gb); | |
600 | 30 | filter_order = 8 << get_bits1(gb); | |
601 | 30 | dval1 = get_bits1(gb); | |
602 | 30 | dval2 = get_bits1(gb); | |
603 | |||
604 |
2/2✓ Branch 0 taken 336 times.
✓ Branch 1 taken 30 times.
|
366 | for (i = 0; i < filter_order; i++) { |
605 |
2/2✓ Branch 0 taken 84 times.
✓ Branch 1 taken 252 times.
|
336 | if (!(i & 3)) |
606 | 84 | code_size = 14 - get_bits(gb, 3); | |
607 | 336 | s->filter[i] = get_sbits(gb, code_size); | |
608 | } | ||
609 | |||
610 | 30 | order_half = filter_order / 2; | |
611 | 30 | length2 = length - (filter_order - 1); | |
612 | |||
613 | /* decorrelate beginning samples */ | ||
614 |
2/2✓ Branch 0 taken 21 times.
✓ Branch 1 taken 9 times.
|
30 | if (dval1) { |
615 |
2/2✓ Branch 0 taken 120 times.
✓ Branch 1 taken 21 times.
|
141 | for (i = 0; i < order_half; i++) { |
616 | 120 | int32_t a = p1[i]; | |
617 | 120 | int32_t b = p2[i]; | |
618 | 120 | p1[i] = a + b; | |
619 | } | ||
620 | } | ||
621 | |||
622 | /* decorrelate ending samples */ | ||
623 |
2/2✓ Branch 0 taken 18 times.
✓ Branch 1 taken 12 times.
|
30 | if (dval2) { |
624 |
2/2✓ Branch 0 taken 78 times.
✓ Branch 1 taken 18 times.
|
96 | for (i = length2 + order_half; i < length; i++) { |
625 | 78 | int32_t a = p1[i]; | |
626 | 78 | int32_t b = p2[i]; | |
627 | 78 | p1[i] = a + b; | |
628 | } | ||
629 | } | ||
630 | |||
631 | |||
632 |
2/2✓ Branch 0 taken 336 times.
✓ Branch 1 taken 30 times.
|
366 | for (i = 0; i < filter_order; i++) |
633 | 336 | s->residues[i] = *p2++ >> dshift; | |
634 | |||
635 | 30 | p1 += order_half; | |
636 | 30 | x = FF_ARRAY_ELEMS(s->residues) - filter_order; | |
637 |
2/2✓ Branch 0 taken 630 times.
✓ Branch 1 taken 30 times.
|
660 | for (; length2 > 0; length2 -= tmp) { |
638 | 630 | tmp = FFMIN(length2, x); | |
639 | |||
640 |
2/2✓ Branch 0 taken 330384 times.
✓ Branch 1 taken 630 times.
|
331014 | for (i = 0; i < tmp - (tmp == length2); i++) |
641 | 330384 | s->residues[filter_order + i] = *p2++ >> dshift; | |
642 | |||
643 |
2/2✓ Branch 0 taken 330414 times.
✓ Branch 1 taken 630 times.
|
331044 | for (i = 0; i < tmp; i++) { |
644 | 330414 | int v = 1 << 9; | |
645 | |||
646 |
2/2✓ Branch 0 taken 132108 times.
✓ Branch 1 taken 198306 times.
|
330414 | if (filter_order == 16) { |
647 | 132108 | v += s->adsp.scalarproduct_int16(&s->residues[i], s->filter, | |
648 | filter_order); | ||
649 | } else { | ||
650 | 198306 | v += s->residues[i + 7] * s->filter[7] + | |
651 | 198306 | s->residues[i + 6] * s->filter[6] + | |
652 | 198306 | s->residues[i + 5] * s->filter[5] + | |
653 | 198306 | s->residues[i + 4] * s->filter[4] + | |
654 | 198306 | s->residues[i + 3] * s->filter[3] + | |
655 | 198306 | s->residues[i + 2] * s->filter[2] + | |
656 | 198306 | s->residues[i + 1] * s->filter[1] + | |
657 | 198306 | s->residues[i ] * s->filter[0]; | |
658 | } | ||
659 | |||
660 | 330414 | v = av_clip_intp2(v >> 10, 13) * (1U << dshift) - *p1; | |
661 | 330414 | *p1++ = v; | |
662 | } | ||
663 | |||
664 | 630 | memmove(s->residues, &s->residues[tmp], 2 * filter_order); | |
665 | } | ||
666 | 30 | break; | |
667 | } | ||
668 | } | ||
669 | |||
670 |
3/4✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 30 times.
|
39 | if (s->dmode > 0 && s->dmode < 6) { |
671 | 9 | p1[0] = bp1; | |
672 | 9 | p2[0] = bp2; | |
673 | } | ||
674 | |||
675 | 39 | return 0; | |
676 | } | ||
677 | |||
678 | 39 | static int tak_decode_frame(AVCodecContext *avctx, AVFrame *frame, | |
679 | int *got_frame_ptr, AVPacket *pkt) | ||
680 | { | ||
681 | 39 | TAKDecContext *s = avctx->priv_data; | |
682 | 39 | GetBitContext *gb = &s->gb; | |
683 | int chan, i, ret, hsize; | ||
684 | |||
685 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (pkt->size < TAK_MIN_FRAME_HEADER_BYTES) |
686 | ✗ | return AVERROR_INVALIDDATA; | |
687 | |||
688 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if ((ret = init_get_bits8(gb, pkt->data, pkt->size)) < 0) |
689 | ✗ | return ret; | |
690 | |||
691 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if ((ret = ff_tak_decode_frame_header(avctx, gb, &s->ti, 0)) < 0) |
692 | ✗ | return ret; | |
693 | |||
694 | 39 | hsize = get_bits_count(gb) / 8; | |
695 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) { |
696 | ✗ | if (ff_tak_check_crc(pkt->data, hsize)) { | |
697 | ✗ | av_log(avctx, AV_LOG_ERROR, "CRC error\n"); | |
698 | ✗ | if (avctx->err_recognition & AV_EF_EXPLODE) | |
699 | ✗ | return AVERROR_INVALIDDATA; | |
700 | } | ||
701 | } | ||
702 | |||
703 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (s->ti.codec != TAK_CODEC_MONO_STEREO && |
704 | ✗ | s->ti.codec != TAK_CODEC_MULTICHANNEL) { | |
705 | ✗ | avpriv_report_missing_feature(avctx, "TAK codec type %d", s->ti.codec); | |
706 | ✗ | return AVERROR_PATCHWELCOME; | |
707 | } | ||
708 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (s->ti.data_type) { |
709 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
710 | "unsupported data type: %d\n", s->ti.data_type); | ||
711 | ✗ | return AVERROR_INVALIDDATA; | |
712 | } | ||
713 |
2/4✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 39 times.
|
39 | if (s->ti.codec == TAK_CODEC_MONO_STEREO && s->ti.channels > 2) { |
714 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
715 | "invalid number of channels: %d\n", s->ti.channels); | ||
716 | ✗ | return AVERROR_INVALIDDATA; | |
717 | } | ||
718 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (s->ti.channels > 6) { |
719 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
720 | "unsupported number of channels: %d\n", s->ti.channels); | ||
721 | ✗ | return AVERROR_INVALIDDATA; | |
722 | } | ||
723 | |||
724 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (s->ti.frame_samples <= 0) { |
725 | ✗ | av_log(avctx, AV_LOG_ERROR, "unsupported/invalid number of samples\n"); | |
726 | ✗ | return AVERROR_INVALIDDATA; | |
727 | } | ||
728 | |||
729 | 39 | avctx->bits_per_raw_sample = s->ti.bps; | |
730 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if ((ret = set_bps_params(avctx)) < 0) |
731 | ✗ | return ret; | |
732 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (s->ti.sample_rate != avctx->sample_rate) { |
733 | ✗ | avctx->sample_rate = s->ti.sample_rate; | |
734 | ✗ | set_sample_rate_params(avctx); | |
735 | } | ||
736 | |||
737 | 39 | av_channel_layout_uninit(&avctx->ch_layout); | |
738 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (s->ti.ch_layout) { |
739 | ✗ | av_channel_layout_from_mask(&avctx->ch_layout, s->ti.ch_layout); | |
740 | } else { | ||
741 | 39 | avctx->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC; | |
742 | 39 | avctx->ch_layout.nb_channels = s->ti.channels; | |
743 | } | ||
744 | |||
745 | 78 | s->nb_samples = s->ti.last_frame_samples ? s->ti.last_frame_samples | |
746 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 38 times.
|
39 | : s->ti.frame_samples; |
747 | |||
748 | 39 | frame->nb_samples = s->nb_samples; | |
749 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0) |
750 | ✗ | return ret; | |
751 | 39 | ff_thread_finish_setup(avctx); | |
752 | |||
753 |
1/2✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
|
39 | if (avctx->bits_per_raw_sample <= 16) { |
754 | 39 | int buf_size = av_samples_get_buffer_size(NULL, avctx->ch_layout.nb_channels, | |
755 | s->nb_samples, | ||
756 | AV_SAMPLE_FMT_S32P, 0); | ||
757 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (buf_size < 0) |
758 | ✗ | return buf_size; | |
759 | 39 | av_fast_malloc(&s->decode_buffer, &s->decode_buffer_size, buf_size); | |
760 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (!s->decode_buffer) |
761 | ✗ | return AVERROR(ENOMEM); | |
762 | 39 | ret = av_samples_fill_arrays((uint8_t **)s->decoded, NULL, | |
763 | 39 | s->decode_buffer, avctx->ch_layout.nb_channels, | |
764 | s->nb_samples, AV_SAMPLE_FMT_S32P, 0); | ||
765 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (ret < 0) |
766 | ✗ | return ret; | |
767 | } else { | ||
768 | ✗ | for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++) | |
769 | ✗ | s->decoded[chan] = (int32_t *)frame->extended_data[chan]; | |
770 | } | ||
771 | |||
772 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (s->nb_samples < 16) { |
773 | ✗ | for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++) { | |
774 | ✗ | int32_t *decoded = s->decoded[chan]; | |
775 | ✗ | for (i = 0; i < s->nb_samples; i++) | |
776 | ✗ | decoded[i] = get_sbits(gb, avctx->bits_per_raw_sample); | |
777 | } | ||
778 | } else { | ||
779 |
1/2✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
|
39 | if (s->ti.codec == TAK_CODEC_MONO_STEREO) { |
780 |
2/2✓ Branch 0 taken 78 times.
✓ Branch 1 taken 39 times.
|
117 | for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++) |
781 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 78 times.
|
78 | if (ret = decode_channel(s, chan)) |
782 | ✗ | return ret; | |
783 | |||
784 |
1/2✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
|
39 | if (avctx->ch_layout.nb_channels == 2) { |
785 | 39 | s->nb_subframes = get_bits(gb, 1) + 1; | |
786 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (s->nb_subframes > 1) { |
787 | ✗ | s->subframe_len[1] = get_bits(gb, 6); | |
788 | } | ||
789 | |||
790 | 39 | s->dmode = get_bits(gb, 3); | |
791 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if (ret = decorrelate(s, 0, 1, s->nb_samples - 1)) |
792 | ✗ | return ret; | |
793 | } | ||
794 | ✗ | } else if (s->ti.codec == TAK_CODEC_MULTICHANNEL) { | |
795 | ✗ | if (get_bits1(gb)) { | |
796 | ✗ | int ch_mask = 0; | |
797 | |||
798 | ✗ | chan = get_bits(gb, 4) + 1; | |
799 | ✗ | if (chan > avctx->ch_layout.nb_channels) | |
800 | ✗ | return AVERROR_INVALIDDATA; | |
801 | |||
802 | ✗ | for (i = 0; i < chan; i++) { | |
803 | ✗ | int nbit = get_bits(gb, 4); | |
804 | |||
805 | ✗ | if (nbit >= avctx->ch_layout.nb_channels) | |
806 | ✗ | return AVERROR_INVALIDDATA; | |
807 | |||
808 | ✗ | if (ch_mask & 1 << nbit) | |
809 | ✗ | return AVERROR_INVALIDDATA; | |
810 | |||
811 | ✗ | s->mcdparams[i].present = get_bits1(gb); | |
812 | ✗ | if (s->mcdparams[i].present) { | |
813 | ✗ | s->mcdparams[i].index = get_bits(gb, 2); | |
814 | ✗ | s->mcdparams[i].chan2 = get_bits(gb, 4); | |
815 | ✗ | if (s->mcdparams[i].chan2 >= avctx->ch_layout.nb_channels) { | |
816 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
817 | "invalid channel 2 (%d) for %d channel(s)\n", | ||
818 | ✗ | s->mcdparams[i].chan2, avctx->ch_layout.nb_channels); | |
819 | ✗ | return AVERROR_INVALIDDATA; | |
820 | } | ||
821 | ✗ | if (s->mcdparams[i].index == 1) { | |
822 | ✗ | if ((nbit == s->mcdparams[i].chan2) || | |
823 | ✗ | (ch_mask & 1 << s->mcdparams[i].chan2)) | |
824 | ✗ | return AVERROR_INVALIDDATA; | |
825 | |||
826 | ✗ | ch_mask |= 1 << s->mcdparams[i].chan2; | |
827 | ✗ | } else if (!(ch_mask & 1 << s->mcdparams[i].chan2)) { | |
828 | ✗ | return AVERROR_INVALIDDATA; | |
829 | } | ||
830 | } | ||
831 | ✗ | s->mcdparams[i].chan1 = nbit; | |
832 | |||
833 | ✗ | ch_mask |= 1 << nbit; | |
834 | } | ||
835 | } else { | ||
836 | ✗ | chan = avctx->ch_layout.nb_channels; | |
837 | ✗ | for (i = 0; i < chan; i++) { | |
838 | ✗ | s->mcdparams[i].present = 0; | |
839 | ✗ | s->mcdparams[i].chan1 = i; | |
840 | } | ||
841 | } | ||
842 | |||
843 | ✗ | for (i = 0; i < chan; i++) { | |
844 | ✗ | if (s->mcdparams[i].present && s->mcdparams[i].index == 1) | |
845 | ✗ | if (ret = decode_channel(s, s->mcdparams[i].chan2)) | |
846 | ✗ | return ret; | |
847 | |||
848 | ✗ | if (ret = decode_channel(s, s->mcdparams[i].chan1)) | |
849 | ✗ | return ret; | |
850 | |||
851 | ✗ | if (s->mcdparams[i].present) { | |
852 | ✗ | s->dmode = mc_dmodes[s->mcdparams[i].index]; | |
853 | ✗ | if (ret = decorrelate(s, | |
854 | ✗ | s->mcdparams[i].chan2, | |
855 | ✗ | s->mcdparams[i].chan1, | |
856 | ✗ | s->nb_samples - 1)) | |
857 | ✗ | return ret; | |
858 | } | ||
859 | } | ||
860 | } | ||
861 | |||
862 |
2/2✓ Branch 0 taken 78 times.
✓ Branch 1 taken 39 times.
|
117 | for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++) { |
863 | 78 | int32_t *decoded = s->decoded[chan]; | |
864 | |||
865 |
1/2✓ Branch 0 taken 78 times.
✗ Branch 1 not taken.
|
78 | if (s->lpc_mode[chan]) |
866 | 78 | decode_lpc(decoded, s->lpc_mode[chan], s->nb_samples); | |
867 | |||
868 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 78 times.
|
78 | if (s->sample_shift[chan] > 0) |
869 | ✗ | for (i = 0; i < s->nb_samples; i++) | |
870 | ✗ | decoded[i] *= 1U << s->sample_shift[chan]; | |
871 | } | ||
872 | } | ||
873 | |||
874 | 39 | align_get_bits(gb); | |
875 | 39 | skip_bits(gb, 24); | |
876 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if (get_bits_left(gb) < 0) |
877 | ✗ | av_log(avctx, AV_LOG_DEBUG, "overread\n"); | |
878 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | else if (get_bits_left(gb) > 0) |
879 | ✗ | av_log(avctx, AV_LOG_DEBUG, "underread\n"); | |
880 | |||
881 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_COMPLIANT)) { |
882 | ✗ | if (ff_tak_check_crc(pkt->data + hsize, | |
883 | ✗ | get_bits_count(gb) / 8 - hsize)) { | |
884 | ✗ | av_log(avctx, AV_LOG_ERROR, "CRC error\n"); | |
885 | ✗ | if (avctx->err_recognition & AV_EF_EXPLODE) | |
886 | ✗ | return AVERROR_INVALIDDATA; | |
887 | } | ||
888 | } | ||
889 | |||
890 | /* convert to output buffer */ | ||
891 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
39 | switch (avctx->sample_fmt) { |
892 | ✗ | case AV_SAMPLE_FMT_U8P: | |
893 | ✗ | for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++) { | |
894 | ✗ | uint8_t *samples = (uint8_t *)frame->extended_data[chan]; | |
895 | ✗ | int32_t *decoded = s->decoded[chan]; | |
896 | ✗ | for (i = 0; i < s->nb_samples; i++) | |
897 | ✗ | samples[i] = decoded[i] + 0x80U; | |
898 | } | ||
899 | ✗ | break; | |
900 | 39 | case AV_SAMPLE_FMT_S16P: | |
901 |
2/2✓ Branch 0 taken 78 times.
✓ Branch 1 taken 39 times.
|
117 | for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++) { |
902 | 78 | int16_t *samples = (int16_t *)frame->extended_data[chan]; | |
903 | 78 | int32_t *decoded = s->decoded[chan]; | |
904 |
2/2✓ Branch 0 taken 859950 times.
✓ Branch 1 taken 78 times.
|
860028 | for (i = 0; i < s->nb_samples; i++) |
905 | 859950 | samples[i] = decoded[i]; | |
906 | } | ||
907 | 39 | break; | |
908 | ✗ | case AV_SAMPLE_FMT_S32P: | |
909 | ✗ | for (chan = 0; chan < avctx->ch_layout.nb_channels; chan++) { | |
910 | ✗ | int32_t *samples = (int32_t *)frame->extended_data[chan]; | |
911 | ✗ | for (i = 0; i < s->nb_samples; i++) | |
912 | ✗ | samples[i] *= 1U << 8; | |
913 | } | ||
914 | ✗ | break; | |
915 | } | ||
916 | |||
917 | 39 | *got_frame_ptr = 1; | |
918 | |||
919 | 39 | return pkt->size; | |
920 | } | ||
921 | |||
922 | #if HAVE_THREADS | ||
923 | ✗ | static int update_thread_context(AVCodecContext *dst, | |
924 | const AVCodecContext *src) | ||
925 | { | ||
926 | ✗ | TAKDecContext *tsrc = src->priv_data; | |
927 | ✗ | TAKDecContext *tdst = dst->priv_data; | |
928 | |||
929 | ✗ | if (dst == src) | |
930 | ✗ | return 0; | |
931 | ✗ | memcpy(&tdst->ti, &tsrc->ti, sizeof(TAKStreamInfo)); | |
932 | ✗ | return 0; | |
933 | } | ||
934 | #endif | ||
935 | |||
936 | 2 | static av_cold int tak_decode_close(AVCodecContext *avctx) | |
937 | { | ||
938 | 2 | TAKDecContext *s = avctx->priv_data; | |
939 | |||
940 | 2 | av_freep(&s->decode_buffer); | |
941 | |||
942 | 2 | return 0; | |
943 | } | ||
944 | |||
945 | const FFCodec ff_tak_decoder = { | ||
946 | .p.name = "tak", | ||
947 | CODEC_LONG_NAME("TAK (Tom's lossless Audio Kompressor)"), | ||
948 | .p.type = AVMEDIA_TYPE_AUDIO, | ||
949 | .p.id = AV_CODEC_ID_TAK, | ||
950 | .priv_data_size = sizeof(TAKDecContext), | ||
951 | .init = tak_decode_init, | ||
952 | .close = tak_decode_close, | ||
953 | FF_CODEC_DECODE_CB(tak_decode_frame), | ||
954 | UPDATE_THREAD_CONTEXT(update_thread_context), | ||
955 | .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_CHANNEL_CONF, | ||
956 | CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_U8P, AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P), | ||
957 | }; | ||
958 |