FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/atrac9dec.c
Date: 2022-07-05 19:52:29
Exec Total Coverage
Lines: 0 538 0.0%
Branches: 0 313 0.0%
Line Branch Exec Source
1 /*
2 * ATRAC9 decoder
3 * Copyright (c) 2018 Rostislav Pehlivanov <atomnuker@gmail.com>
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 #include "libavutil/channel_layout.h"
23 #include "libavutil/thread.h"
24
25 #include "codec_internal.h"
26 #include "internal.h"
27 #include "get_bits.h"
28 #include "fft.h"
29 #include "atrac9tab.h"
30 #include "libavutil/lfg.h"
31 #include "libavutil/float_dsp.h"
32 #include "libavutil/mem_internal.h"
33
34 #define ATRAC9_SF_VLC_BITS 8
35 #define ATRAC9_COEFF_VLC_BITS 9
36
37 typedef struct ATRAC9ChannelData {
38 int band_ext;
39 int q_unit_cnt;
40 int band_ext_data[4];
41 int32_t scalefactors[31];
42 int32_t scalefactors_prev[31];
43
44 int precision_coarse[30];
45 int precision_fine[30];
46 int precision_mask[30];
47
48 int codebookset[30];
49
50 int32_t q_coeffs_coarse[256];
51 int32_t q_coeffs_fine[256];
52
53 DECLARE_ALIGNED(32, float, coeffs )[256];
54 DECLARE_ALIGNED(32, float, prev_win)[128];
55 } ATRAC9ChannelData;
56
57 typedef struct ATRAC9BlockData {
58 ATRAC9ChannelData channel[2];
59
60 /* Base */
61 int band_count;
62 int q_unit_cnt;
63 int q_unit_cnt_prev;
64
65 /* Stereo block only */
66 int stereo_q_unit;
67
68 /* Band extension only */
69 int has_band_ext;
70 int has_band_ext_data;
71 int band_ext_q_unit;
72
73 /* Gradient */
74 int grad_mode;
75 int grad_boundary;
76 int gradient[31];
77
78 /* Stereo */
79 int cpe_base_channel;
80 int is_signs[30];
81
82 int reuseable;
83
84 } ATRAC9BlockData;
85
86 typedef struct ATRAC9Context {
87 AVCodecContext *avctx;
88 AVFloatDSPContext *fdsp;
89 FFTContext imdct;
90 ATRAC9BlockData block[5];
91 AVLFG lfg;
92
93 /* Set on init */
94 int frame_log2;
95 int avg_frame_size;
96 int frame_count;
97 int samplerate_idx;
98 const ATRAC9BlockConfig *block_config;
99
100 /* Generated on init */
101 uint8_t alloc_curve[48][48];
102 DECLARE_ALIGNED(32, float, imdct_win)[256];
103
104 DECLARE_ALIGNED(32, float, temp)[256];
105 } ATRAC9Context;
106
107 static VLC sf_vlc[2][8]; /* Signed/unsigned, length */
108 static VLC coeff_vlc[2][8][4]; /* Cookbook, precision, cookbook index */
109
110 ✗ static inline int parse_gradient(ATRAC9Context *s, ATRAC9BlockData *b,
111 GetBitContext *gb)
112 {
113 int grad_range[2];
114 int grad_value[2];
115 int values, sign, base;
116 uint8_t *curve;
117 float scale;
118
119 ✗ b->grad_mode = get_bits(gb, 2);
120 ✗ if (b->grad_mode) {
121 ✗ grad_range[0] = get_bits(gb, 5);
122 ✗ grad_range[1] = 31;
123 ✗ grad_value[0] = get_bits(gb, 5);
124 ✗ grad_value[1] = 31;
125 } else {
126 ✗ grad_range[0] = get_bits(gb, 6);
127 ✗ grad_range[1] = get_bits(gb, 6) + 1;
128 ✗ grad_value[0] = get_bits(gb, 5);
129 ✗ grad_value[1] = get_bits(gb, 5);
130 }
131 ✗ b->grad_boundary = get_bits(gb, 4);
132
133 ✗ if (grad_range[0] >= grad_range[1] || grad_range[1] > 31)
134 ✗ return AVERROR_INVALIDDATA;
135
136 ✗ if (b->grad_boundary > b->q_unit_cnt)
137 ✗ return AVERROR_INVALIDDATA;
138
139 ✗ values = grad_value[1] - grad_value[0];
140 ✗ sign = 1 - 2*(values < 0);
141 ✗ base = grad_value[0] + sign;
142 ✗ scale = (FFABS(values) - 1) / 31.0f;
143 ✗ curve = s->alloc_curve[grad_range[1] - grad_range[0] - 1];
144
145 ✗ for (int i = 0; i <= b->q_unit_cnt; i++)
146 ✗ b->gradient[i] = grad_value[i >= grad_range[0]];
147
148 ✗ for (int i = grad_range[0]; i < grad_range[1]; i++)
149 ✗ b->gradient[i] = base + sign*((int)(scale*curve[i - grad_range[0]]));
150
151 ✗ return 0;
152 }
153
154 ✗ static inline void calc_precision(ATRAC9Context *s, ATRAC9BlockData *b,
155 ATRAC9ChannelData *c)
156 {
157 ✗ memset(c->precision_mask, 0, sizeof(c->precision_mask));
158 ✗ for (int i = 1; i < b->q_unit_cnt; i++) {
159 ✗ const int delta = FFABS(c->scalefactors[i] - c->scalefactors[i - 1]) - 1;
160 ✗ if (delta > 0) {
161 ✗ const int neg = c->scalefactors[i - 1] > c->scalefactors[i];
162 ✗ c->precision_mask[i - neg] += FFMIN(delta, 5);
163 }
164 }
165
166 ✗ if (b->grad_mode) {
167 ✗ for (int i = 0; i < b->q_unit_cnt; i++) {
168 ✗ c->precision_coarse[i] = c->scalefactors[i];
169 ✗ c->precision_coarse[i] += c->precision_mask[i] - b->gradient[i];
170 ✗ if (c->precision_coarse[i] < 0)
171 ✗ continue;
172 ✗ switch (b->grad_mode) {
173 ✗ case 1:
174 ✗ c->precision_coarse[i] >>= 1;
175 ✗ break;
176 ✗ case 2:
177 ✗ c->precision_coarse[i] = (3 * c->precision_coarse[i]) >> 3;
178 ✗ break;
179 ✗ case 3:
180 ✗ c->precision_coarse[i] >>= 2;
181 ✗ break;
182 }
183 }
184 } else {
185 ✗ for (int i = 0; i < b->q_unit_cnt; i++)
186 ✗ c->precision_coarse[i] = c->scalefactors[i] - b->gradient[i];
187 }
188
189
190 ✗ for (int i = 0; i < b->q_unit_cnt; i++)
191 ✗ c->precision_coarse[i] = FFMAX(c->precision_coarse[i], 1);
192
193 ✗ for (int i = 0; i < b->grad_boundary; i++)
194 ✗ c->precision_coarse[i]++;
195
196 ✗ for (int i = 0; i < b->q_unit_cnt; i++) {
197 ✗ c->precision_fine[i] = 0;
198 ✗ if (c->precision_coarse[i] > 15) {
199 ✗ c->precision_fine[i] = FFMIN(c->precision_coarse[i], 30) - 15;
200 ✗ c->precision_coarse[i] = 15;
201 }
202 }
203 }
204
205 ✗ static inline int parse_band_ext(ATRAC9Context *s, ATRAC9BlockData *b,
206 GetBitContext *gb, int stereo)
207 {
208 ✗ int ext_band = 0;
209
210 ✗ if (b->has_band_ext) {
211 ✗ if (b->q_unit_cnt < 13 || b->q_unit_cnt > 20)
212 ✗ return AVERROR_INVALIDDATA;
213 ✗ ext_band = at9_tab_band_ext_group[b->q_unit_cnt - 13][2];
214 ✗ if (stereo) {
215 ✗ b->channel[1].band_ext = get_bits(gb, 2);
216 ✗ b->channel[1].band_ext = ext_band > 2 ? b->channel[1].band_ext : 4;
217 } else {
218 ✗ skip_bits1(gb);
219 }
220 }
221
222 ✗ b->has_band_ext_data = get_bits1(gb);
223 ✗ if (!b->has_band_ext_data)
224 ✗ return 0;
225
226 ✗ if (!b->has_band_ext) {
227 ✗ skip_bits(gb, 2);
228 ✗ skip_bits_long(gb, get_bits(gb, 5));
229 ✗ return 0;
230 }
231
232 ✗ b->channel[0].band_ext = get_bits(gb, 2);
233 ✗ b->channel[0].band_ext = ext_band > 2 ? b->channel[0].band_ext : 4;
234
235 ✗ if (!get_bits(gb, 5)) {
236 ✗ for (int i = 0; i <= stereo; i++) {
237 ✗ ATRAC9ChannelData *c = &b->channel[i];
238 ✗ const int count = at9_tab_band_ext_cnt[c->band_ext][ext_band];
239 ✗ for (int j = 0; j < count; j++) {
240 ✗ int len = at9_tab_band_ext_lengths[c->band_ext][ext_band][j];
241 ✗ c->band_ext_data[j] = av_clip_uintp2_c(c->band_ext_data[j], len);
242 }
243 }
244
245 ✗ return 0;
246 }
247
248 ✗ for (int i = 0; i <= stereo; i++) {
249 ✗ ATRAC9ChannelData *c = &b->channel[i];
250 ✗ const int count = at9_tab_band_ext_cnt[c->band_ext][ext_band];
251 ✗ for (int j = 0; j < count; j++) {
252 ✗ int len = at9_tab_band_ext_lengths[c->band_ext][ext_band][j];
253 ✗ c->band_ext_data[j] = get_bits(gb, len);
254 }
255 }
256
257 ✗ return 0;
258 }
259
260 ✗ static inline int read_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b,
261 ATRAC9ChannelData *c, GetBitContext *gb,
262 int channel_idx, int first_in_pkt)
263 {
264 static const uint8_t mode_map[2][4] = { { 0, 1, 2, 3 }, { 0, 2, 3, 4 } };
265 ✗ const int mode = mode_map[channel_idx][get_bits(gb, 2)];
266
267 ✗ memset(c->scalefactors, 0, sizeof(c->scalefactors));
268
269 ✗ if (first_in_pkt && (mode == 4 || ((mode == 3) && !channel_idx))) {
270 ✗ av_log(s->avctx, AV_LOG_ERROR, "Invalid scalefactor coding mode!\n");
271 ✗ return AVERROR_INVALIDDATA;
272 }
273
274 ✗ switch (mode) {
275 ✗ case 0: { /* VLC delta offset */
276 ✗ const uint8_t *sf_weights = at9_tab_sf_weights[get_bits(gb, 3)];
277 ✗ const int base = get_bits(gb, 5);
278 ✗ const int len = get_bits(gb, 2) + 3;
279 ✗ const VLC *tab = &sf_vlc[0][len];
280
281 ✗ c->scalefactors[0] = get_bits(gb, len);
282
283 ✗ for (int i = 1; i < b->band_ext_q_unit; i++) {
284 ✗ int val = c->scalefactors[i - 1] + get_vlc2(gb, tab->table,
285 ATRAC9_SF_VLC_BITS, 1);
286 ✗ c->scalefactors[i] = val & ((1 << len) - 1);
287 }
288
289 ✗ for (int i = 0; i < b->band_ext_q_unit; i++)
290 ✗ c->scalefactors[i] += base - sf_weights[i];
291
292 ✗ break;
293 }
294 ✗ case 1: { /* CLC offset */
295 ✗ const int len = get_bits(gb, 2) + 2;
296 ✗ const int base = len < 5 ? get_bits(gb, 5) : 0;
297 ✗ for (int i = 0; i < b->band_ext_q_unit; i++)
298 ✗ c->scalefactors[i] = base + get_bits(gb, len);
299 ✗ break;
300 }
301 ✗ case 2:
302 case 4: { /* VLC dist to baseline */
303 ✗ const int *baseline = mode == 4 ? c->scalefactors_prev :
304 channel_idx ? b->channel[0].scalefactors :
305 c->scalefactors_prev;
306 ✗ const int baseline_len = mode == 4 ? b->q_unit_cnt_prev :
307 ✗ channel_idx ? b->band_ext_q_unit :
308 b->q_unit_cnt_prev;
309
310 ✗ const int len = get_bits(gb, 2) + 2;
311 ✗ const int unit_cnt = FFMIN(b->band_ext_q_unit, baseline_len);
312 ✗ const VLC *tab = &sf_vlc[1][len];
313
314 ✗ for (int i = 0; i < unit_cnt; i++) {
315 ✗ int dist = get_vlc2(gb, tab->table, ATRAC9_SF_VLC_BITS, 1);
316 ✗ c->scalefactors[i] = baseline[i] + dist;
317 }
318
319 ✗ for (int i = unit_cnt; i < b->band_ext_q_unit; i++)
320 ✗ c->scalefactors[i] = get_bits(gb, 5);
321
322 ✗ break;
323 }
324 ✗ case 3: { /* VLC offset with baseline */
325 ✗ const int *baseline = channel_idx ? b->channel[0].scalefactors :
326 c->scalefactors_prev;
327 ✗ const int baseline_len = channel_idx ? b->band_ext_q_unit :
328 b->q_unit_cnt_prev;
329
330 ✗ const int base = get_bits(gb, 5) - (1 << (5 - 1));
331 ✗ const int len = get_bits(gb, 2) + 1;
332 ✗ const int unit_cnt = FFMIN(b->band_ext_q_unit, baseline_len);
333 ✗ const VLC *tab = &sf_vlc[0][len];
334
335 ✗ c->scalefactors[0] = get_bits(gb, len);
336
337 ✗ for (int i = 1; i < unit_cnt; i++) {
338 ✗ int val = c->scalefactors[i - 1] + get_vlc2(gb, tab->table,
339 ATRAC9_SF_VLC_BITS, 1);
340 ✗ c->scalefactors[i] = val & ((1 << len) - 1);
341 }
342
343 ✗ for (int i = 0; i < unit_cnt; i++)
344 ✗ c->scalefactors[i] += base + baseline[i];
345
346 ✗ for (int i = unit_cnt; i < b->band_ext_q_unit; i++)
347 ✗ c->scalefactors[i] = get_bits(gb, 5);
348 ✗ break;
349 }
350 }
351
352 ✗ for (int i = 0; i < b->band_ext_q_unit; i++)
353 ✗ if (c->scalefactors[i] < 0 || c->scalefactors[i] > 31)
354 ✗ return AVERROR_INVALIDDATA;
355
356 ✗ memcpy(c->scalefactors_prev, c->scalefactors, sizeof(c->scalefactors));
357
358 ✗ return 0;
359 }
360
361 ✗ static inline void calc_codebook_idx(ATRAC9Context *s, ATRAC9BlockData *b,
362 ATRAC9ChannelData *c)
363 {
364 ✗ int avg = 0;
365 ✗ const int last_sf = c->scalefactors[c->q_unit_cnt];
366
367 ✗ memset(c->codebookset, 0, sizeof(c->codebookset));
368
369 ✗ if (c->q_unit_cnt <= 1)
370 ✗ return;
371 ✗ if (s->samplerate_idx > 7)
372 ✗ return;
373
374 ✗ c->scalefactors[c->q_unit_cnt] = c->scalefactors[c->q_unit_cnt - 1];
375
376 ✗ if (c->q_unit_cnt > 12) {
377 ✗ for (int i = 0; i < 12; i++)
378 ✗ avg += c->scalefactors[i];
379 ✗ avg = (avg + 6) / 12;
380 }
381
382 ✗ for (int i = 8; i < c->q_unit_cnt; i++) {
383 ✗ const int prev = c->scalefactors[i - 1];
384 ✗ const int cur = c->scalefactors[i ];
385 ✗ const int next = c->scalefactors[i + 1];
386 ✗ const int min = FFMIN(prev, next);
387 ✗ if ((cur - min >= 3 || 2*cur - prev - next >= 3))
388 ✗ c->codebookset[i] = 1;
389 }
390
391
392 ✗ for (int i = 12; i < c->q_unit_cnt; i++) {
393 ✗ const int cur = c->scalefactors[i];
394 ✗ const int cnd = at9_q_unit_to_coeff_cnt[i] == 16;
395 ✗ const int min = FFMIN(c->scalefactors[i + 1], c->scalefactors[i - 1]);
396 ✗ if (c->codebookset[i])
397 ✗ continue;
398
399 ✗ c->codebookset[i] = (((cur - min) >= 2) && (cur >= (avg - cnd)));
400 }
401
402 ✗ c->scalefactors[c->q_unit_cnt] = last_sf;
403 }
404
405 ✗ static inline void read_coeffs_coarse(ATRAC9Context *s, ATRAC9BlockData *b,
406 ATRAC9ChannelData *c, GetBitContext *gb)
407 {
408 ✗ const int max_prec = s->samplerate_idx > 7 ? 1 : 7;
409
410 ✗ memset(c->q_coeffs_coarse, 0, sizeof(c->q_coeffs_coarse));
411
412 ✗ for (int i = 0; i < c->q_unit_cnt; i++) {
413 ✗ int *coeffs = &c->q_coeffs_coarse[at9_q_unit_to_coeff_idx[i]];
414 ✗ const int bands = at9_q_unit_to_coeff_cnt[i];
415 ✗ const int prec = c->precision_coarse[i] + 1;
416
417 ✗ if (prec <= max_prec) {
418 ✗ const int cb = c->codebookset[i];
419 ✗ const int cbi = at9_q_unit_to_codebookidx[i];
420 ✗ const VLC *tab = &coeff_vlc[cb][prec][cbi];
421 ✗ const HuffmanCodebook *huff = &at9_huffman_coeffs[cb][prec][cbi];
422 ✗ const int groups = bands >> huff->value_cnt_pow;
423
424 ✗ for (int j = 0; j < groups; j++) {
425 ✗ uint16_t val = get_vlc2(gb, tab->table, ATRAC9_COEFF_VLC_BITS, 2);
426
427 ✗ for (int k = 0; k < huff->value_cnt; k++) {
428 ✗ coeffs[k] = sign_extend(val, huff->value_bits);
429 ✗ val >>= huff->value_bits;
430 }
431
432 ✗ coeffs += huff->value_cnt;
433 }
434 } else {
435 ✗ for (int j = 0; j < bands; j++)
436 ✗ coeffs[j] = sign_extend(get_bits(gb, prec), prec);
437 }
438 }
439 }
440
441 ✗ static inline void read_coeffs_fine(ATRAC9Context *s, ATRAC9BlockData *b,
442 ATRAC9ChannelData *c, GetBitContext *gb)
443 {
444 ✗ memset(c->q_coeffs_fine, 0, sizeof(c->q_coeffs_fine));
445
446 ✗ for (int i = 0; i < c->q_unit_cnt; i++) {
447 ✗ const int start = at9_q_unit_to_coeff_idx[i + 0];
448 ✗ const int end = at9_q_unit_to_coeff_idx[i + 1];
449 ✗ const int len = c->precision_fine[i] + 1;
450
451 ✗ if (c->precision_fine[i] <= 0)
452 ✗ continue;
453
454 ✗ for (int j = start; j < end; j++)
455 ✗ c->q_coeffs_fine[j] = sign_extend(get_bits(gb, len), len);
456 }
457 }
458
459 ✗ static inline void dequantize(ATRAC9Context *s, ATRAC9BlockData *b,
460 ATRAC9ChannelData *c)
461 {
462 ✗ memset(c->coeffs, 0, sizeof(c->coeffs));
463
464 ✗ for (int i = 0; i < c->q_unit_cnt; i++) {
465 ✗ const int start = at9_q_unit_to_coeff_idx[i + 0];
466 ✗ const int end = at9_q_unit_to_coeff_idx[i + 1];
467
468 ✗ const float coarse_c = at9_quant_step_coarse[c->precision_coarse[i]];
469 ✗ const float fine_c = at9_quant_step_fine[c->precision_fine[i]];
470
471 ✗ for (int j = start; j < end; j++) {
472 ✗ const float vc = c->q_coeffs_coarse[j] * coarse_c;
473 ✗ const float vf = c->q_coeffs_fine[j] * fine_c;
474 ✗ c->coeffs[j] = vc + vf;
475 }
476 }
477 }
478
479 ✗ static inline void apply_intensity_stereo(ATRAC9Context *s, ATRAC9BlockData *b,
480 const int stereo)
481 {
482 ✗ float *src = b->channel[ b->cpe_base_channel].coeffs;
483 ✗ float *dst = b->channel[!b->cpe_base_channel].coeffs;
484
485 ✗ if (!stereo)
486 ✗ return;
487
488 ✗ if (b->q_unit_cnt <= b->stereo_q_unit)
489 ✗ return;
490
491 ✗ for (int i = b->stereo_q_unit; i < b->q_unit_cnt; i++) {
492 ✗ const int sign = b->is_signs[i];
493 ✗ const int start = at9_q_unit_to_coeff_idx[i + 0];
494 ✗ const int end = at9_q_unit_to_coeff_idx[i + 1];
495 ✗ for (int j = start; j < end; j++)
496 ✗ dst[j] = sign*src[j];
497 }
498 }
499
500 ✗ static inline void apply_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b,
501 const int stereo)
502 {
503 ✗ for (int i = 0; i <= stereo; i++) {
504 ✗ float *coeffs = b->channel[i].coeffs;
505 ✗ for (int j = 0; j < b->q_unit_cnt; j++) {
506 ✗ const int start = at9_q_unit_to_coeff_idx[j + 0];
507 ✗ const int end = at9_q_unit_to_coeff_idx[j + 1];
508 ✗ const int scalefactor = b->channel[i].scalefactors[j];
509 ✗ const float scale = at9_scalefactor_c[scalefactor];
510 ✗ for (int k = start; k < end; k++)
511 ✗ coeffs[k] *= scale;
512 }
513 }
514 }
515
516 ✗ static inline void fill_with_noise(ATRAC9Context *s, ATRAC9ChannelData *c,
517 int start, int count)
518 {
519 ✗ float maxval = 0.0f;
520 ✗ for (int i = 0; i < count; i += 2) {
521 double tmp[2];
522 ✗ av_bmg_get(&s->lfg, tmp);
523 ✗ c->coeffs[start + i + 0] = tmp[0];
524 ✗ c->coeffs[start + i + 1] = tmp[1];
525 ✗ maxval = FFMAX(FFMAX(FFABS(tmp[0]), FFABS(tmp[1])), maxval);
526 }
527 /* Normalize */
528 ✗ for (int i = 0; i < count; i++)
529 ✗ c->coeffs[start + i] /= maxval;
530 }
531
532 ✗ static inline void scale_band_ext_coeffs(ATRAC9ChannelData *c, float sf[6],
533 const int s_unit, const int e_unit)
534 {
535 ✗ for (int i = s_unit; i < e_unit; i++) {
536 ✗ const int start = at9_q_unit_to_coeff_idx[i + 0];
537 ✗ const int end = at9_q_unit_to_coeff_idx[i + 1];
538 ✗ for (int j = start; j < end; j++)
539 ✗ c->coeffs[j] *= sf[i - s_unit];
540 }
541 }
542
543 ✗ static inline void apply_band_extension(ATRAC9Context *s, ATRAC9BlockData *b,
544 const int stereo)
545 {
546 ✗ const int g_units[4] = { /* A, B, C, total units */
547 ✗ b->q_unit_cnt,
548 ✗ at9_tab_band_ext_group[b->q_unit_cnt - 13][0],
549 ✗ at9_tab_band_ext_group[b->q_unit_cnt - 13][1],
550 ✗ FFMAX(g_units[2], 22),
551 };
552
553 ✗ const int g_bins[4] = { /* A, B, C, total bins */
554 ✗ at9_q_unit_to_coeff_idx[g_units[0]],
555 ✗ at9_q_unit_to_coeff_idx[g_units[1]],
556 ✗ at9_q_unit_to_coeff_idx[g_units[2]],
557 ✗ at9_q_unit_to_coeff_idx[g_units[3]],
558 };
559
560 ✗ for (int ch = 0; ch <= stereo; ch++) {
561 ✗ ATRAC9ChannelData *c = &b->channel[ch];
562
563 /* Mirror the spectrum */
564 ✗ for (int i = 0; i < 3; i++)
565 ✗ for (int j = 0; j < (g_bins[i + 1] - g_bins[i + 0]); j++)
566 ✗ c->coeffs[g_bins[i] + j] = c->coeffs[g_bins[i] - j - 1];
567
568 ✗ switch (c->band_ext) {
569 ✗ case 0: {
570 ✗ float sf[6] = { 0.0f };
571 ✗ const int l = g_units[3] - g_units[0] - 1;
572 ✗ const int n_start = at9_q_unit_to_coeff_idx[g_units[3] - 1];
573 ✗ const int n_cnt = at9_q_unit_to_coeff_cnt[g_units[3] - 1];
574 ✗ switch (at9_tab_band_ext_group[b->q_unit_cnt - 13][2]) {
575 ✗ case 3:
576 ✗ sf[0] = at9_band_ext_scales_m0[0][0][c->band_ext_data[0]];
577 ✗ sf[1] = at9_band_ext_scales_m0[0][1][c->band_ext_data[0]];
578 ✗ sf[2] = at9_band_ext_scales_m0[0][2][c->band_ext_data[1]];
579 ✗ sf[3] = at9_band_ext_scales_m0[0][3][c->band_ext_data[2]];
580 ✗ sf[4] = at9_band_ext_scales_m0[0][4][c->band_ext_data[3]];
581 ✗ break;
582 ✗ case 4:
583 ✗ sf[0] = at9_band_ext_scales_m0[1][0][c->band_ext_data[0]];
584 ✗ sf[1] = at9_band_ext_scales_m0[1][1][c->band_ext_data[0]];
585 ✗ sf[2] = at9_band_ext_scales_m0[1][2][c->band_ext_data[1]];
586 ✗ sf[3] = at9_band_ext_scales_m0[1][3][c->band_ext_data[2]];
587 ✗ sf[4] = at9_band_ext_scales_m0[1][4][c->band_ext_data[3]];
588 ✗ break;
589 ✗ case 5:
590 ✗ sf[0] = at9_band_ext_scales_m0[2][0][c->band_ext_data[0]];
591 ✗ sf[1] = at9_band_ext_scales_m0[2][1][c->band_ext_data[1]];
592 ✗ sf[2] = at9_band_ext_scales_m0[2][2][c->band_ext_data[1]];
593 ✗ break;
594 }
595
596 ✗ sf[l] = at9_scalefactor_c[c->scalefactors[g_units[0]]];
597
598 ✗ fill_with_noise(s, c, n_start, n_cnt);
599 ✗ scale_band_ext_coeffs(c, sf, g_units[0], g_units[3]);
600 ✗ break;
601 }
602 ✗ case 1: {
603 float sf[6];
604 ✗ for (int i = g_units[0]; i < g_units[3]; i++)
605 ✗ sf[i - g_units[0]] = at9_scalefactor_c[c->scalefactors[i]];
606
607 ✗ fill_with_noise(s, c, g_bins[0], g_bins[3] - g_bins[0]);
608 ✗ scale_band_ext_coeffs(c, sf, g_units[0], g_units[3]);
609 ✗ break;
610 }
611 ✗ case 2: {
612 ✗ const float g_sf[2] = {
613 ✗ at9_band_ext_scales_m2[c->band_ext_data[0]],
614 ✗ at9_band_ext_scales_m2[c->band_ext_data[1]],
615 };
616
617 ✗ for (int i = 0; i < 2; i++)
618 ✗ for (int j = g_bins[i + 0]; j < g_bins[i + 1]; j++)
619 ✗ c->coeffs[j] *= g_sf[i];
620 ✗ break;
621 }
622 ✗ case 3: {
623 ✗ float scale = at9_band_ext_scales_m3[c->band_ext_data[0]][0];
624 ✗ float rate = at9_band_ext_scales_m3[c->band_ext_data[1]][1];
625 ✗ rate = pow(2, rate);
626 ✗ for (int i = g_bins[0]; i < g_bins[3]; i++) {
627 ✗ scale *= rate;
628 ✗ c->coeffs[i] *= scale;
629 }
630 ✗ break;
631 }
632 ✗ case 4: {
633 ✗ const float m = at9_band_ext_scales_m4[c->band_ext_data[0]];
634 ✗ const float g_sf[3] = { 0.7079468f*m, 0.5011902f*m, 0.3548279f*m };
635
636 ✗ for (int i = 0; i < 3; i++)
637 ✗ for (int j = g_bins[i + 0]; j < g_bins[i + 1]; j++)
638 ✗ c->coeffs[j] *= g_sf[i];
639 ✗ break;
640 }
641 }
642 }
643 }
644
645 ✗ static int atrac9_decode_block(ATRAC9Context *s, GetBitContext *gb,
646 ATRAC9BlockData *b, AVFrame *frame,
647 int frame_idx, int block_idx)
648 {
649 ✗ const int first_in_pkt = !get_bits1(gb);
650 ✗ const int reuse_params = get_bits1(gb);
651 ✗ const int stereo = s->block_config->type[block_idx] == ATRAC9_BLOCK_TYPE_CPE;
652
653 ✗ if (s->block_config->type[block_idx] == ATRAC9_BLOCK_TYPE_LFE) {
654 ✗ ATRAC9ChannelData *c = &b->channel[0];
655 ✗ const int precision = reuse_params ? 8 : 4;
656 ✗ c->q_unit_cnt = b->q_unit_cnt = 2;
657
658 ✗ memset(c->scalefactors, 0, sizeof(c->scalefactors));
659 ✗ memset(c->q_coeffs_fine, 0, sizeof(c->q_coeffs_fine));
660 ✗ memset(c->q_coeffs_coarse, 0, sizeof(c->q_coeffs_coarse));
661
662 ✗ for (int i = 0; i < b->q_unit_cnt; i++) {
663 ✗ c->scalefactors[i] = get_bits(gb, 5);
664 ✗ c->precision_coarse[i] = precision;
665 ✗ c->precision_fine[i] = 0;
666 }
667
668 ✗ for (int i = 0; i < c->q_unit_cnt; i++) {
669 ✗ const int start = at9_q_unit_to_coeff_idx[i + 0];
670 ✗ const int end = at9_q_unit_to_coeff_idx[i + 1];
671 ✗ for (int j = start; j < end; j++)
672 ✗ c->q_coeffs_coarse[j] = get_bits(gb, c->precision_coarse[i] + 1);
673 }
674
675 ✗ dequantize (s, b, c);
676 ✗ apply_scalefactors(s, b, 0);
677
678 ✗ goto imdct;
679 }
680
681 ✗ if (first_in_pkt && reuse_params) {
682 ✗ av_log(s->avctx, AV_LOG_ERROR, "Invalid block flags!\n");
683 ✗ return AVERROR_INVALIDDATA;
684 }
685
686 /* Band parameters */
687 ✗ if (!reuse_params) {
688 int stereo_band, ext_band;
689 ✗ const int min_band_count = s->samplerate_idx > 7 ? 1 : 3;
690 ✗ b->reuseable = 0;
691 ✗ b->band_count = get_bits(gb, 4) + min_band_count;
692 ✗ b->q_unit_cnt = at9_tab_band_q_unit_map[b->band_count];
693
694 ✗ b->band_ext_q_unit = b->stereo_q_unit = b->q_unit_cnt;
695
696 ✗ if (b->band_count > at9_tab_sri_max_bands[s->samplerate_idx]) {
697 ✗ av_log(s->avctx, AV_LOG_ERROR, "Invalid band count %i!\n",
698 b->band_count);
699 ✗ return AVERROR_INVALIDDATA;
700 }
701
702 ✗ if (stereo) {
703 ✗ stereo_band = get_bits(gb, 4) + min_band_count;
704 ✗ if (stereo_band > b->band_count) {
705 ✗ av_log(s->avctx, AV_LOG_ERROR, "Invalid stereo band %i!\n",
706 stereo_band);
707 ✗ return AVERROR_INVALIDDATA;
708 }
709 ✗ b->stereo_q_unit = at9_tab_band_q_unit_map[stereo_band];
710 }
711
712 ✗ b->has_band_ext = get_bits1(gb);
713 ✗ if (b->has_band_ext) {
714 ✗ ext_band = get_bits(gb, 4) + min_band_count;
715 ✗ if (ext_band < b->band_count) {
716 ✗ av_log(s->avctx, AV_LOG_ERROR, "Invalid extension band %i!\n",
717 ext_band);
718 ✗ return AVERROR_INVALIDDATA;
719 }
720 ✗ b->band_ext_q_unit = at9_tab_band_q_unit_map[ext_band];
721 }
722 ✗ b->reuseable = 1;
723 }
724 ✗ if (!b->reuseable) {
725 ✗ av_log(s->avctx, AV_LOG_ERROR, "invalid block reused!\n");
726 ✗ return AVERROR_INVALIDDATA;
727 }
728
729 /* Calculate bit alloc gradient */
730 ✗ if (parse_gradient(s, b, gb))
731 ✗ return AVERROR_INVALIDDATA;
732
733 /* IS data */
734 ✗ b->cpe_base_channel = 0;
735 ✗ if (stereo) {
736 ✗ b->cpe_base_channel = get_bits1(gb);
737 ✗ if (get_bits1(gb)) {
738 ✗ for (int i = b->stereo_q_unit; i < b->q_unit_cnt; i++)
739 ✗ b->is_signs[i] = 1 - 2*get_bits1(gb);
740 } else {
741 ✗ for (int i = 0; i < FF_ARRAY_ELEMS(b->is_signs); i++)
742 ✗ b->is_signs[i] = 1;
743 }
744 }
745
746 /* Band extension */
747 ✗ if (parse_band_ext(s, b, gb, stereo))
748 ✗ return AVERROR_INVALIDDATA;
749
750 /* Scalefactors */
751 ✗ for (int i = 0; i <= stereo; i++) {
752 ✗ ATRAC9ChannelData *c = &b->channel[i];
753 ✗ c->q_unit_cnt = i == b->cpe_base_channel ? b->q_unit_cnt :
754 b->stereo_q_unit;
755 ✗ if (read_scalefactors(s, b, c, gb, i, first_in_pkt))
756 ✗ return AVERROR_INVALIDDATA;
757
758 ✗ calc_precision (s, b, c);
759 ✗ calc_codebook_idx (s, b, c);
760 ✗ read_coeffs_coarse(s, b, c, gb);
761 ✗ read_coeffs_fine (s, b, c, gb);
762 ✗ dequantize (s, b, c);
763 }
764
765 ✗ b->q_unit_cnt_prev = b->has_band_ext ? b->band_ext_q_unit : b->q_unit_cnt;
766
767 ✗ apply_intensity_stereo(s, b, stereo);
768 ✗ apply_scalefactors (s, b, stereo);
769
770 ✗ if (b->has_band_ext && b->has_band_ext_data)
771 ✗ apply_band_extension (s, b, stereo);
772
773 ✗ imdct:
774 ✗ for (int i = 0; i <= stereo; i++) {
775 ✗ ATRAC9ChannelData *c = &b->channel[i];
776 ✗ const int dst_idx = s->block_config->plane_map[block_idx][i];
777 ✗ const int wsize = 1 << s->frame_log2;
778 ✗ const ptrdiff_t offset = wsize*frame_idx*sizeof(float);
779 ✗ float *dst = (float *)(frame->extended_data[dst_idx] + offset);
780
781 ✗ s->imdct.imdct_half(&s->imdct, s->temp, c->coeffs);
782 ✗ s->fdsp->vector_fmul_window(dst, c->prev_win, s->temp,
783 ✗ s->imdct_win, wsize >> 1);
784 ✗ memcpy(c->prev_win, s->temp + (wsize >> 1), sizeof(float)*wsize >> 1);
785 }
786
787 ✗ return 0;
788 }
789
790 ✗ static int atrac9_decode_frame(AVCodecContext *avctx, AVFrame *frame,
791 int *got_frame_ptr, AVPacket *avpkt)
792 {
793 int ret;
794 GetBitContext gb;
795 ✗ ATRAC9Context *s = avctx->priv_data;
796 ✗ const int frames = FFMIN(avpkt->size / s->avg_frame_size, s->frame_count);
797
798 ✗ frame->nb_samples = (1 << s->frame_log2) * frames;
799 ✗ ret = ff_get_buffer(avctx, frame, 0);
800 ✗ if (ret < 0)
801 ✗ return ret;
802
803 ✗ init_get_bits8(&gb, avpkt->data, avpkt->size);
804
805 ✗ for (int i = 0; i < frames; i++) {
806 ✗ for (int j = 0; j < s->block_config->count; j++) {
807 ✗ ret = atrac9_decode_block(s, &gb, &s->block[j], frame, i, j);
808 ✗ if (ret)
809 ✗ return ret;
810 ✗ align_get_bits(&gb);
811 }
812 }
813
814 ✗ *got_frame_ptr = 1;
815
816 ✗ return avctx->block_align;
817 }
818
819 ✗ static void atrac9_decode_flush(AVCodecContext *avctx)
820 {
821 ✗ ATRAC9Context *s = avctx->priv_data;
822
823 ✗ for (int j = 0; j < s->block_config->count; j++) {
824 ✗ ATRAC9BlockData *b = &s->block[j];
825 ✗ const int stereo = s->block_config->type[j] == ATRAC9_BLOCK_TYPE_CPE;
826 ✗ for (int i = 0; i <= stereo; i++) {
827 ✗ ATRAC9ChannelData *c = &b->channel[i];
828 ✗ memset(c->prev_win, 0, sizeof(c->prev_win));
829 }
830 }
831 }
832
833 ✗ static av_cold int atrac9_decode_close(AVCodecContext *avctx)
834 {
835 ✗ ATRAC9Context *s = avctx->priv_data;
836
837 ✗ ff_mdct_end(&s->imdct);
838 ✗ av_freep(&s->fdsp);
839
840 ✗ return 0;
841 }
842
843 ✗ static av_cold void atrac9_init_vlc(VLC *vlc, int nb_bits, int nb_codes,
844 const uint8_t (**tab)[2],
845 unsigned *buf_offset, int offset)
846 {
847 static VLCElem vlc_buf[24812];
848
849 ✗ vlc->table = &vlc_buf[*buf_offset];
850 ✗ vlc->table_allocated = FF_ARRAY_ELEMS(vlc_buf) - *buf_offset;
851 ✗ ff_init_vlc_from_lengths(vlc, nb_bits, nb_codes,
852 ✗ &(*tab)[0][1], 2, &(*tab)[0][0], 2, 1,
853 offset, INIT_VLC_STATIC_OVERLONG, NULL);
854 ✗ *buf_offset += vlc->table_size;
855 ✗ *tab += nb_codes;
856 }
857
858 ✗ static av_cold void atrac9_init_static(void)
859 {
860 const uint8_t (*tab)[2];
861 ✗ unsigned offset = 0;
862
863 /* Unsigned scalefactor VLCs */
864 ✗ tab = at9_sfb_a_tab;
865 ✗ for (int i = 1; i < 7; i++) {
866 ✗ const HuffmanCodebook *hf = &at9_huffman_sf_unsigned[i];
867
868 ✗ atrac9_init_vlc(&sf_vlc[0][i], ATRAC9_SF_VLC_BITS,
869 ✗ hf->size, &tab, &offset, 0);
870 }
871
872 /* Signed scalefactor VLCs */
873 ✗ tab = at9_sfb_b_tab;
874 ✗ for (int i = 2; i < 6; i++) {
875 ✗ const HuffmanCodebook *hf = &at9_huffman_sf_signed[i];
876
877 /* The symbols are signed integers in the range -16..15;
878 * the values in the source table are offset by 16 to make
879 * them fit into an uint8_t; the -16 reverses this shift. */
880 ✗ atrac9_init_vlc(&sf_vlc[1][i], ATRAC9_SF_VLC_BITS,
881 ✗ hf->size, &tab, &offset, -16);
882 }
883
884 /* Coefficient VLCs */
885 ✗ tab = at9_coeffs_tab;
886 ✗ for (int i = 0; i < 2; i++) {
887 ✗ for (int j = 2; j < 8; j++) {
888 ✗ for (int k = i; k < 4; k++) {
889 ✗ const HuffmanCodebook *hf = &at9_huffman_coeffs[i][j][k];
890 ✗ atrac9_init_vlc(&coeff_vlc[i][j][k], ATRAC9_COEFF_VLC_BITS,
891 ✗ hf->size, &tab, &offset, 0);
892 }
893 }
894 }
895 }
896
897 ✗ static av_cold int atrac9_decode_init(AVCodecContext *avctx)
898 {
899 static AVOnce static_table_init = AV_ONCE_INIT;
900 GetBitContext gb;
901 ✗ ATRAC9Context *s = avctx->priv_data;
902 int version, block_config_idx, superframe_idx, alloc_c_len;
903
904 ✗ s->avctx = avctx;
905
906 ✗ av_lfg_init(&s->lfg, 0xFBADF00D);
907
908 ✗ if (avctx->block_align <= 0) {
909 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid block align\n");
910 ✗ return AVERROR_INVALIDDATA;
911 }
912
913 ✗ if (avctx->extradata_size != 12) {
914 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid extradata length!\n");
915 ✗ return AVERROR_INVALIDDATA;
916 }
917
918 ✗ version = AV_RL32(avctx->extradata);
919 ✗ if (version > 2) {
920 ✗ av_log(avctx, AV_LOG_ERROR, "Unsupported version (%i)!\n", version);
921 ✗ return AVERROR_INVALIDDATA;
922 }
923
924 ✗ init_get_bits8(&gb, avctx->extradata + 4, avctx->extradata_size);
925
926 ✗ if (get_bits(&gb, 8) != 0xFE) {
927 ✗ av_log(avctx, AV_LOG_ERROR, "Incorrect magic byte!\n");
928 ✗ return AVERROR_INVALIDDATA;
929 }
930
931 ✗ s->samplerate_idx = get_bits(&gb, 4);
932 ✗ avctx->sample_rate = at9_tab_samplerates[s->samplerate_idx];
933
934 ✗ block_config_idx = get_bits(&gb, 3);
935 ✗ if (block_config_idx > 5) {
936 ✗ av_log(avctx, AV_LOG_ERROR, "Incorrect block config!\n");
937 ✗ return AVERROR_INVALIDDATA;
938 }
939 ✗ s->block_config = &at9_block_layout[block_config_idx];
940
941 ✗ av_channel_layout_uninit(&avctx->ch_layout);
942 ✗ avctx->ch_layout = s->block_config->channel_layout;
943 ✗ avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
944
945 ✗ if (get_bits1(&gb)) {
946 ✗ av_log(avctx, AV_LOG_ERROR, "Incorrect verification bit!\n");
947 ✗ return AVERROR_INVALIDDATA;
948 }
949
950 /* Average frame size in bytes */
951 ✗ s->avg_frame_size = get_bits(&gb, 11) + 1;
952
953 ✗ superframe_idx = get_bits(&gb, 2);
954 ✗ if (superframe_idx & 1) {
955 ✗ av_log(avctx, AV_LOG_ERROR, "Invalid superframe index!\n");
956 ✗ return AVERROR_INVALIDDATA;
957 }
958
959 ✗ s->frame_count = 1 << superframe_idx;
960 ✗ s->frame_log2 = at9_tab_sri_frame_log2[s->samplerate_idx];
961
962 ✗ if (ff_mdct_init(&s->imdct, s->frame_log2 + 1, 1, 1.0f / 32768.0f))
963 ✗ return AVERROR(ENOMEM);
964
965 ✗ s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
966 ✗ if (!s->fdsp)
967 ✗ return AVERROR(ENOMEM);
968
969 /* iMDCT window */
970 ✗ for (int i = 0; i < (1 << s->frame_log2); i++) {
971 ✗ const int len = 1 << s->frame_log2;
972 ✗ const float sidx = ( i + 0.5f) / len;
973 ✗ const float eidx = (len - i - 0.5f) / len;
974 ✗ const float s_c = sinf(sidx*M_PI - M_PI_2)*0.5f + 0.5f;
975 ✗ const float e_c = sinf(eidx*M_PI - M_PI_2)*0.5f + 0.5f;
976 ✗ s->imdct_win[i] = s_c / ((s_c * s_c) + (e_c * e_c));
977 }
978
979 /* Allocation curve */
980 ✗ alloc_c_len = FF_ARRAY_ELEMS(at9_tab_b_dist);
981 ✗ for (int i = 1; i <= alloc_c_len; i++)
982 ✗ for (int j = 0; j < i; j++)
983 ✗ s->alloc_curve[i - 1][j] = at9_tab_b_dist[(j * alloc_c_len) / i];
984
985 ✗ ff_thread_once(&static_table_init, atrac9_init_static);
986
987 ✗ return 0;
988 }
989
990 const FFCodec ff_atrac9_decoder = {
991 .p.name = "atrac9",
992 .p.long_name = NULL_IF_CONFIG_SMALL("ATRAC9 (Adaptive TRansform Acoustic Coding 9)"),
993 .p.type = AVMEDIA_TYPE_AUDIO,
994 .p.id = AV_CODEC_ID_ATRAC9,
995 .priv_data_size = sizeof(ATRAC9Context),
996 .init = atrac9_decode_init,
997 .close = atrac9_decode_close,
998 FF_CODEC_DECODE_CB(atrac9_decode_frame),
999 .flush = atrac9_decode_flush,
1000 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
1001 .p.capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1002 };
1003