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