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], 13, FF_ARRAY_ELEMS(amplitude_bits),
 218                        amplitude_bits, 1, 1, amplitude_codes, 2, 2, NULL, 0, 0, 8192);
 219     INIT_VLC_STATIC_LE(&vtable[3], 18, FF_ARRAY_ELEMS(freq_diff_bits),
 220                        freq_diff_bits, 1, 1, freq_diff_codes, 4, 4, NULL, 0, 0, 262144);
 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     v = get_vlc2(gb, table->table, table->bits, 1);
 371     if (v < 0)
 372         return AVERROR_INVALIDDATA;
 373     if (v)
 374         v = v - 1;
 375     else
 376         v = get_bits(gb, get_bits(gb, 3) + 1);
 377
 378     if (flag) {
 379         if (v >= FF_ARRAY_ELEMS(code_prefix))
 380             return AVERROR_INVALIDDATA;
 381
 382         v = code_prefix[v] + get_bitsz(gb, v >> 2);
 383     }
 384
 385     return v;
 386 }
 387
 388 static int skip_label(QDMCContext *s, GetBitContext *gb)
 389 {
 390     uint32_t label = get_bits_long(gb, 32);
 391     uint16_t sum = 226, checksum = get_bits(gb, 16);
 392     const uint8_t *ptr = gb->buffer + 6;
 393     int i;
 394
 395     if (label != MKTAG('Q', 'M', 'C', 1))
 396         return AVERROR_INVALIDDATA;
 397
 398     for (i = 0; i < s->checksum_size - 6; i++)
 399         sum += ptr[i];
 400
 401     return sum != checksum;
 402 }
 403
 404 static int read_noise_data(QDMCContext *s, GetBitContext *gb)
 405 {
 406     int ch, j, k, v, idx, band, lastval, newval, len;
 407
 408     for (ch = 0; ch < s->nb_channels; ch++) {
 409         for (band = 0; band < noise_bands_size[s->band_index]; band++) {
 410             v = qdmc_get_vlc(gb, &vtable[0], 0);
 411             if (v < 0)
 412                 return AVERROR_INVALIDDATA;
 413
 414             if (v & 1)
 415                 v = v + 1;
 416             else
 417                 v = -v;
 418
 419             lastval = v / 2;
 420             s->noise[ch][band][0] = lastval - 1;
 421             for (j = 0; j < 15;) {
 422                 len = qdmc_get_vlc(gb, &vtable[1], 1);
 423                 if (len < 0)
 424                     return AVERROR_INVALIDDATA;
 425                 len += 1;
 426
 427                 v = qdmc_get_vlc(gb, &vtable[0], 0);
 428                 if (v < 0)
 429                     return AVERROR_INVALIDDATA;
 430
 431                 if (v & 1)
 432                     newval = lastval + (v + 1) / 2;
 433                 else
 434                     newval = lastval - v / 2;
 435
 436                 idx = j + 1;
 437                 if (len + idx > 16)
 438                     return AVERROR_INVALIDDATA;
 439
 440                 for (k = 1; idx <= j + len; k++, idx++)
 441                     s->noise[ch][band][idx] = lastval + k * (newval - lastval) / len - 1;
 442
 443                 lastval = newval;
 444                 j += len;
 445             }
 446         }
 447     }
 448
 449     return 0;
 450 }
 451
 452 static void add_tone(QDMCContext *s, int group, int offset, int freq, int stereo_mode, int amplitude, int phase)
 453 {
 454     const int index = s->nb_tones[group];
 455
 456     if (index >= FF_ARRAY_ELEMS(s->tones[group])) {
 457         av_log(s->avctx, AV_LOG_WARNING, "Too many tones already in buffer, ignoring tone!\n");
 458         return;
 459     }
 460
 461     s->tones[group][index].offset    = offset;
 462     s->tones[group][index].freq      = freq;
 463     s->tones[group][index].mode      = stereo_mode;
 464     s->tones[group][index].amplitude = amplitude;
 465     s->tones[group][index].phase     = phase;
 466     s->nb_tones[group]++;
 467 }
 468
 469 static int read_wave_data(QDMCContext *s, GetBitContext *gb)
 470 {
 471     int amp, phase, stereo_mode = 0, i, group, freq, group_size, group_bits;
 472     int amp2, phase2, pos2, off;
 473
 474     for (group = 0; group < 5; group++) {
 475         group_size = 1 << (s->frame_bits - group - 1);
 476         group_bits = 4 - group;
 477         pos2 = 0;
 478         off  = 0;
 479
 480         for (i = 1; ; i = freq + 1) {
 481             int v;
 482
 483             v = qdmc_get_vlc(gb, &vtable[3], 1);
 484             if (v < 0)
 485                 return AVERROR_INVALIDDATA;
 486
 487             freq = i + v;
 488             while (freq >= group_size - 1) {
 489                 freq += 2 - group_size;
 490                 pos2 += group_size;
 491                 off  += 1 << group_bits;
 492             }
 493
 494             if (pos2 >= s->frame_size)
 495                 break;
 496
 497             if (s->nb_channels > 1)
 498                 stereo_mode = get_bits(gb, 2);
 499
 500             amp   = qdmc_get_vlc(gb, &vtable[2], 0);
 501             if (amp < 0)
 502                 return AVERROR_INVALIDDATA;
 503             phase = get_bits(gb, 3);
 504
 505             if (stereo_mode > 1) {
 506                 amp2   = qdmc_get_vlc(gb, &vtable[4], 0);
 507                 if (amp2 < 0)
 508                     return AVERROR_INVALIDDATA;
 509                 amp2   = amp - amp2;
 510
 511                 phase2 = qdmc_get_vlc(gb, &vtable[5], 0);
 512                 if (phase2 < 0)
 513                     return AVERROR_INVALIDDATA;
 514                 phase2 = phase - phase2;
 515
 516                 if (phase2 < 0)
 517                     phase2 += 8;
 518             }
 519
 520             if ((freq >> group_bits) + 1 < s->subframe_size) {
 521                 add_tone(s, group, off, freq, stereo_mode & 1, amp, phase);
 522                 if (stereo_mode > 1)
 523                     add_tone(s, group, off, freq, ~stereo_mode & 1, amp2, phase2);
 524             }
 525         }
 526     }
 527
 528     return 0;
 529 }
 530
 531 static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)
 532 {
 533     int subframe_size, i, j, k, length;
 534     float scale, *noise_ptr;
 535
 536     scale = 0.5 * amplitude;
 537     subframe_size = s->subframe_size;
 538     if (subframe_size >= node2)
 539         subframe_size = node2;
 540     length = (subframe_size - node1) & 0xFFFC;
 541     j = node1;
 542     noise_ptr = &s->noise_buffer[256 * index];
 543
 544     for (i = 0; i < length; i += 4, j+= 4, noise_ptr += 4) {
 545         s->noise2_buffer[j    ] += scale * noise_ptr[0];
 546         s->noise2_buffer[j + 1] += scale * noise_ptr[1];
 547         s->noise2_buffer[j + 2] += scale * noise_ptr[2];
 548         s->noise2_buffer[j + 3] += scale * noise_ptr[3];
 549     }
 550
 551     k = length + node1;
 552     noise_ptr = s->noise_buffer + length + (index << 8);
 553     for (i = length; i < subframe_size - node1; i++, k++, noise_ptr++)
 554         s->noise2_buffer[k] += scale * noise_ptr[0];
 555 }
 556
 557 static void add_noise(QDMCContext *s, int ch, int current_subframe)
 558 {
 559     int i, j, aindex;
 560     float amplitude;
 561     float *im = &s->fft_buffer[0 + ch][s->fft_offset + s->subframe_size * current_subframe];
 562     float *re = &s->fft_buffer[2 + ch][s->fft_offset + s->subframe_size * current_subframe];
 563
 564     memset(s->noise2_buffer, 0, 4 * s->subframe_size);
 565
 566     for (i = 0; i < noise_bands_size[s->band_index]; i++) {
 567         if (qdmc_nodes[i + 21 * s->band_index] > s->subframe_size - 1)
 568             break;
 569
 570         aindex = s->noise[ch][i][current_subframe / 2];
 571         amplitude = aindex > 0 ? amplitude_tab[aindex & 0x3F] : 0.0f;
 572
 573         lin_calc(s, amplitude, qdmc_nodes[21 * s->band_index + i],
 574                  qdmc_nodes[21 * s->band_index + i + 2], i);
 575     }
 576
 577     for (j = 2; j < s->subframe_size - 1; j++) {
 578         float rnd_re, rnd_im;
 579
 580         s->rndval = 214013 * s->rndval + 2531011;
 581         rnd_im = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
 582         s->rndval = 214013 * s->rndval + 2531011;
 583         rnd_re = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
 584         im[j  ] += rnd_im;
 585         re[j  ] += rnd_re;
 586         im[j+1] -= rnd_im;
 587         re[j+1] -= rnd_re;
 588     }
 589 }
 590
 591 static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)
 592 {
 593     int j, group_bits, pos, pindex;
 594     float im, re, amplitude, level, *imptr, *reptr;
 595
 596     if (s->nb_channels == 1)
 597         stereo_mode = 0;
 598
 599     group_bits = 4 - group;
 600     pos = freqs >> (4 - group);
 601     amplitude = amplitude_tab[amp & 0x3F];
 602     imptr = &s->fft_buffer[    stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
 603     reptr = &s->fft_buffer[2 + stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
 604     pindex = (phase << 6) - ((2 * (freqs >> (4 - group)) + 1) << 7);
 605     for (j = 0; j < (1 << (group_bits + 1)) - 1; j++) {
 606         pindex += (2 * freqs + 1) << (7 - group_bits);
 607         level = amplitude * s->alt_sin[group][j];
 608         im = level * sin_table[ pindex        & 0x1FF];
 609         re = level * sin_table[(pindex + 128) & 0x1FF];
 610         imptr[0] += im;
 611         imptr[1] -= im;
 612         reptr[0] += re;
 613         reptr[1] -= re;
 614         imptr += s->subframe_size;
 615         reptr += s->subframe_size;
 616         if (imptr >= &s->fft_buffer[stereo_mode][2 * s->frame_size]) {
 617             imptr = &s->fft_buffer[0 + stereo_mode][pos];
 618             reptr = &s->fft_buffer[2 + stereo_mode][pos];
 619         }
 620     }
 621 }
 622
 623 static void add_wave0(QDMCContext *s, int offset, int freqs, int stereo_mode, int amp, int phase)
 624 {
 625     float level, im, re;
 626     int pos;
 627
 628     if (s->nb_channels == 1)
 629         stereo_mode = 0;
 630
 631     level = amplitude_tab[amp & 0x3F];
 632     im = level * sin_table[ (phase << 6)        & 0x1FF];
 633     re = level * sin_table[((phase << 6) + 128) & 0x1FF];
 634     pos = s->fft_offset + freqs + s->subframe_size * offset;
 635     s->fft_buffer[    stereo_mode][pos    ] += im;
 636     s->fft_buffer[2 + stereo_mode][pos    ] += re;
 637     s->fft_buffer[    stereo_mode][pos + 1] -= im;
 638     s->fft_buffer[2 + stereo_mode][pos + 1] -= re;
 639 }
 640
 641 static void add_waves(QDMCContext *s, int current_subframe)
 642 {
 643     int w, g;
 644
 645     for (g = 0; g < 4; g++) {
 646         for (w = s->cur_tone[g]; w < s->nb_tones[g]; w++) {
 647             QDMCTone *t = &s->tones[g][w];
 648
 649             if (current_subframe < t->offset)
 650                 break;
 651             add_wave(s, t->offset, t->freq, g, t->mode, t->amplitude, t->phase);
 652         }
 653         s->cur_tone[g] = w;
 654     }
 655     for (w = s->cur_tone[4]; w < s->nb_tones[4]; w++) {
 656         QDMCTone *t = &s->tones[4][w];
 657
 658         if (current_subframe < t->offset)
 659             break;
 660         add_wave0(s, t->offset, t->freq, t->mode, t->amplitude, t->phase);
 661     }
 662     s->cur_tone[4] = w;
 663 }
 664
 665 static int decode_frame(QDMCContext *s, GetBitContext *gb, int16_t *out)
 666 {
 667     int ret, ch, i, n;
 668
 669     if (skip_label(s, gb))
 670         return AVERROR_INVALIDDATA;
 671
 672     s->fft_offset = s->frame_size - s->fft_offset;
 673     s->buffer_ptr = &s->buffer[s->nb_channels * s->buffer_offset];
 674
 675     ret = read_noise_data(s, gb);
 676     if (ret < 0)
 677         return ret;
 678
 679     ret = read_wave_data(s, gb);
 680     if (ret < 0)
 681         return ret;
 682
 683     for (n = 0; n < 32; n++) {
 684         float *r;
 685
 686         for (ch = 0; ch < s->nb_channels; ch++)
 687             add_noise(s, ch, n);
 688
 689         add_waves(s, n);
 690
 691         for (ch = 0; ch < s->nb_channels; ch++) {
 692             for (i = 0; i < s->subframe_size; i++) {
 693                 s->cmplx[ch][i].re = s->fft_buffer[ch + 2][s->fft_offset + n * s->subframe_size + i];
 694                 s->cmplx[ch][i].im = s->fft_buffer[ch + 0][s->fft_offset + n * s->subframe_size + i];
 695                 s->cmplx[ch][s->subframe_size + i].re = 0;
 696                 s->cmplx[ch][s->subframe_size + i].im = 0;
 697             }
 698         }
 699
 700         for (ch = 0; ch < s->nb_channels; ch++) {
 701             s->fft_ctx.fft_permute(&s->fft_ctx, s->cmplx[ch]);
 702             s->fft_ctx.fft_calc(&s->fft_ctx, s->cmplx[ch]);
 703         }
 704
 705         r = &s->buffer_ptr[s->nb_channels * n * s->subframe_size];
 706         for (i = 0; i < 2 * s->subframe_size; i++) {
 707             for (ch = 0; ch < s->nb_channels; ch++) {
 708                 *r++ += s->cmplx[ch][i].re;
 709             }
 710         }
 711
 712         r = &s->buffer_ptr[n * s->subframe_size * s->nb_channels];
 713         for (i = 0; i < s->nb_channels * s->subframe_size; i++) {
 714             out[i] = av_clipf(r[i], INT16_MIN, INT16_MAX);
 715         }
 716         out += s->subframe_size * s->nb_channels;
 717
 718         for (ch = 0; ch < s->nb_channels; ch++) {
 719             memset(s->fft_buffer[ch+0] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
 720             memset(s->fft_buffer[ch+2] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
 721         }
 722         memset(s->buffer + s->nb_channels * (n * s->subframe_size + s->frame_size + s->buffer_offset), 0, 4 * s->subframe_size * s->nb_channels);
 723     }
 724
 725     s->buffer_offset += s->frame_size;
 726     if (s->buffer_offset >= 32768 - s->frame_size) {
 727         memcpy(s->buffer, &s->buffer[s->nb_channels * s->buffer_offset], 4 * s->frame_size * s->nb_channels);
 728         s->buffer_offset = 0;
 729     }
 730
 731     return 0;
 732 }
 733
 734 static av_cold void qdmc_flush(AVCodecContext *avctx)
 735 {
 736     QDMCContext *s = avctx->priv_data;
 737
 738     memset(s->buffer, 0, sizeof(s->buffer));
 739     memset(s->fft_buffer, 0, sizeof(s->fft_buffer));
 740     s->fft_offset = 0;
 741     s->buffer_offset = 0;
 742 }
 743
 744 static int qdmc_decode_frame(AVCodecContext *avctx, void *data,
 745                              int *got_frame_ptr, AVPacket *avpkt)
 746 {
 747     QDMCContext *s = avctx->priv_data;
 748     AVFrame *frame = data;
 749     GetBitContext gb;
 750     int ret;
 751
 752     if (!avpkt->data)
 753         return 0;
 754     if (avpkt->size < s->checksum_size)
 755         return AVERROR_INVALIDDATA;
 756
 757     s->avctx = avctx;
 758     frame->nb_samples = s->frame_size;
 759     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
 760         return ret;
 761
 762     if ((ret = init_get_bits8(&gb, avpkt->data, s->checksum_size)) < 0)
 763         return ret;
 764
 765     memset(s->nb_tones, 0, sizeof(s->nb_tones));
 766     memset(s->cur_tone, 0, sizeof(s->cur_tone));
 767
 768     ret = decode_frame(s, &gb, (int16_t *)frame->data[0]);
 769     if (ret >= 0) {
 770         *got_frame_ptr = 1;
 771         return s->checksum_size;
 772     }
 773     qdmc_flush(avctx);
 774     return ret;
 775 }
 776
 777 AVCodec ff_qdmc_decoder = {
 778     .name             = "qdmc",
 779     .long_name        = NULL_IF_CONFIG_SMALL("QDesign Music Codec 1"),
 780     .type             = AVMEDIA_TYPE_AUDIO,
 781     .id               = AV_CODEC_ID_QDMC,
 782     .priv_data_size   = sizeof(QDMCContext),
 783     .init             = qdmc_decode_init,
 784     .close            = qdmc_decode_close,
 785     .decode           = qdmc_decode_frame,
 786     .flush            = qdmc_flush,
 787     .capabilities     = AV_CODEC_CAP_DR1,
 788 };