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