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

   1 /*
   2  * QDMC compatible decoder
   3  * Copyright (c) 2017 Paul B Mahol
   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 <math.h>
  23 #include <stddef.h>
  24 #include <stdio.h>
  25
  26 #define BITSTREAM_READER_LE
  27
  28 #include "libavutil/channel_layout.h"
  29 #include "libavutil/thread.h"
  30
  31 #include "avcodec.h"
  32 #include "bytestream.h"
  33 #include "get_bits.h"
  34 #include "internal.h"
  35 #include "fft.h"
  36
  37 typedef struct QDMCTone {
  38     uint8_t mode;
  39     uint8_t phase;
  40     uint8_t offset;
  41     int16_t freq;
  42     int16_t amplitude;
  43 } QDMCTone;
  44
  45 typedef struct QDMCContext {
  46     AVCodecContext *avctx;
  47
  48     uint8_t frame_bits;
  49     int band_index;
  50     int frame_size;
  51     int subframe_size;
  52     int fft_offset;
  53     int buffer_offset;
  54     int nb_channels;
  55     int checksum_size;
  56
  57     uint8_t noise[2][19][17];
  58     QDMCTone tones[5][8192];
  59     int nb_tones[5];
  60     int cur_tone[5];
  61     float alt_sin[5][31];
  62     float fft_buffer[4][8192 * 2];
  63     float noise2_buffer[4096 * 2];
  64     float noise_buffer[4096 * 2];
  65     float buffer[2 * 32768];
  66     float *buffer_ptr;
  67     int rndval;
  68
  69     DECLARE_ALIGNED(32, FFTComplex, cmplx)[2][512];
  70     FFTContext fft_ctx;
  71 } QDMCContext;
  72
  73 static float sin_table[512];
  74 static VLC vtable[6];
  75
  76 static const unsigned code_prefix[] = {
  77     0x0, 0x1, 0x2, 0x3, 0x4, 0x6, 0x8, 0xA,
  78     0xC, 0x10, 0x14, 0x18, 0x1C, 0x24, 0x2C, 0x34,
  79     0x3C, 0x4C, 0x5C, 0x6C, 0x7C, 0x9C, 0xBC, 0xDC,
  80     0xFC, 0x13C, 0x17C, 0x1BC, 0x1FC, 0x27C, 0x2FC, 0x37C,
  81     0x3FC, 0x4FC, 0x5FC, 0x6FC, 0x7FC, 0x9FC, 0xBFC, 0xDFC,
  82     0xFFC, 0x13FC, 0x17FC, 0x1BFC, 0x1FFC, 0x27FC, 0x2FFC, 0x37FC,
  83     0x3FFC, 0x4FFC, 0x5FFC, 0x6FFC, 0x7FFC, 0x9FFC, 0xBFFC, 0xDFFC,
  84     0xFFFC, 0x13FFC, 0x17FFC, 0x1BFFC, 0x1FFFC, 0x27FFC, 0x2FFFC, 0x37FFC,
  85     0x3FFFC
  86 };
  87
  88 static const float amplitude_tab[64] = {
  89     1.18750000f, 1.68359380f, 2.37500000f, 3.36718750f, 4.75000000f,
  90     6.73437500f, 9.50000000f, 13.4687500f, 19.0000000f, 26.9375000f,
  91     38.0000000f, 53.8750000f, 76.0000000f, 107.750000f, 152.000000f,
  92     215.500000f, 304.000000f, 431.000000f, 608.000000f, 862.000000f,
  93     1216.00000f, 1724.00000f, 2432.00000f, 3448.00000f, 4864.00000f,
  94     6896.00000f, 9728.00000f, 13792.0000f, 19456.0000f, 27584.0000f,
  95     38912.0000f, 55168.0000f, 77824.0000f, 110336.000f, 155648.000f,
  96     220672.000f, 311296.000f, 441344.000f, 622592.000f, 882688.000f,
  97     1245184.00f, 1765376.00f, 2490368.00f, 3530752.00f, 4980736.00f,
  98     7061504.00f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  99 };
 100
 101 static const uint16_t qdmc_nodes[112] = {
 102     0, 1, 2, 4, 6, 8, 12, 16, 24, 32, 48, 56, 64,
 103     80, 96, 120, 144, 176, 208, 240, 256,
 104     0, 2, 4, 8, 16, 24, 32, 48, 56, 64, 80, 104,
 105     128, 160, 208, 256, 0, 0, 0, 0, 0,
 106     0, 2, 4, 8, 16, 32, 48, 64, 80, 112, 160, 208,
 107     256, 0, 0, 0, 0, 0, 0, 0, 0,
 108     0, 4, 8, 16, 32, 48, 64, 96, 144, 208, 256,
 109     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 110     0, 4, 16, 32, 64, 256, 0, 0, 0, 0, 0, 0, 0, 0,
 111     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 112 };
 113
 114 static const uint8_t noise_bands_size[] = {
 115     19, 14, 11, 9, 4, 2, 0
 116 };
 117
 118 static const uint8_t noise_bands_selector[] = {
 119     4, 3, 2, 1, 0, 0, 0,
 120 };
 121
 122 static const uint8_t noise_value[][2] = {
 123     {  1,  2 }, { 10,  7 }, { 26,  9 }, { 22,  9 }, { 24,  9 }, { 14,  9 },
 124     {  8,  6 }, {  6,  5 }, {  7,  5 }, {  9,  7 }, { 30,  9 }, { 32, 10 },
 125     { 13, 10 }, { 20,  9 }, { 28,  9 }, { 12,  7 }, { 15, 11 }, { 36, 12 },
 126     {  0, 12 }, { 34, 10 }, { 18,  9 }, { 11,  9 }, { 16,  9 }, {  5,  3 },
 127     {  2,  3 }, {  4,  3 }, {  3,  2 },
 128 };
 129
 130 static const uint8_t noise_segment_length[][2] = {
 131     {  1,  1 }, {  2,  2 }, {  3,  4 }, {  8,  9 }, {  9, 10 }, {  0, 10 },
 132     { 13,  8 }, {  7,  7 }, {  6,  6 }, { 17,  5 }, {  4,  4 }, {  5,  4 },
 133 };
 134
 135 static const uint8_t amplitude[][2] = {
 136     { 18,  3 }, { 16,  3 }, { 22,  7 }, {  8, 10 }, {  4, 10 }, {  3,  9 },
 137     {  2,  8 }, { 23,  8 }, { 10,  8 }, { 11,  7 }, { 21,  5 }, { 20,  4 },
 138     {  1,  7 }, {  7, 10 }, {  5, 10 }, {  9,  9 }, {  6, 10 }, { 25, 11 },
 139     { 26, 12 }, { 27, 13 }, {  0, 13 }, { 24,  9 }, { 12,  6 }, { 13,  5 },
 140     { 14,  4 }, { 19,  3 }, { 15,  3 }, { 17,  2 },
 141 };
 142
 143 static const uint8_t freq_diff[][2] = {
 144     {  2,  4 }, { 14,  6 }, { 26,  7 }, { 31,  8 }, { 32,  9 }, { 35,  9 },
 145     {  7,  5 }, { 10,  5 }, { 22,  7 }, { 27,  7 }, { 19,  7 }, { 20,  7 },
 146     {  4,  5 }, { 13,  5 }, { 17,  6 }, { 15,  6 }, {  8,  5 }, {  5,  4 },
 147     { 28,  7 }, { 33,  9 }, { 36, 11 }, { 38, 12 }, { 42, 14 }, { 45, 16 },
 148     { 44, 18 }, {  0, 18 }, { 46, 17 }, { 43, 15 }, { 40, 13 }, { 37, 11 },
 149     { 39, 12 }, { 41, 12 }, { 34,  8 }, { 16,  6 }, { 11,  5 }, {  9,  4 },
 150     {  1,  2 }, {  3,  4 }, { 30,  7 }, { 29,  7 }, { 23,  6 }, { 24,  6 },
 151     { 18,  6 }, {  6,  4 }, { 12,  5 }, { 21,  6 }, { 25,  6 },
 152 };
 153
 154 static const uint8_t amplitude_diff_bits[] = {
 155     8, 2, 1, 3, 4, 5, 6, 7, 8,
 156 };
 157
 158 static const uint8_t amplitude_diff_codes[] = {
 159     0xFE, 0x0, 0x1, 0x2, 0x6, 0xE, 0x1E, 0x3E, 0x7E,
 160 };
 161
 162 static const uint8_t phase_diff_bits[] = {
 163     6, 2, 2, 4, 4, 6, 5, 4, 2,
 164 };
 165
 166 static const uint8_t phase_diff_codes[] = {
 167     0x35, 0x2, 0x0, 0x1, 0xD, 0x15, 0x5, 0x9, 0x3,
 168 };
 169
 170 #define INIT_VLC_STATIC_LE(vlc, nb_bits, nb_codes,                 \
 171                            bits, bits_wrap, bits_size,             \
 172                            codes, codes_wrap, codes_size,          \
 173                            symbols, symbols_wrap, symbols_size,    \
 174                            static_size)                            \
 175     do {                                                           \
 176         static VLC_TYPE table[static_size][2];                     \
 177         (vlc)->table           = table;                            \
 178         (vlc)->table_allocated = static_size;                      \
 179         ff_init_vlc_sparse(vlc, nb_bits, nb_codes,                 \
 180                            bits, bits_wrap, bits_size,             \
 181                            codes, codes_wrap, codes_size,          \
 182                            symbols, symbols_wrap, symbols_size,    \
 183                            INIT_VLC_LE | INIT_VLC_USE_NEW_STATIC); \
 184     } while (0)
 185
 186 static av_cold void qdmc_init_static_data(void)
 187 {
 188     int i;
 189
 190     INIT_VLC_STATIC_FROM_LENGTHS(&vtable[0], 12, FF_ARRAY_ELEMS(noise_value),
 191                                  &noise_value[0][1], 2,
 192                                  &noise_value[0][0], 2, 1, 0, INIT_VLC_LE, 4096);
 193     INIT_VLC_STATIC_FROM_LENGTHS(&vtable[1], 10, FF_ARRAY_ELEMS(noise_segment_length),
 194                                  &noise_segment_length[0][1], 2,
 195                                  &noise_segment_length[0][0], 2, 1, 0, INIT_VLC_LE, 1024);
 196     INIT_VLC_STATIC_FROM_LENGTHS(&vtable[2], 12, FF_ARRAY_ELEMS(amplitude),
 197                                  &amplitude[0][1], 2,
 198                                  &amplitude[0][0], 2, 1, 0, INIT_VLC_LE, 4098);
 199     INIT_VLC_STATIC_FROM_LENGTHS(&vtable[3], 12, FF_ARRAY_ELEMS(freq_diff),
 200                                  &freq_diff[0][1], 2,
 201                                  &freq_diff[0][0], 2, 1, 0, INIT_VLC_LE, 4160);
 202     INIT_VLC_STATIC_LE(&vtable[4], 8, FF_ARRAY_ELEMS(amplitude_diff_bits),
 203                        amplitude_diff_bits, 1, 1, amplitude_diff_codes, 1, 1, NULL, 0, 0, 256);
 204     INIT_VLC_STATIC_LE(&vtable[5], 6, FF_ARRAY_ELEMS(phase_diff_bits),
 205                        phase_diff_bits, 1, 1, phase_diff_codes, 1, 1, NULL, 0, 0, 64);
 206
 207     for (i = 0; i < 512; i++)
 208         sin_table[i] = sin(2.0f * i * M_PI * 0.001953125f);
 209 }
 210
 211 static void make_noises(QDMCContext *s)
 212 {
 213     int i, j, n0, n1, n2, diff;
 214     float *nptr;
 215
 216     for (j = 0; j < noise_bands_size[s->band_index]; j++) {
 217         n0 = qdmc_nodes[j + 21 * s->band_index    ];
 218         n1 = qdmc_nodes[j + 21 * s->band_index + 1];
 219         n2 = qdmc_nodes[j + 21 * s->band_index + 2];
 220         nptr = s->noise_buffer + 256 * j;
 221
 222         for (i = 0; i + n0 < n1; i++, nptr++)
 223             nptr[0] = i / (float)(n1 - n0);
 224
 225         diff = n2 - n1;
 226         nptr = s->noise_buffer + (j << 8) + n1 - n0;
 227
 228         for (i = n1; i < n2; i++, nptr++, diff--)
 229             nptr[0] = diff / (float)(n2 - n1);
 230     }
 231 }
 232
 233 static av_cold int qdmc_decode_init(AVCodecContext *avctx)
 234 {
 235     static AVOnce init_static_once = AV_ONCE_INIT;
 236     QDMCContext *s = avctx->priv_data;
 237     int ret, fft_size, fft_order, size, g, j, x;
 238     GetByteContext b;
 239
 240     ff_thread_once(&init_static_once, qdmc_init_static_data);
 241
 242     if (!avctx->extradata || (avctx->extradata_size < 48)) {
 243         av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n");
 244         return AVERROR_INVALIDDATA;
 245     }
 246
 247     bytestream2_init(&b, avctx->extradata, avctx->extradata_size);
 248
 249     while (bytestream2_get_bytes_left(&b) > 8) {
 250         if (bytestream2_peek_be64(&b) == (((uint64_t)MKBETAG('f','r','m','a') << 32) |
 251                                            (uint64_t)MKBETAG('Q','D','M','C')))
 252             break;
 253         bytestream2_skipu(&b, 1);
 254     }
 255     bytestream2_skipu(&b, 8);
 256
 257     if (bytestream2_get_bytes_left(&b) < 36) {
 258         av_log(avctx, AV_LOG_ERROR, "not enough extradata (%i)\n",
 259                bytestream2_get_bytes_left(&b));
 260         return AVERROR_INVALIDDATA;
 261     }
 262
 263     size = bytestream2_get_be32u(&b);
 264     if (size > bytestream2_get_bytes_left(&b)) {
 265         av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n",
 266                bytestream2_get_bytes_left(&b), size);
 267         return AVERROR_INVALIDDATA;
 268     }
 269
 270     if (bytestream2_get_be32u(&b) != MKBETAG('Q','D','C','A')) {
 271         av_log(avctx, AV_LOG_ERROR, "invalid extradata, expecting QDCA\n");
 272         return AVERROR_INVALIDDATA;
 273     }
 274     bytestream2_skipu(&b, 4);
 275
 276     avctx->channels = s->nb_channels = bytestream2_get_be32u(&b);
 277     if (s->nb_channels <= 0 || s->nb_channels > 2) {
 278         av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
 279         return AVERROR_INVALIDDATA;
 280     }
 281     avctx->channel_layout = avctx->channels == 2 ? AV_CH_LAYOUT_STEREO :
 282                                                    AV_CH_LAYOUT_MONO;
 283
 284     avctx->sample_rate = bytestream2_get_be32u(&b);
 285     avctx->bit_rate = bytestream2_get_be32u(&b);
 286     bytestream2_skipu(&b, 4);
 287     fft_size = bytestream2_get_be32u(&b);
 288     fft_order = av_log2(fft_size) + 1;
 289     s->checksum_size = bytestream2_get_be32u(&b);
 290     if (s->checksum_size >= 1U << 28) {
 291         av_log(avctx, AV_LOG_ERROR, "data block size too large (%u)\n", s->checksum_size);
 292         return AVERROR_INVALIDDATA;
 293     }
 294
 295     if (avctx->sample_rate >= 32000) {
 296         x = 28000;
 297         s->frame_bits = 13;
 298     } else if (avctx->sample_rate >= 16000) {
 299         x = 20000;
 300         s->frame_bits = 12;
 301     } else {
 302         x = 16000;
 303         s->frame_bits = 11;
 304     }
 305     s->frame_size = 1 << s->frame_bits;
 306     s->subframe_size = s->frame_size >> 5;
 307
 308     if (avctx->channels == 2)
 309         x = 3 * x / 2;
 310     s->band_index = noise_bands_selector[FFMIN(6, llrint(floor(avctx->bit_rate * 3.0 / (double)x + 0.5)))];
 311
 312     if ((fft_order < 7) || (fft_order > 9)) {
 313         avpriv_request_sample(avctx, "Unknown FFT order %d", fft_order);
 314         return AVERROR_PATCHWELCOME;
 315     }
 316
 317     if (fft_size != (1 << (fft_order - 1))) {
 318         av_log(avctx, AV_LOG_ERROR, "FFT size %d not power of 2.\n", fft_size);
 319         return AVERROR_INVALIDDATA;
 320     }
 321
 322     ret = ff_fft_init(&s->fft_ctx, fft_order, 1);
 323     if (ret < 0)
 324         return ret;
 325
 326     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 327
 328     for (g = 5; g > 0; g--) {
 329         for (j = 0; j < (1 << g) - 1; j++)
 330             s->alt_sin[5-g][j] = sin_table[(((j+1) << (8 - g)) & 0x1FF)];
 331     }
 332
 333     make_noises(s);
 334
 335     return 0;
 336 }
 337
 338 static av_cold int qdmc_decode_close(AVCodecContext *avctx)
 339 {
 340     QDMCContext *s = avctx->priv_data;
 341
 342     ff_fft_end(&s->fft_ctx);
 343
 344     return 0;
 345 }
 346
 347 static int qdmc_get_vlc(GetBitContext *gb, VLC *table, int flag)
 348 {
 349     int v;
 350
 351     if (get_bits_left(gb) < 1)
 352         return AVERROR_INVALIDDATA;
 353     v = get_vlc2(gb, table->table, table->bits, 2);
 354     if (v)
 355         v = v - 1;
 356     else
 357         v = get_bits(gb, get_bits(gb, 3) + 1);
 358
 359     if (flag) {
 360         if (v >= FF_ARRAY_ELEMS(code_prefix))
 361             return AVERROR_INVALIDDATA;
 362
 363         v = code_prefix[v] + get_bitsz(gb, v >> 2);
 364     }
 365
 366     return v;
 367 }
 368
 369 static int skip_label(QDMCContext *s, GetBitContext *gb)
 370 {
 371     uint32_t label = get_bits_long(gb, 32);
 372     uint16_t sum = 226, checksum = get_bits(gb, 16);
 373     const uint8_t *ptr = gb->buffer + 6;
 374     int i;
 375
 376     if (label != MKTAG('Q', 'M', 'C', 1))
 377         return AVERROR_INVALIDDATA;
 378
 379     for (i = 0; i < s->checksum_size - 6; i++)
 380         sum += ptr[i];
 381
 382     return sum != checksum;
 383 }
 384
 385 static int read_noise_data(QDMCContext *s, GetBitContext *gb)
 386 {
 387     int ch, j, k, v, idx, band, lastval, newval, len;
 388
 389     for (ch = 0; ch < s->nb_channels; ch++) {
 390         for (band = 0; band < noise_bands_size[s->band_index]; band++) {
 391             v = qdmc_get_vlc(gb, &vtable[0], 0);
 392             if (v < 0)
 393                 return AVERROR_INVALIDDATA;
 394
 395             if (v & 1)
 396                 v = v + 1;
 397             else
 398                 v = -v;
 399
 400             lastval = v / 2;
 401             s->noise[ch][band][0] = lastval - 1;
 402             for (j = 0; j < 15;) {
 403                 len = qdmc_get_vlc(gb, &vtable[1], 1);
 404                 if (len < 0)
 405                     return AVERROR_INVALIDDATA;
 406                 len += 1;
 407
 408                 v = qdmc_get_vlc(gb, &vtable[0], 0);
 409                 if (v < 0)
 410                     return AVERROR_INVALIDDATA;
 411
 412                 if (v & 1)
 413                     newval = lastval + (v + 1) / 2;
 414                 else
 415                     newval = lastval - v / 2;
 416
 417                 idx = j + 1;
 418                 if (len + idx > 16)
 419                     return AVERROR_INVALIDDATA;
 420
 421                 for (k = 1; idx <= j + len; k++, idx++)
 422                     s->noise[ch][band][idx] = lastval + k * (newval - lastval) / len - 1;
 423
 424                 lastval = newval;
 425                 j += len;
 426             }
 427         }
 428     }
 429
 430     return 0;
 431 }
 432
 433 static void add_tone(QDMCContext *s, int group, int offset, int freq, int stereo_mode, int amplitude, int phase)
 434 {
 435     const int index = s->nb_tones[group];
 436
 437     if (index >= FF_ARRAY_ELEMS(s->tones[group])) {
 438         av_log(s->avctx, AV_LOG_WARNING, "Too many tones already in buffer, ignoring tone!\n");
 439         return;
 440     }
 441
 442     s->tones[group][index].offset    = offset;
 443     s->tones[group][index].freq      = freq;
 444     s->tones[group][index].mode      = stereo_mode;
 445     s->tones[group][index].amplitude = amplitude;
 446     s->tones[group][index].phase     = phase;
 447     s->nb_tones[group]++;
 448 }
 449
 450 static int read_wave_data(QDMCContext *s, GetBitContext *gb)
 451 {
 452     int amp, phase, stereo_mode = 0, i, group, freq, group_size, group_bits;
 453     int amp2, phase2, pos2, off;
 454
 455     for (group = 0; group < 5; group++) {
 456         group_size = 1 << (s->frame_bits - group - 1);
 457         group_bits = 4 - group;
 458         pos2 = 0;
 459         off  = 0;
 460
 461         for (i = 1; ; i = freq + 1) {
 462             int v;
 463
 464             v = qdmc_get_vlc(gb, &vtable[3], 1);
 465             if (v < 0)
 466                 return AVERROR_INVALIDDATA;
 467
 468             freq = i + v;
 469             while (freq >= group_size - 1) {
 470                 freq += 2 - group_size;
 471                 pos2 += group_size;
 472                 off  += 1 << group_bits;
 473             }
 474
 475             if (pos2 >= s->frame_size)
 476                 break;
 477
 478             if (s->nb_channels > 1)
 479                 stereo_mode = get_bits(gb, 2);
 480
 481             amp   = qdmc_get_vlc(gb, &vtable[2], 0);
 482             if (amp < 0)
 483                 return AVERROR_INVALIDDATA;
 484             phase = get_bits(gb, 3);
 485
 486             if (stereo_mode > 1) {
 487                 amp2   = qdmc_get_vlc(gb, &vtable[4], 0);
 488                 if (amp2 < 0)
 489                     return AVERROR_INVALIDDATA;
 490                 amp2   = amp - amp2;
 491
 492                 phase2 = qdmc_get_vlc(gb, &vtable[5], 0);
 493                 if (phase2 < 0)
 494                     return AVERROR_INVALIDDATA;
 495                 phase2 = phase - phase2;
 496
 497                 if (phase2 < 0)
 498                     phase2 += 8;
 499             }
 500
 501             if ((freq >> group_bits) + 1 < s->subframe_size) {
 502                 add_tone(s, group, off, freq, stereo_mode & 1, amp, phase);
 503                 if (stereo_mode > 1)
 504                     add_tone(s, group, off, freq, ~stereo_mode & 1, amp2, phase2);
 505             }
 506         }
 507     }
 508
 509     return 0;
 510 }
 511
 512 static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)
 513 {
 514     int subframe_size, i, j, k, length;
 515     float scale, *noise_ptr;
 516
 517     scale = 0.5 * amplitude;
 518     subframe_size = s->subframe_size;
 519     if (subframe_size >= node2)
 520         subframe_size = node2;
 521     length = (subframe_size - node1) & 0xFFFC;
 522     j = node1;
 523     noise_ptr = &s->noise_buffer[256 * index];
 524
 525     for (i = 0; i < length; i += 4, j+= 4, noise_ptr += 4) {
 526         s->noise2_buffer[j    ] += scale * noise_ptr[0];
 527         s->noise2_buffer[j + 1] += scale * noise_ptr[1];
 528         s->noise2_buffer[j + 2] += scale * noise_ptr[2];
 529         s->noise2_buffer[j + 3] += scale * noise_ptr[3];
 530     }
 531
 532     k = length + node1;
 533     noise_ptr = s->noise_buffer + length + (index << 8);
 534     for (i = length; i < subframe_size - node1; i++, k++, noise_ptr++)
 535         s->noise2_buffer[k] += scale * noise_ptr[0];
 536 }
 537
 538 static void add_noise(QDMCContext *s, int ch, int current_subframe)
 539 {
 540     int i, j, aindex;
 541     float amplitude;
 542     float *im = &s->fft_buffer[0 + ch][s->fft_offset + s->subframe_size * current_subframe];
 543     float *re = &s->fft_buffer[2 + ch][s->fft_offset + s->subframe_size * current_subframe];
 544
 545     memset(s->noise2_buffer, 0, 4 * s->subframe_size);
 546
 547     for (i = 0; i < noise_bands_size[s->band_index]; i++) {
 548         if (qdmc_nodes[i + 21 * s->band_index] > s->subframe_size - 1)
 549             break;
 550
 551         aindex = s->noise[ch][i][current_subframe / 2];
 552         amplitude = aindex > 0 ? amplitude_tab[aindex & 0x3F] : 0.0f;
 553
 554         lin_calc(s, amplitude, qdmc_nodes[21 * s->band_index + i],
 555                  qdmc_nodes[21 * s->band_index + i + 2], i);
 556     }
 557
 558     for (j = 2; j < s->subframe_size - 1; j++) {
 559         float rnd_re, rnd_im;
 560
 561         s->rndval = 214013U * s->rndval + 2531011;
 562         rnd_im = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
 563         s->rndval = 214013U * s->rndval + 2531011;
 564         rnd_re = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
 565         im[j  ] += rnd_im;
 566         re[j  ] += rnd_re;
 567         im[j+1] -= rnd_im;
 568         re[j+1] -= rnd_re;
 569     }
 570 }
 571
 572 static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)
 573 {
 574     int j, group_bits, pos, pindex;
 575     float im, re, amplitude, level, *imptr, *reptr;
 576
 577     if (s->nb_channels == 1)
 578         stereo_mode = 0;
 579
 580     group_bits = 4 - group;
 581     pos = freqs >> (4 - group);
 582     amplitude = amplitude_tab[amp & 0x3F];
 583     imptr = &s->fft_buffer[    stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
 584     reptr = &s->fft_buffer[2 + stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
 585     pindex = (phase << 6) - ((2 * (freqs >> (4 - group)) + 1) << 7);
 586     for (j = 0; j < (1 << (group_bits + 1)) - 1; j++) {
 587         pindex += (2 * freqs + 1) << (7 - group_bits);
 588         level = amplitude * s->alt_sin[group][j];
 589         im = level * sin_table[ pindex        & 0x1FF];
 590         re = level * sin_table[(pindex + 128) & 0x1FF];
 591         imptr[0] += im;
 592         imptr[1] -= im;
 593         reptr[0] += re;
 594         reptr[1] -= re;
 595         imptr += s->subframe_size;
 596         reptr += s->subframe_size;
 597         if (imptr >= &s->fft_buffer[stereo_mode][2 * s->frame_size]) {
 598             imptr = &s->fft_buffer[0 + stereo_mode][pos];
 599             reptr = &s->fft_buffer[2 + stereo_mode][pos];
 600         }
 601     }
 602 }
 603
 604 static void add_wave0(QDMCContext *s, int offset, int freqs, int stereo_mode, int amp, int phase)
 605 {
 606     float level, im, re;
 607     int pos;
 608
 609     if (s->nb_channels == 1)
 610         stereo_mode = 0;
 611
 612     level = amplitude_tab[amp & 0x3F];
 613     im = level * sin_table[ (phase << 6)        & 0x1FF];
 614     re = level * sin_table[((phase << 6) + 128) & 0x1FF];
 615     pos = s->fft_offset + freqs + s->subframe_size * offset;
 616     s->fft_buffer[    stereo_mode][pos    ] += im;
 617     s->fft_buffer[2 + stereo_mode][pos    ] += re;
 618     s->fft_buffer[    stereo_mode][pos + 1] -= im;
 619     s->fft_buffer[2 + stereo_mode][pos + 1] -= re;
 620 }
 621
 622 static void add_waves(QDMCContext *s, int current_subframe)
 623 {
 624     int w, g;
 625
 626     for (g = 0; g < 4; g++) {
 627         for (w = s->cur_tone[g]; w < s->nb_tones[g]; w++) {
 628             QDMCTone *t = &s->tones[g][w];
 629
 630             if (current_subframe < t->offset)
 631                 break;
 632             add_wave(s, t->offset, t->freq, g, t->mode, t->amplitude, t->phase);
 633         }
 634         s->cur_tone[g] = w;
 635     }
 636     for (w = s->cur_tone[4]; w < s->nb_tones[4]; w++) {
 637         QDMCTone *t = &s->tones[4][w];
 638
 639         if (current_subframe < t->offset)
 640             break;
 641         add_wave0(s, t->offset, t->freq, t->mode, t->amplitude, t->phase);
 642     }
 643     s->cur_tone[4] = w;
 644 }
 645
 646 static int decode_frame(QDMCContext *s, GetBitContext *gb, int16_t *out)
 647 {
 648     int ret, ch, i, n;
 649
 650     if (skip_label(s, gb))
 651         return AVERROR_INVALIDDATA;
 652
 653     s->fft_offset = s->frame_size - s->fft_offset;
 654     s->buffer_ptr = &s->buffer[s->nb_channels * s->buffer_offset];
 655
 656     ret = read_noise_data(s, gb);
 657     if (ret < 0)
 658         return ret;
 659
 660     ret = read_wave_data(s, gb);
 661     if (ret < 0)
 662         return ret;
 663
 664     for (n = 0; n < 32; n++) {
 665         float *r;
 666
 667         for (ch = 0; ch < s->nb_channels; ch++)
 668             add_noise(s, ch, n);
 669
 670         add_waves(s, n);
 671
 672         for (ch = 0; ch < s->nb_channels; ch++) {
 673             for (i = 0; i < s->subframe_size; i++) {
 674                 s->cmplx[ch][i].re = s->fft_buffer[ch + 2][s->fft_offset + n * s->subframe_size + i];
 675                 s->cmplx[ch][i].im = s->fft_buffer[ch + 0][s->fft_offset + n * s->subframe_size + i];
 676                 s->cmplx[ch][s->subframe_size + i].re = 0;
 677                 s->cmplx[ch][s->subframe_size + i].im = 0;
 678             }
 679         }
 680
 681         for (ch = 0; ch < s->nb_channels; ch++) {
 682             s->fft_ctx.fft_permute(&s->fft_ctx, s->cmplx[ch]);
 683             s->fft_ctx.fft_calc(&s->fft_ctx, s->cmplx[ch]);
 684         }
 685
 686         r = &s->buffer_ptr[s->nb_channels * n * s->subframe_size];
 687         for (i = 0; i < 2 * s->subframe_size; i++) {
 688             for (ch = 0; ch < s->nb_channels; ch++) {
 689                 *r++ += s->cmplx[ch][i].re;
 690             }
 691         }
 692
 693         r = &s->buffer_ptr[n * s->subframe_size * s->nb_channels];
 694         for (i = 0; i < s->nb_channels * s->subframe_size; i++) {
 695             out[i] = av_clipf(r[i], INT16_MIN, INT16_MAX);
 696         }
 697         out += s->subframe_size * s->nb_channels;
 698
 699         for (ch = 0; ch < s->nb_channels; ch++) {
 700             memset(s->fft_buffer[ch+0] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
 701             memset(s->fft_buffer[ch+2] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
 702         }
 703         memset(s->buffer + s->nb_channels * (n * s->subframe_size + s->frame_size + s->buffer_offset), 0, 4 * s->subframe_size * s->nb_channels);
 704     }
 705
 706     s->buffer_offset += s->frame_size;
 707     if (s->buffer_offset >= 32768 - s->frame_size) {
 708         memcpy(s->buffer, &s->buffer[s->nb_channels * s->buffer_offset], 4 * s->frame_size * s->nb_channels);
 709         s->buffer_offset = 0;
 710     }
 711
 712     return 0;
 713 }
 714
 715 static av_cold void qdmc_flush(AVCodecContext *avctx)
 716 {
 717     QDMCContext *s = avctx->priv_data;
 718
 719     memset(s->buffer, 0, sizeof(s->buffer));
 720     memset(s->fft_buffer, 0, sizeof(s->fft_buffer));
 721     s->fft_offset = 0;
 722     s->buffer_offset = 0;
 723 }
 724
 725 static int qdmc_decode_frame(AVCodecContext *avctx, void *data,
 726                              int *got_frame_ptr, AVPacket *avpkt)
 727 {
 728     QDMCContext *s = avctx->priv_data;
 729     AVFrame *frame = data;
 730     GetBitContext gb;
 731     int ret;
 732
 733     if (!avpkt->data)
 734         return 0;
 735     if (avpkt->size < s->checksum_size)
 736         return AVERROR_INVALIDDATA;
 737
 738     s->avctx = avctx;
 739     frame->nb_samples = s->frame_size;
 740     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
 741         return ret;
 742
 743     if ((ret = init_get_bits8(&gb, avpkt->data, s->checksum_size)) < 0)
 744         return ret;
 745
 746     memset(s->nb_tones, 0, sizeof(s->nb_tones));
 747     memset(s->cur_tone, 0, sizeof(s->cur_tone));
 748
 749     ret = decode_frame(s, &gb, (int16_t *)frame->data[0]);
 750     if (ret >= 0) {
 751         *got_frame_ptr = 1;
 752         return s->checksum_size;
 753     }
 754     qdmc_flush(avctx);
 755     return ret;
 756 }
 757
 758 AVCodec ff_qdmc_decoder = {
 759     .name             = "qdmc",
 760     .long_name        = NULL_IF_CONFIG_SMALL("QDesign Music Codec 1"),
 761     .type             = AVMEDIA_TYPE_AUDIO,
 762     .id               = AV_CODEC_ID_QDMC,
 763     .priv_data_size   = sizeof(QDMCContext),
 764     .init             = qdmc_decode_init,
 765     .close            = qdmc_decode_close,
 766     .decode           = qdmc_decode_frame,
 767     .flush            = qdmc_flush,
 768     .capabilities     = AV_CODEC_CAP_DR1,
 769 };