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