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