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     int reuseable;
  75
  76 } ATRAC9BlockData;
  77
  78 typedef struct ATRAC9Context {
  79     AVCodecContext *avctx;
  80     AVFloatDSPContext *fdsp;
  81     FFTContext imdct;
  82     ATRAC9BlockData block[5];
  83     AVLFG lfg;
  84
  85     /* Set on init */
  86     int frame_log2;
  87     int avg_frame_size;
  88     int frame_count;
  89     int samplerate_idx;
  90     const ATRAC9BlockConfig *block_config;
  91
  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];
  97
  98     DECLARE_ALIGNED(32, float, temp)[256];
  99 } ATRAC9Context;
 100
 101 static inline int parse_gradient(ATRAC9Context *s, ATRAC9BlockData *b,
 102                                  GetBitContext *gb)
 103 {
 104     int grad_range[2];
 105     int grad_value[2];
 106     int values, sign, base;
 107     uint8_t *curve;
 108     float scale;
 109
 110     b->grad_mode = get_bits(gb, 2);
 111     if (b->grad_mode) {
 112         grad_range[0] = get_bits(gb, 5);
 113         grad_range[1] = 31;
 114         grad_value[0] = get_bits(gb, 5);
 115         grad_value[1] = 31;
 116     } else {
 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);
 121     }
 122     b->grad_boundary = get_bits(gb, 4);
 123
 124     if (grad_range[0] >= grad_range[1] || grad_range[1] > 31)
 125         return AVERROR_INVALIDDATA;
 126
 127     if (b->grad_boundary > b->q_unit_cnt)
 128         return AVERROR_INVALIDDATA;
 129
 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];
 135
 136     for (int i = 0; i <= b->q_unit_cnt; i++)
 137         b->gradient[i] = grad_value[i >= grad_range[0]];
 138
 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]]));
 141
 142     return 0;
 143 }
 144
 145 static inline void calc_precision(ATRAC9Context *s, ATRAC9BlockData *b,
 146                                   ATRAC9ChannelData *c)
 147 {
 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;
 151         if (delta > 0) {
 152             const int neg = c->scalefactors[i - 1] > c->scalefactors[i];
 153             c->precision_mask[i - neg] += FFMIN(delta, 5);
 154         }
 155     }
 156
 157     if (b->grad_mode) {
 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)
 162                 continue;
 163             switch (b->grad_mode) {
 164             case 1:
 165                 c->precision_coarse[i] >>= 1;
 166                 break;
 167             case 2:
 168                 c->precision_coarse[i] = (3 * c->precision_coarse[i]) >> 3;
 169                 break;
 170             case 3:
 171                 c->precision_coarse[i] >>= 2;
 172                 break;
 173             }
 174         }
 175     } else {
 176         for (int i = 0; i < b->q_unit_cnt; i++)
 177             c->precision_coarse[i] = c->scalefactors[i] - b->gradient[i];
 178     }
 179
 180
 181     for (int i = 0; i < b->q_unit_cnt; i++)
 182         c->precision_coarse[i] = FFMAX(c->precision_coarse[i], 1);
 183
 184     for (int i = 0; i < b->grad_boundary; i++)
 185         c->precision_coarse[i]++;
 186
 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;
 192         }
 193     }
 194 }
 195
 196 static inline int parse_band_ext(ATRAC9Context *s, ATRAC9BlockData *b,
 197                                  GetBitContext *gb, int stereo)
 198 {
 199     int ext_band = 0;
 200
 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];
 205         if (stereo) {
 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;
 208         } else {
 209             skip_bits1(gb);
 210         }
 211     }
 212
 213     b->has_band_ext_data = get_bits1(gb);
 214     if (!b->has_band_ext_data)
 215         return 0;
 216
 217     if (!b->has_band_ext) {
 218         skip_bits(gb, 2);
 219         skip_bits_long(gb, get_bits(gb, 5));
 220         return 0;
 221     }
 222
 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;
 225
 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);
 233             }
 234         }
 235
 236         return 0;
 237     }
 238
 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);
 245         }
 246     }
 247
 248     return 0;
 249 }
 250
 251 static inline int read_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b,
 252                                     ATRAC9ChannelData *c, GetBitContext *gb,
 253                                     int channel_idx, int first_in_pkt)
 254 {
 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)];
 257
 258     memset(c->scalefactors, 0, sizeof(c->scalefactors));
 259
 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;
 263     }
 264
 265     switch (mode) {
 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];
 271
 272         c->scalefactors[0] = get_bits(gb, len);
 273
 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, 1);
 276             c->scalefactors[i] = val & ((1 << len) - 1);
 277         }
 278
 279         for (int i = 0; i < b->band_ext_q_unit; i++)
 280             c->scalefactors[i] += base - sf_weights[i];
 281
 282         break;
 283     }
 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);
 289         break;
 290     }
 291     case 2:
 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 :
 298                                  b->q_unit_cnt_prev;
 299
 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];
 303
 304         for (int i = 0; i < unit_cnt; i++) {
 305             int dist = get_vlc2(gb, tab->table, 9, 1);
 306             c->scalefactors[i] = baseline[i] + dist;
 307         }
 308
 309         for (int i = unit_cnt; i < b->band_ext_q_unit; i++)
 310             c->scalefactors[i] = get_bits(gb, 5);
 311
 312         break;
 313     }
 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 :
 318                                  b->q_unit_cnt_prev;
 319
 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];
 324
 325         c->scalefactors[0] = get_bits(gb, len);
 326
 327         for (int i = 1; i < unit_cnt; i++) {
 328             int val = c->scalefactors[i - 1] + get_vlc2(gb, tab->table, 9, 1);
 329             c->scalefactors[i] = val & ((1 << len) - 1);
 330         }
 331
 332         for (int i = 0; i < unit_cnt; i++)
 333             c->scalefactors[i] += base + baseline[i];
 334
 335         for (int i = unit_cnt; i < b->band_ext_q_unit; i++)
 336             c->scalefactors[i] = get_bits(gb, 5);
 337         break;
 338     }
 339     }
 340
 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;
 344
 345     memcpy(c->scalefactors_prev, c->scalefactors, sizeof(c->scalefactors));
 346
 347     return 0;
 348 }
 349
 350 static inline void calc_codebook_idx(ATRAC9Context *s, ATRAC9BlockData *b,
 351                                      ATRAC9ChannelData *c)
 352 {
 353     int avg = 0;
 354     const int last_sf = c->scalefactors[c->q_unit_cnt];
 355
 356     memset(c->codebookset, 0, sizeof(c->codebookset));
 357
 358     if (c->q_unit_cnt <= 1)
 359         return;
 360     if (s->samplerate_idx > 7)
 361         return;
 362
 363     c->scalefactors[c->q_unit_cnt] = c->scalefactors[c->q_unit_cnt - 1];
 364
 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;
 369     }
 370
 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;
 378     }
 379
 380
 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])
 386             continue;
 387
 388         c->codebookset[i] = (((cur - min) >= 2) && (cur >= (avg - cnd)));
 389     }
 390
 391     c->scalefactors[c->q_unit_cnt] = last_sf;
 392 }
 393
 394 static inline void read_coeffs_coarse(ATRAC9Context *s, ATRAC9BlockData *b,
 395                                       ATRAC9ChannelData *c, GetBitContext *gb)
 396 {
 397     const int max_prec = s->samplerate_idx > 7 ? 1 : 7;
 398
 399     memset(c->q_coeffs_coarse, 0, sizeof(c->q_coeffs_coarse));
 400
 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;
 405
 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;
 412
 413             for (int j = 0; j < groups; j++) {
 414                 uint16_t val = get_vlc2(gb, tab->table, 9, 2);
 415
 416                 for (int k = 0; k < huff->value_cnt; k++) {
 417                     coeffs[k] = sign_extend(val, huff->value_bits);
 418                     val >>= huff->value_bits;
 419                 }
 420
 421                 coeffs += huff->value_cnt;
 422             }
 423         } else {
 424             for (int j = 0; j < bands; j++)
 425                 coeffs[j] = sign_extend(get_bits(gb, prec), prec);
 426         }
 427     }
 428 }
 429
 430 static inline void read_coeffs_fine(ATRAC9Context *s, ATRAC9BlockData *b,
 431                                     ATRAC9ChannelData *c, GetBitContext *gb)
 432 {
 433     memset(c->q_coeffs_fine, 0, sizeof(c->q_coeffs_fine));
 434
 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;
 439
 440         if (c->precision_fine[i] <= 0)
 441             continue;
 442
 443         for (int j = start; j < end; j++)
 444             c->q_coeffs_fine[j] = sign_extend(get_bits(gb, len), len);
 445     }
 446 }
 447
 448 static inline void dequantize(ATRAC9Context *s, ATRAC9BlockData *b,
 449                               ATRAC9ChannelData *c)
 450 {
 451     memset(c->coeffs, 0, sizeof(c->coeffs));
 452
 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];
 456
 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]];
 459
 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;
 464         }
 465     }
 466 }
 467
 468 static inline void apply_intensity_stereo(ATRAC9Context *s, ATRAC9BlockData *b,
 469                                           const int stereo)
 470 {
 471     float *src = b->channel[ b->cpe_base_channel].coeffs;
 472     float *dst = b->channel[!b->cpe_base_channel].coeffs;
 473
 474     if (!stereo)
 475         return;
 476
 477     if (b->q_unit_cnt <= b->stereo_q_unit)
 478         return;
 479
 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];
 486     }
 487 }
 488
 489 static inline void apply_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b,
 490                                       const int stereo)
 491 {
 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++)
 500                 coeffs[k] *= scale;
 501         }
 502     }
 503 }
 504
 505 static inline void fill_with_noise(ATRAC9Context *s, ATRAC9ChannelData *c,
 506                                    int start, int count)
 507 {
 508     float maxval = 0.0f;
 509     for (int i = 0; i < count; i += 2) {
 510         double tmp[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);
 515     }
 516     /* Normalize */
 517     for (int i = 0; i < count; i++)
 518         c->coeffs[start + i] /= maxval;
 519 }
 520
 521 static inline void scale_band_ext_coeffs(ATRAC9ChannelData *c, float sf[6],
 522                                          const int s_unit, const int e_unit)
 523 {
 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];
 529     }
 530 }
 531
 532 static inline void apply_band_extension(ATRAC9Context *s, ATRAC9BlockData *b,
 533                                        const int stereo)
 534 {
 535     const int g_units[4] = { /* A, B, C, total units */
 536         b->q_unit_cnt,
 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),
 540     };
 541
 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]],
 547     };
 548
 549     for (int ch = 0; ch <= stereo; ch++) {
 550         ATRAC9ChannelData *c = &b->channel[ch];
 551
 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];
 556
 557         switch (c->band_ext) {
 558         case 0: {
 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]) {
 564             case 3:
 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]];
 570                 break;
 571             case 4:
 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]];
 577                 break;
 578             case 5:
 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]];
 582                 break;
 583             }
 584
 585             sf[l] = at9_scalefactor_c[c->scalefactors[g_units[0]]];
 586
 587             fill_with_noise(s, c, n_start, n_cnt);
 588             scale_band_ext_coeffs(c, sf, g_units[0], g_units[3]);
 589             break;
 590         }
 591         case 1: {
 592             float sf[6];
 593             for (int i = g_units[0]; i < g_units[3]; i++)
 594                 sf[i - g_units[0]] = at9_scalefactor_c[c->scalefactors[i]];
 595
 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]);
 598             break;
 599         }
 600         case 2: {
 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]],
 604             };
 605
 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];
 609             break;
 610         }
 611         case 3: {
 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];
 614             rate = pow(2, rate);
 615             for (int i = g_bins[0]; i < g_bins[3]; i++) {
 616                 scale *= rate;
 617                 c->coeffs[i] *= scale;
 618             }
 619             break;
 620         }
 621         case 4: {
 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 };
 624
 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];
 628             break;
 629         }
 630         }
 631     }
 632 }
 633
 634 static int atrac9_decode_block(ATRAC9Context *s, GetBitContext *gb,
 635                                ATRAC9BlockData *b, AVFrame *frame,
 636                                int frame_idx, int block_idx)
 637 {
 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;
 641
 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;
 646
 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));
 650
 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;
 655         }
 656
 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);
 662         }
 663
 664         dequantize        (s, b, c);
 665         apply_scalefactors(s, b, 0);
 666
 667         goto imdct;
 668     }
 669
 670     if (first_in_pkt && reuse_params) {
 671         av_log(s->avctx, AV_LOG_ERROR, "Invalid block flags!\n");
 672         return AVERROR_INVALIDDATA;
 673     }
 674
 675     /* Band parameters */
 676     if (!reuse_params) {
 677         int stereo_band, ext_band;
 678         const int min_band_count = s->samplerate_idx > 7 ? 1 : 3;
 679         b->reuseable = 0;
 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];
 682
 683         b->band_ext_q_unit = b->stereo_q_unit = b->q_unit_cnt;
 684
 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",
 687                    b->band_count);
 688             return AVERROR_INVALIDDATA;
 689         }
 690
 691         if (stereo) {
 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",
 695                        stereo_band);
 696                 return AVERROR_INVALIDDATA;
 697             }
 698             b->stereo_q_unit = at9_tab_band_q_unit_map[stereo_band];
 699         }
 700
 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",
 706                        ext_band);
 707                 return AVERROR_INVALIDDATA;
 708             }
 709             b->band_ext_q_unit = at9_tab_band_q_unit_map[ext_band];
 710         }
 711         b->reuseable = 1;
 712     }
 713     if (!b->reuseable) {
 714         av_log(s->avctx, AV_LOG_ERROR, "invalid block reused!\n");
 715         return AVERROR_INVALIDDATA;
 716     }
 717
 718     /* Calculate bit alloc gradient */
 719     if (parse_gradient(s, b, gb))
 720         return AVERROR_INVALIDDATA;
 721
 722     /* IS data */
 723     b->cpe_base_channel = 0;
 724     if (stereo) {
 725         b->cpe_base_channel = get_bits1(gb);
 726         if (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);
 729         } else {
 730             for (int i = 0; i < FF_ARRAY_ELEMS(b->is_signs); i++)
 731                 b->is_signs[i] = 1;
 732         }
 733     }
 734
 735     /* Band extension */
 736     if (parse_band_ext(s, b, gb, stereo))
 737         return AVERROR_INVALIDDATA;
 738
 739     /* Scalefactors */
 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 :
 743                                                    b->stereo_q_unit;
 744         if (read_scalefactors(s, b, c, gb, i, first_in_pkt))
 745             return AVERROR_INVALIDDATA;
 746
 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);
 752     }
 753
 754     b->q_unit_cnt_prev = b->has_band_ext ? b->band_ext_q_unit : b->q_unit_cnt;
 755
 756     apply_intensity_stereo(s, b, stereo);
 757     apply_scalefactors    (s, b, stereo);
 758
 759     if (b->has_band_ext && b->has_band_ext_data)
 760         apply_band_extension  (s, b, stereo);
 761
 762 imdct:
 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);
 769
 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);
 774     }
 775
 776     return 0;
 777 }
 778
 779 static int atrac9_decode_frame(AVCodecContext *avctx, void *data,
 780                                int *got_frame_ptr, AVPacket *avpkt)
 781 {
 782     int ret;
 783     GetBitContext gb;
 784     AVFrame *frame = data;
 785     ATRAC9Context *s = avctx->priv_data;
 786     const int frames = FFMIN(avpkt->size / s->avg_frame_size, s->frame_count);
 787
 788     frame->nb_samples = (1 << s->frame_log2) * frames;
 789     ret = ff_get_buffer(avctx, frame, 0);
 790     if (ret < 0)
 791         return ret;
 792
 793     init_get_bits8(&gb, avpkt->data, avpkt->size);
 794
 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);
 798             if (ret)
 799                 return ret;
 800             align_get_bits(&gb);
 801         }
 802     }
 803
 804     *got_frame_ptr = 1;
 805
 806     return avctx->block_align;
 807 }
 808
 809 static void atrac9_decode_flush(AVCodecContext *avctx)
 810 {
 811     ATRAC9Context *s = avctx->priv_data;
 812
 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));
 819         }
 820     }
 821 }
 822
 823 static av_cold int atrac9_decode_close(AVCodecContext *avctx)
 824 {
 825     ATRAC9Context *s = avctx->priv_data;
 826
 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]);
 835
 836     ff_mdct_end(&s->imdct);
 837     av_free(s->fdsp);
 838
 839     return 0;
 840 }
 841
 842 static av_cold int atrac9_decode_init(AVCodecContext *avctx)
 843 {
 844     GetBitContext gb;
 845     ATRAC9Context *s = avctx->priv_data;
 846     int version, block_config_idx, superframe_idx, alloc_c_len;
 847
 848     s->avctx = avctx;
 849
 850     av_lfg_init(&s->lfg, 0xFBADF00D);
 851
 852     if (avctx->block_align <= 0) {
 853         av_log(avctx, AV_LOG_ERROR, "Invalid block align\n");
 854         return AVERROR_INVALIDDATA;
 855     }
 856
 857     if (avctx->extradata_size != 12) {
 858         av_log(avctx, AV_LOG_ERROR, "Invalid extradata length!\n");
 859         return AVERROR_INVALIDDATA;
 860     }
 861
 862     version = AV_RL32(avctx->extradata);
 863     if (version > 2) {
 864         av_log(avctx, AV_LOG_ERROR, "Unsupported version (%i)!\n", version);
 865         return AVERROR_INVALIDDATA;
 866     }
 867
 868     init_get_bits8(&gb, avctx->extradata + 4, avctx->extradata_size);
 869
 870     if (get_bits(&gb, 8) != 0xFE) {
 871         av_log(avctx, AV_LOG_ERROR, "Incorrect magic byte!\n");
 872         return AVERROR_INVALIDDATA;
 873     }
 874
 875     s->samplerate_idx = get_bits(&gb, 4);
 876     avctx->sample_rate = at9_tab_samplerates[s->samplerate_idx];
 877
 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;
 882     }
 883     s->block_config = &at9_block_layout[block_config_idx];
 884
 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;
 888
 889     if (get_bits1(&gb)) {
 890         av_log(avctx, AV_LOG_ERROR, "Incorrect verification bit!\n");
 891         return AVERROR_INVALIDDATA;
 892     }
 893
 894     /* Average frame size in bytes */
 895     s->avg_frame_size = get_bits(&gb, 11) + 1;
 896
 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;
 901     }
 902
 903     s->frame_count = 1 << superframe_idx;
 904     s->frame_log2  = at9_tab_sri_frame_log2[s->samplerate_idx];
 905
 906     if (ff_mdct_init(&s->imdct, s->frame_log2 + 1, 1, 1.0f / 32768.0f))
 907         return AVERROR(ENOMEM);
 908
 909     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
 910     if (!s->fdsp)
 911         return AVERROR(ENOMEM);
 912
 913     /* iMDCT window */
 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));
 921     }
 922
 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];
 928
 929     /* Unsigned scalefactor VLCs */
 930     for (int i = 1; i < 7; i++) {
 931         const HuffmanCodebook *hf = &at9_huffman_sf_unsigned[i];
 932
 933         init_vlc(&s->sf_vlc[0][i], 9, hf->size, hf->bits, 1, 1, hf->codes,
 934                  2, 2, 0);
 935     }
 936
 937     /* Signed scalefactor VLCs */
 938     for (int i = 2; i < 6; i++) {
 939         const HuffmanCodebook *hf = &at9_huffman_sf_signed[i];
 940
 941         int nums = hf->size;
 942         int16_t sym[32];
 943         for (int j = 0; j < nums; j++)
 944             sym[j] = sign_extend(j, hf->value_bits);
 945
 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);
 948     }
 949
 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,
 956                          hf->codes, 2, 2, 0);
 957             }
 958         }
 959     }
 960
 961     return 0;
 962 }
 963
 964 AVCodec ff_atrac9_decoder = {
 965     .name           = "atrac9",
 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,
 976 };