3 * Copyright (c) 2018 Rostislav Pehlivanov <atomnuker@gmail.com>
5 * This file is part of FFmpeg.
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.
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.
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
25 #include "atrac9tab.h"
26 #include "libavutil/lfg.h"
27 #include "libavutil/float_dsp.h"
29 typedef struct ATRAC9ChannelData {
33 int32_t scalefactors[31];
34 int32_t scalefactors_prev[31];
36 int precision_coarse[30];
37 int precision_fine[30];
38 int precision_mask[30];
42 int32_t q_coeffs_coarse[256];
43 int32_t q_coeffs_fine[256];
45 DECLARE_ALIGNED(32, float, coeffs )[256];
46 DECLARE_ALIGNED(32, float, prev_win)[128];
49 typedef struct ATRAC9BlockData {
50 ATRAC9ChannelData channel[2];
57 /* Stereo block only */
60 /* Band extension only */
62 int has_band_ext_data;
78 typedef struct ATRAC9Context {
79 AVCodecContext *avctx;
80 AVFloatDSPContext *fdsp;
82 ATRAC9BlockData block[5];
90 const ATRAC9BlockConfig *block_config;
92 /* Generated on init */
93 VLC sf_vlc[2][8]; /* Signed/unsigned, length */
94 VLC coeff_vlc[2][8][4]; /* Cookbook, precision, cookbook index */
95 uint8_t alloc_curve[48][48];
96 DECLARE_ALIGNED(32, float, imdct_win)[256];
98 DECLARE_ALIGNED(32, float, temp)[256];
101 static inline int parse_gradient(ATRAC9Context *s, ATRAC9BlockData *b,
106 int values, sign, base;
110 b->grad_mode = get_bits(gb, 2);
112 grad_range[0] = get_bits(gb, 5);
114 grad_value[0] = get_bits(gb, 5);
117 grad_range[0] = get_bits(gb, 6);
118 grad_range[1] = get_bits(gb, 6) + 1;
119 grad_value[0] = get_bits(gb, 5);
120 grad_value[1] = get_bits(gb, 5);
122 b->grad_boundary = get_bits(gb, 4);
124 if (grad_range[0] >= grad_range[1] || grad_range[1] > 31)
125 return AVERROR_INVALIDDATA;
127 if (b->grad_boundary > b->q_unit_cnt)
128 return AVERROR_INVALIDDATA;
130 values = grad_value[1] - grad_value[0];
131 sign = 1 - 2*(values < 0);
132 base = grad_value[0] + sign;
133 scale = (FFABS(values) - 1) / 31.0f;
134 curve = s->alloc_curve[grad_range[1] - grad_range[0] - 1];
136 for (int i = 0; i <= b->q_unit_cnt; i++)
137 b->gradient[i] = grad_value[i >= grad_range[0]];
139 for (int i = grad_range[0]; i < grad_range[1]; i++)
140 b->gradient[i] = base + sign*((int)(scale*curve[i - grad_range[0]]));
145 static inline void calc_precision(ATRAC9Context *s, ATRAC9BlockData *b,
146 ATRAC9ChannelData *c)
148 memset(c->precision_mask, 0, sizeof(c->precision_mask));
149 for (int i = 1; i < b->q_unit_cnt; i++) {
150 const int delta = FFABS(c->scalefactors[i] - c->scalefactors[i - 1]) - 1;
152 const int neg = c->scalefactors[i - 1] > c->scalefactors[i];
153 c->precision_mask[i - neg] += FFMIN(delta, 5);
158 for (int i = 0; i < b->q_unit_cnt; i++) {
159 c->precision_coarse[i] = c->scalefactors[i];
160 c->precision_coarse[i] += c->precision_mask[i] - b->gradient[i];
161 if (c->precision_coarse[i] < 0)
163 switch (b->grad_mode) {
165 c->precision_coarse[i] >>= 1;
168 c->precision_coarse[i] = (3 * c->precision_coarse[i]) >> 3;
171 c->precision_coarse[i] >>= 2;
176 for (int i = 0; i < b->q_unit_cnt; i++)
177 c->precision_coarse[i] = c->scalefactors[i] - b->gradient[i];
181 for (int i = 0; i < b->q_unit_cnt; i++)
182 c->precision_coarse[i] = FFMAX(c->precision_coarse[i], 1);
184 for (int i = 0; i < b->grad_boundary; i++)
185 c->precision_coarse[i]++;
187 for (int i = 0; i < b->q_unit_cnt; i++) {
188 c->precision_fine[i] = 0;
189 if (c->precision_coarse[i] > 15) {
190 c->precision_fine[i] = FFMIN(c->precision_coarse[i], 30) - 15;
191 c->precision_coarse[i] = 15;
196 static inline int parse_band_ext(ATRAC9Context *s, ATRAC9BlockData *b,
197 GetBitContext *gb, int stereo)
201 if (b->has_band_ext) {
202 if (b->q_unit_cnt < 13 || b->q_unit_cnt > 20)
203 return AVERROR_INVALIDDATA;
204 ext_band = at9_tab_band_ext_group[b->q_unit_cnt - 13][2];
206 b->channel[1].band_ext = get_bits(gb, 2);
207 b->channel[1].band_ext = ext_band > 2 ? b->channel[1].band_ext : 4;
213 b->has_band_ext_data = get_bits1(gb);
214 if (!b->has_band_ext_data)
217 if (!b->has_band_ext) {
219 skip_bits_long(gb, get_bits(gb, 5));
223 b->channel[0].band_ext = get_bits(gb, 2);
224 b->channel[0].band_ext = ext_band > 2 ? b->channel[0].band_ext : 4;
226 if (!get_bits(gb, 5)) {
227 for (int i = 0; i <= stereo; i++) {
228 ATRAC9ChannelData *c = &b->channel[i];
229 const int count = at9_tab_band_ext_cnt[c->band_ext][ext_band];
230 for (int j = 0; j < count; j++) {
231 int len = at9_tab_band_ext_lengths[c->band_ext][ext_band][j];
232 c->band_ext_data[j] = av_clip_uintp2_c(c->band_ext_data[j], len);
239 for (int i = 0; i <= stereo; i++) {
240 ATRAC9ChannelData *c = &b->channel[i];
241 const int count = at9_tab_band_ext_cnt[c->band_ext][ext_band];
242 for (int j = 0; j < count; j++) {
243 int len = at9_tab_band_ext_lengths[c->band_ext][ext_band][j];
244 c->band_ext_data[j] = get_bits(gb, len);
251 static inline int read_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b,
252 ATRAC9ChannelData *c, GetBitContext *gb,
253 int channel_idx, int first_in_pkt)
255 static const uint8_t mode_map[2][4] = { { 0, 1, 2, 3 }, { 0, 2, 3, 4 } };
256 const int mode = mode_map[channel_idx][get_bits(gb, 2)];
258 memset(c->scalefactors, 0, sizeof(c->scalefactors));
260 if (first_in_pkt && (mode == 4 || ((mode == 3) && !channel_idx))) {
261 av_log(s->avctx, AV_LOG_ERROR, "Invalid scalefactor coding mode!\n");
262 return AVERROR_INVALIDDATA;
266 case 0: { /* VLC delta offset */
267 const uint8_t *sf_weights = at9_tab_sf_weights[get_bits(gb, 3)];
268 const int base = get_bits(gb, 5);
269 const int len = get_bits(gb, 2) + 3;
270 const VLC *tab = &s->sf_vlc[0][len];
272 c->scalefactors[0] = get_bits(gb, len);
274 for (int i = 1; i < b->band_ext_q_unit; i++) {
275 int val = c->scalefactors[i - 1] + get_vlc2(gb, tab->table, 9, 2);
276 c->scalefactors[i] = val & ((1 << len) - 1);
279 for (int i = 0; i < b->band_ext_q_unit; i++)
280 c->scalefactors[i] += base - sf_weights[i];
284 case 1: { /* CLC offset */
285 const int len = get_bits(gb, 2) + 2;
286 const int base = len < 5 ? get_bits(gb, 5) : 0;
287 for (int i = 0; i < b->band_ext_q_unit; i++)
288 c->scalefactors[i] = base + get_bits(gb, len);
292 case 4: { /* VLC dist to baseline */
293 const int *baseline = mode == 4 ? c->scalefactors_prev :
294 channel_idx ? b->channel[0].scalefactors :
295 c->scalefactors_prev;
296 const int baseline_len = mode == 4 ? b->q_unit_cnt_prev :
297 channel_idx ? b->band_ext_q_unit :
300 const int len = get_bits(gb, 2) + 2;
301 const int unit_cnt = FFMIN(b->band_ext_q_unit, baseline_len);
302 const VLC *tab = &s->sf_vlc[1][len];
304 for (int i = 0; i < unit_cnt; i++) {
305 int dist = get_vlc2(gb, tab->table, 9, 2);
306 c->scalefactors[i] = baseline[i] + dist;
309 for (int i = unit_cnt; i < b->band_ext_q_unit; i++)
310 c->scalefactors[i] = get_bits(gb, 5);
314 case 3: { /* VLC offset with baseline */
315 const int *baseline = channel_idx ? b->channel[0].scalefactors :
316 c->scalefactors_prev;
317 const int baseline_len = channel_idx ? b->band_ext_q_unit :
320 const int base = get_bits(gb, 5) - (1 << (5 - 1));
321 const int len = get_bits(gb, 2) + 1;
322 const int unit_cnt = FFMIN(b->band_ext_q_unit, baseline_len);
323 const VLC *tab = &s->sf_vlc[0][len];
325 c->scalefactors[0] = get_bits(gb, len);
327 for (int i = 1; i < unit_cnt; i++) {
328 int val = c->scalefactors[i - 1] + get_vlc2(gb, tab->table, 9, 2);
329 c->scalefactors[i] = val & ((1 << len) - 1);
332 for (int i = 0; i < unit_cnt; i++)
333 c->scalefactors[i] += base + baseline[i];
335 for (int i = unit_cnt; i < b->band_ext_q_unit; i++)
336 c->scalefactors[i] = get_bits(gb, 5);
341 for (int i = 0; i < b->band_ext_q_unit; i++)
342 if (c->scalefactors[i] < 0 || c->scalefactors[i] > 31)
343 return AVERROR_INVALIDDATA;
345 memcpy(c->scalefactors_prev, c->scalefactors, sizeof(c->scalefactors));
350 static inline void calc_codebook_idx(ATRAC9Context *s, ATRAC9BlockData *b,
351 ATRAC9ChannelData *c)
354 const int last_sf = c->scalefactors[c->q_unit_cnt];
356 memset(c->codebookset, 0, sizeof(c->codebookset));
358 if (c->q_unit_cnt <= 1)
360 if (s->samplerate_idx > 7)
363 c->scalefactors[c->q_unit_cnt] = c->scalefactors[c->q_unit_cnt - 1];
365 if (c->q_unit_cnt > 12) {
366 for (int i = 0; i < 12; i++)
367 avg += c->scalefactors[i];
368 avg = (avg + 6) / 12;
371 for (int i = 8; i < c->q_unit_cnt; i++) {
372 const int prev = c->scalefactors[i - 1];
373 const int cur = c->scalefactors[i ];
374 const int next = c->scalefactors[i + 1];
375 const int min = FFMIN(prev, next);
376 if ((cur - min >= 3 || 2*cur - prev - next >= 3))
377 c->codebookset[i] = 1;
381 for (int i = 12; i < c->q_unit_cnt; i++) {
382 const int cur = c->scalefactors[i];
383 const int cnd = at9_q_unit_to_coeff_cnt[i] == 16;
384 const int min = FFMIN(c->scalefactors[i + 1], c->scalefactors[i - 1]);
385 if (c->codebookset[i])
388 c->codebookset[i] = (((cur - min) >= 2) && (cur >= (avg - cnd)));
391 c->scalefactors[c->q_unit_cnt] = last_sf;
394 static inline void read_coeffs_coarse(ATRAC9Context *s, ATRAC9BlockData *b,
395 ATRAC9ChannelData *c, GetBitContext *gb)
397 const int max_prec = s->samplerate_idx > 7 ? 1 : 7;
399 memset(c->q_coeffs_coarse, 0, sizeof(c->q_coeffs_coarse));
401 for (int i = 0; i < c->q_unit_cnt; i++) {
402 int *coeffs = &c->q_coeffs_coarse[at9_q_unit_to_coeff_idx[i]];
403 const int bands = at9_q_unit_to_coeff_cnt[i];
404 const int prec = c->precision_coarse[i] + 1;
406 if (prec <= max_prec) {
407 const int cb = c->codebookset[i];
408 const int cbi = at9_q_unit_to_codebookidx[i];
409 const VLC *tab = &s->coeff_vlc[cb][prec][cbi];
410 const HuffmanCodebook *huff = &at9_huffman_coeffs[cb][prec][cbi];
411 const int groups = bands >> huff->value_cnt_pow;
413 for (int j = 0; j < groups; j++) {
414 uint16_t val = get_vlc2(gb, tab->table, 9, huff->max_bit_size);
416 for (int k = 0; k < huff->value_cnt; k++) {
417 coeffs[k] = sign_extend(val, huff->value_bits);
418 val >>= huff->value_bits;
421 coeffs += huff->value_cnt;
424 for (int j = 0; j < bands; j++)
425 coeffs[j] = sign_extend(get_bits(gb, prec), prec);
430 static inline void read_coeffs_fine(ATRAC9Context *s, ATRAC9BlockData *b,
431 ATRAC9ChannelData *c, GetBitContext *gb)
433 memset(c->q_coeffs_fine, 0, sizeof(c->q_coeffs_fine));
435 for (int i = 0; i < c->q_unit_cnt; i++) {
436 const int start = at9_q_unit_to_coeff_idx[i + 0];
437 const int end = at9_q_unit_to_coeff_idx[i + 1];
438 const int len = c->precision_fine[i] + 1;
440 if (c->precision_fine[i] <= 0)
443 for (int j = start; j < end; j++)
444 c->q_coeffs_fine[j] = sign_extend(get_bits(gb, len), len);
448 static inline void dequantize(ATRAC9Context *s, ATRAC9BlockData *b,
449 ATRAC9ChannelData *c)
451 memset(c->coeffs, 0, sizeof(c->coeffs));
453 for (int i = 0; i < c->q_unit_cnt; i++) {
454 const int start = at9_q_unit_to_coeff_idx[i + 0];
455 const int end = at9_q_unit_to_coeff_idx[i + 1];
457 const float coarse_c = at9_quant_step_coarse[c->precision_coarse[i]];
458 const float fine_c = at9_quant_step_fine[c->precision_fine[i]];
460 for (int j = start; j < end; j++) {
461 const float vc = c->q_coeffs_coarse[j] * coarse_c;
462 const float vf = c->q_coeffs_fine[j] * fine_c;
463 c->coeffs[j] = vc + vf;
468 static inline void apply_intensity_stereo(ATRAC9Context *s, ATRAC9BlockData *b,
471 float *src = b->channel[ b->cpe_base_channel].coeffs;
472 float *dst = b->channel[!b->cpe_base_channel].coeffs;
477 if (b->q_unit_cnt <= b->stereo_q_unit)
480 for (int i = b->stereo_q_unit; i < b->q_unit_cnt; i++) {
481 const int sign = b->is_signs[i];
482 const int start = at9_q_unit_to_coeff_idx[i + 0];
483 const int end = at9_q_unit_to_coeff_idx[i + 1];
484 for (int j = start; j < end; j++)
485 dst[j] = sign*src[j];
489 static inline void apply_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b,
492 for (int i = 0; i <= stereo; i++) {
493 float *coeffs = b->channel[i].coeffs;
494 for (int j = 0; j < b->q_unit_cnt; j++) {
495 const int start = at9_q_unit_to_coeff_idx[j + 0];
496 const int end = at9_q_unit_to_coeff_idx[j + 1];
497 const int scalefactor = b->channel[i].scalefactors[j];
498 const float scale = at9_scalefactor_c[scalefactor];
499 for (int k = start; k < end; k++)
505 static inline void fill_with_noise(ATRAC9Context *s, ATRAC9ChannelData *c,
506 int start, int count)
509 for (int i = 0; i < count; i += 2) {
511 av_bmg_get(&s->lfg, tmp);
512 c->coeffs[start + i + 0] = tmp[0];
513 c->coeffs[start + i + 1] = tmp[1];
514 maxval = FFMAX(FFMAX(FFABS(tmp[0]), FFABS(tmp[1])), maxval);
517 for (int i = 0; i < count; i++)
518 c->coeffs[start + i] /= maxval;
521 static inline void scale_band_ext_coeffs(ATRAC9ChannelData *c, float sf[6],
522 const int s_unit, const int e_unit)
524 for (int i = s_unit; i < e_unit; i++) {
525 const int start = at9_q_unit_to_coeff_idx[i + 0];
526 const int end = at9_q_unit_to_coeff_idx[i + 1];
527 for (int j = start; j < end; j++)
528 c->coeffs[j] *= sf[i - s_unit];
532 static inline void apply_band_extension(ATRAC9Context *s, ATRAC9BlockData *b,
535 const int g_units[4] = { /* A, B, C, total units */
537 at9_tab_band_ext_group[b->q_unit_cnt - 13][0],
538 at9_tab_band_ext_group[b->q_unit_cnt - 13][1],
539 FFMAX(g_units[2], 22),
542 const int g_bins[4] = { /* A, B, C, total bins */
543 at9_q_unit_to_coeff_idx[g_units[0]],
544 at9_q_unit_to_coeff_idx[g_units[1]],
545 at9_q_unit_to_coeff_idx[g_units[2]],
546 at9_q_unit_to_coeff_idx[g_units[3]],
549 for (int ch = 0; ch <= stereo; ch++) {
550 ATRAC9ChannelData *c = &b->channel[ch];
552 /* Mirror the spectrum */
553 for (int i = 0; i < 3; i++)
554 for (int j = 0; j < (g_bins[i + 1] - g_bins[i + 0]); j++)
555 c->coeffs[g_bins[i] + j] = c->coeffs[g_bins[i] - j - 1];
557 switch (c->band_ext) {
559 float sf[6] = { 0.0f };
560 const int l = g_units[3] - g_units[0] - 1;
561 const int n_start = at9_q_unit_to_coeff_idx[g_units[3] - 1];
562 const int n_cnt = at9_q_unit_to_coeff_cnt[g_units[3] - 1];
563 switch (at9_tab_band_ext_group[b->q_unit_cnt - 13][2]) {
565 sf[0] = at9_band_ext_scales_m0[0][0][c->band_ext_data[0]];
566 sf[1] = at9_band_ext_scales_m0[0][1][c->band_ext_data[0]];
567 sf[2] = at9_band_ext_scales_m0[0][2][c->band_ext_data[1]];
568 sf[3] = at9_band_ext_scales_m0[0][3][c->band_ext_data[2]];
569 sf[4] = at9_band_ext_scales_m0[0][4][c->band_ext_data[3]];
572 sf[0] = at9_band_ext_scales_m0[1][0][c->band_ext_data[0]];
573 sf[1] = at9_band_ext_scales_m0[1][1][c->band_ext_data[0]];
574 sf[2] = at9_band_ext_scales_m0[1][2][c->band_ext_data[1]];
575 sf[3] = at9_band_ext_scales_m0[1][3][c->band_ext_data[2]];
576 sf[4] = at9_band_ext_scales_m0[1][4][c->band_ext_data[3]];
579 sf[0] = at9_band_ext_scales_m0[2][0][c->band_ext_data[0]];
580 sf[1] = at9_band_ext_scales_m0[2][1][c->band_ext_data[1]];
581 sf[2] = at9_band_ext_scales_m0[2][2][c->band_ext_data[1]];
585 sf[l] = at9_scalefactor_c[c->scalefactors[g_units[0]]];
587 fill_with_noise(s, c, n_start, n_cnt);
588 scale_band_ext_coeffs(c, sf, g_units[0], g_units[3]);
593 for (int i = g_units[0]; i < g_units[3]; i++)
594 sf[i - g_units[0]] = at9_scalefactor_c[c->scalefactors[i]];
596 fill_with_noise(s, c, g_bins[0], g_bins[3] - g_bins[0]);
597 scale_band_ext_coeffs(c, sf, g_units[0], g_units[3]);
601 const float g_sf[2] = {
602 at9_band_ext_scales_m2[c->band_ext_data[0]],
603 at9_band_ext_scales_m2[c->band_ext_data[1]],
606 for (int i = 0; i < 2; i++)
607 for (int j = g_bins[i + 0]; j < g_bins[i + 1]; j++)
608 c->coeffs[j] *= g_sf[i];
612 float scale = at9_band_ext_scales_m3[c->band_ext_data[0]][0];
613 float rate = at9_band_ext_scales_m3[c->band_ext_data[1]][1];
615 for (int i = g_bins[0]; i < g_bins[3]; i++) {
617 c->coeffs[i] *= scale;
622 const float m = at9_band_ext_scales_m4[c->band_ext_data[0]];
623 const float g_sf[3] = { 0.7079468f*m, 0.5011902f*m, 0.3548279f*m };
625 for (int i = 0; i < 3; i++)
626 for (int j = g_bins[i + 0]; j < g_bins[i + 1]; j++)
627 c->coeffs[j] *= g_sf[i];
634 static int atrac9_decode_block(ATRAC9Context *s, GetBitContext *gb,
635 ATRAC9BlockData *b, AVFrame *frame,
636 int frame_idx, int block_idx)
638 const int first_in_pkt = !get_bits1(gb);
639 const int reuse_params = get_bits1(gb);
640 const int stereo = s->block_config->type[block_idx] == ATRAC9_BLOCK_TYPE_CPE;
642 if (s->block_config->type[block_idx] == ATRAC9_BLOCK_TYPE_LFE) {
643 ATRAC9ChannelData *c = &b->channel[0];
644 const int precision = reuse_params ? 8 : 4;
645 c->q_unit_cnt = b->q_unit_cnt = 2;
647 memset(c->scalefactors, 0, sizeof(c->scalefactors));
648 memset(c->q_coeffs_fine, 0, sizeof(c->q_coeffs_fine));
649 memset(c->q_coeffs_coarse, 0, sizeof(c->q_coeffs_coarse));
651 for (int i = 0; i < b->q_unit_cnt; i++) {
652 c->scalefactors[i] = get_bits(gb, 5);
653 c->precision_coarse[i] = precision;
654 c->precision_fine[i] = 0;
657 for (int i = 0; i < c->q_unit_cnt; i++) {
658 const int start = at9_q_unit_to_coeff_idx[i + 0];
659 const int end = at9_q_unit_to_coeff_idx[i + 1];
660 for (int j = start; j < end; j++)
661 c->q_coeffs_coarse[j] = get_bits(gb, c->precision_coarse[i] + 1);
664 dequantize (s, b, c);
665 apply_scalefactors(s, b, 0);
670 if (first_in_pkt && reuse_params) {
671 av_log(s->avctx, AV_LOG_ERROR, "Invalid block flags!\n");
672 return AVERROR_INVALIDDATA;
675 /* Band parameters */
677 int stereo_band, ext_band;
678 const int min_band_count = s->samplerate_idx > 7 ? 1 : 3;
680 b->band_count = get_bits(gb, 4) + min_band_count;
681 b->q_unit_cnt = at9_tab_band_q_unit_map[b->band_count];
683 b->band_ext_q_unit = b->stereo_q_unit = b->q_unit_cnt;
685 if (b->band_count > at9_tab_sri_max_bands[s->samplerate_idx]) {
686 av_log(s->avctx, AV_LOG_ERROR, "Invalid band count %i!\n",
688 return AVERROR_INVALIDDATA;
692 stereo_band = get_bits(gb, 4) + min_band_count;
693 if (stereo_band > b->band_count) {
694 av_log(s->avctx, AV_LOG_ERROR, "Invalid stereo band %i!\n",
696 return AVERROR_INVALIDDATA;
698 b->stereo_q_unit = at9_tab_band_q_unit_map[stereo_band];
701 b->has_band_ext = get_bits1(gb);
702 if (b->has_band_ext) {
703 ext_band = get_bits(gb, 4) + min_band_count;
704 if (ext_band < b->band_count) {
705 av_log(s->avctx, AV_LOG_ERROR, "Invalid extension band %i!\n",
707 return AVERROR_INVALIDDATA;
709 b->band_ext_q_unit = at9_tab_band_q_unit_map[ext_band];
714 av_log(s->avctx, AV_LOG_ERROR, "invalid block reused!\n");
715 return AVERROR_INVALIDDATA;
718 /* Calculate bit alloc gradient */
719 if (parse_gradient(s, b, gb))
720 return AVERROR_INVALIDDATA;
723 b->cpe_base_channel = 0;
725 b->cpe_base_channel = get_bits1(gb);
727 for (int i = b->stereo_q_unit; i < b->q_unit_cnt; i++)
728 b->is_signs[i] = 1 - 2*get_bits1(gb);
730 for (int i = 0; i < FF_ARRAY_ELEMS(b->is_signs); i++)
736 if (parse_band_ext(s, b, gb, stereo))
737 return AVERROR_INVALIDDATA;
740 for (int i = 0; i <= stereo; i++) {
741 ATRAC9ChannelData *c = &b->channel[i];
742 c->q_unit_cnt = i == b->cpe_base_channel ? b->q_unit_cnt :
744 if (read_scalefactors(s, b, c, gb, i, first_in_pkt))
745 return AVERROR_INVALIDDATA;
747 calc_precision (s, b, c);
748 calc_codebook_idx (s, b, c);
749 read_coeffs_coarse(s, b, c, gb);
750 read_coeffs_fine (s, b, c, gb);
751 dequantize (s, b, c);
754 b->q_unit_cnt_prev = b->has_band_ext ? b->band_ext_q_unit : b->q_unit_cnt;
756 apply_intensity_stereo(s, b, stereo);
757 apply_scalefactors (s, b, stereo);
759 if (b->has_band_ext && b->has_band_ext_data)
760 apply_band_extension (s, b, stereo);
763 for (int i = 0; i <= stereo; i++) {
764 ATRAC9ChannelData *c = &b->channel[i];
765 const int dst_idx = s->block_config->plane_map[block_idx][i];
766 const int wsize = 1 << s->frame_log2;
767 const ptrdiff_t offset = wsize*frame_idx*sizeof(float);
768 float *dst = (float *)(frame->extended_data[dst_idx] + offset);
770 s->imdct.imdct_half(&s->imdct, s->temp, c->coeffs);
771 s->fdsp->vector_fmul_window(dst, c->prev_win, s->temp,
772 s->imdct_win, wsize >> 1);
773 memcpy(c->prev_win, s->temp + (wsize >> 1), sizeof(float)*wsize >> 1);
779 static int atrac9_decode_frame(AVCodecContext *avctx, void *data,
780 int *got_frame_ptr, AVPacket *avpkt)
784 AVFrame *frame = data;
785 ATRAC9Context *s = avctx->priv_data;
786 const int frames = FFMIN(avpkt->size / s->avg_frame_size, s->frame_count);
788 frame->nb_samples = (1 << s->frame_log2) * frames;
789 ret = ff_get_buffer(avctx, frame, 0);
793 init_get_bits8(&gb, avpkt->data, avpkt->size);
795 for (int i = 0; i < frames; i++) {
796 for (int j = 0; j < s->block_config->count; j++) {
797 ret = atrac9_decode_block(s, &gb, &s->block[j], frame, i, j);
806 return avctx->block_align;
809 static void atrac9_decode_flush(AVCodecContext *avctx)
811 ATRAC9Context *s = avctx->priv_data;
813 for (int j = 0; j < s->block_config->count; j++) {
814 ATRAC9BlockData *b = &s->block[j];
815 const int stereo = s->block_config->type[j] == ATRAC9_BLOCK_TYPE_CPE;
816 for (int i = 0; i <= stereo; i++) {
817 ATRAC9ChannelData *c = &b->channel[i];
818 memset(c->prev_win, 0, sizeof(c->prev_win));
823 static av_cold int atrac9_decode_close(AVCodecContext *avctx)
825 ATRAC9Context *s = avctx->priv_data;
827 for (int i = 1; i < 7; i++)
828 ff_free_vlc(&s->sf_vlc[0][i]);
829 for (int i = 2; i < 6; i++)
830 ff_free_vlc(&s->sf_vlc[1][i]);
831 for (int i = 0; i < 2; i++)
832 for (int j = 0; j < 8; j++)
833 for (int k = 0; k < 4; k++)
834 ff_free_vlc(&s->coeff_vlc[i][j][k]);
836 ff_mdct_end(&s->imdct);
842 static av_cold int atrac9_decode_init(AVCodecContext *avctx)
845 ATRAC9Context *s = avctx->priv_data;
846 int version, block_config_idx, superframe_idx, alloc_c_len;
850 av_lfg_init(&s->lfg, 0xFBADF00D);
852 if (avctx->block_align <= 0) {
853 av_log(avctx, AV_LOG_ERROR, "Invalid block align\n");
854 return AVERROR_INVALIDDATA;
857 if (avctx->extradata_size != 12) {
858 av_log(avctx, AV_LOG_ERROR, "Invalid extradata length!\n");
859 return AVERROR_INVALIDDATA;
862 version = AV_RL32(avctx->extradata);
864 av_log(avctx, AV_LOG_ERROR, "Unsupported version (%i)!\n", version);
865 return AVERROR_INVALIDDATA;
868 init_get_bits8(&gb, avctx->extradata + 4, avctx->extradata_size);
870 if (get_bits(&gb, 8) != 0xFE) {
871 av_log(avctx, AV_LOG_ERROR, "Incorrect magic byte!\n");
872 return AVERROR_INVALIDDATA;
875 s->samplerate_idx = get_bits(&gb, 4);
876 avctx->sample_rate = at9_tab_samplerates[s->samplerate_idx];
878 block_config_idx = get_bits(&gb, 3);
879 if (block_config_idx > 5) {
880 av_log(avctx, AV_LOG_ERROR, "Incorrect block config!\n");
881 return AVERROR_INVALIDDATA;
883 s->block_config = &at9_block_layout[block_config_idx];
885 avctx->channel_layout = s->block_config->channel_layout;
886 avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
887 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
889 if (get_bits1(&gb)) {
890 av_log(avctx, AV_LOG_ERROR, "Incorrect verification bit!\n");
891 return AVERROR_INVALIDDATA;
894 /* Average frame size in bytes */
895 s->avg_frame_size = get_bits(&gb, 11) + 1;
897 superframe_idx = get_bits(&gb, 2);
898 if (superframe_idx & 1) {
899 av_log(avctx, AV_LOG_ERROR, "Invalid superframe index!\n");
900 return AVERROR_INVALIDDATA;
903 s->frame_count = 1 << superframe_idx;
904 s->frame_log2 = at9_tab_sri_frame_log2[s->samplerate_idx];
906 if (ff_mdct_init(&s->imdct, s->frame_log2 + 1, 1, 1.0f / 32768.0f))
907 return AVERROR(ENOMEM);
909 s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
911 return AVERROR(ENOMEM);
914 for (int i = 0; i < (1 << s->frame_log2); i++) {
915 const int len = 1 << s->frame_log2;
916 const float sidx = ( i + 0.5f) / len;
917 const float eidx = (len - i - 0.5f) / len;
918 const float s_c = sinf(sidx*M_PI - M_PI_2)*0.5f + 0.5f;
919 const float e_c = sinf(eidx*M_PI - M_PI_2)*0.5f + 0.5f;
920 s->imdct_win[i] = s_c / ((s_c * s_c) + (e_c * e_c));
923 /* Allocation curve */
924 alloc_c_len = FF_ARRAY_ELEMS(at9_tab_b_dist);
925 for (int i = 1; i <= alloc_c_len; i++)
926 for (int j = 0; j < i; j++)
927 s->alloc_curve[i - 1][j] = at9_tab_b_dist[(j * alloc_c_len) / i];
929 /* Unsigned scalefactor VLCs */
930 for (int i = 1; i < 7; i++) {
931 const HuffmanCodebook *hf = &at9_huffman_sf_unsigned[i];
933 init_vlc(&s->sf_vlc[0][i], 9, hf->size, hf->bits, 1, 1, hf->codes,
937 /* Signed scalefactor VLCs */
938 for (int i = 2; i < 6; i++) {
939 const HuffmanCodebook *hf = &at9_huffman_sf_signed[i];
943 for (int j = 0; j < nums; j++)
944 sym[j] = sign_extend(j, hf->value_bits);
946 ff_init_vlc_sparse(&s->sf_vlc[1][i], 9, hf->size, hf->bits, 1, 1,
947 hf->codes, 2, 2, sym, sizeof(*sym), sizeof(*sym), 0);
950 /* Coefficient VLCs */
951 for (int i = 0; i < 2; i++) {
952 for (int j = 0; j < 8; j++) {
953 for (int k = 0; k < 4; k++) {
954 const HuffmanCodebook *hf = &at9_huffman_coeffs[i][j][k];
955 init_vlc(&s->coeff_vlc[i][j][k], 9, hf->size, hf->bits, 1, 1,
964 AVCodec ff_atrac9_decoder = {
966 .long_name = NULL_IF_CONFIG_SMALL("ATRAC9 (Adaptive TRansform Acoustic Coding 9)"),
967 .type = AVMEDIA_TYPE_AUDIO,
968 .id = AV_CODEC_ID_ATRAC9,
969 .priv_data_size = sizeof(ATRAC9Context),
970 .init = atrac9_decode_init,
971 .close = atrac9_decode_close,
972 .decode = atrac9_decode_frame,
973 .flush = atrac9_decode_flush,
974 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
975 .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1,