git.sesse.net Git - ffmpeg/blob - libavcodec/atrac9dec.c

   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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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 const 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 };