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