falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
100318 Commits
32 Branches
2.4GB
Tree: fb0ae037d0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'fb0ae037d0'
${ noResults }
FFmpeg/libavcodec/qdmc.c

770 lines
25KB
Raw Blame History 

  1. /*

  2.  * QDMC compatible decoder

  3.  * Copyright (c) 2017 Paul B Mahol

  4.  *

  5.  * This file is part of FFmpeg.

  6.  *

  7.  * FFmpeg is free software; you can redistribute it and/or

  8.  * modify it under the terms of the GNU Lesser General Public

  9.  * License as published by the Free Software Foundation; either

  10.  * version 2.1 of the License, or (at your option) any later version.

  11.  *

  12.  * FFmpeg is distributed in the hope that it will be useful,

  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  15.  * Lesser General Public License for more details.

  16.  *

  17.  * You should have received a copy of the GNU Lesser General Public

  18.  * License along with FFmpeg; if not, write to the Free Software

  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  20.  */

  21. 

  22. #include <math.h>

  23. #include <stddef.h>

  24. #include <stdio.h>

  25. 

  26. #define BITSTREAM_READER_LE

  27. 

  28. #include "libavutil/channel_layout.h"

  29. #include "libavutil/thread.h"

  30. 

  31. #include "avcodec.h"

  32. #include "bytestream.h"

  33. #include "get_bits.h"

  34. #include "internal.h"

  35. #include "fft.h"

  36. 

  37. typedef struct QDMCTone {

  38.     uint8_t mode;

  39.     uint8_t phase;

  40.     uint8_t offset;

  41.     int16_t freq;

  42.     int16_t amplitude;

  43. } QDMCTone;

  44. 

  45. typedef struct QDMCContext {

  46.     AVCodecContext *avctx;

  47. 

  48.     uint8_t frame_bits;

  49.     int band_index;

  50.     int frame_size;

  51.     int subframe_size;

  52.     int fft_offset;

  53.     int buffer_offset;

  54.     int nb_channels;

  55.     int checksum_size;

  56. 

  57.     uint8_t noise[2][19][17];

  58.     QDMCTone tones[5][8192];

  59.     int nb_tones[5];

  60.     int cur_tone[5];

  61.     float alt_sin[5][31];

  62.     float fft_buffer[4][8192 * 2];

  63.     float noise2_buffer[4096 * 2];

  64.     float noise_buffer[4096 * 2];

  65.     float buffer[2 * 32768];

  66.     float *buffer_ptr;

  67.     int rndval;

  68. 

  69.     DECLARE_ALIGNED(32, FFTComplex, cmplx)[2][512];

  70.     FFTContext fft_ctx;

  71. } QDMCContext;

  72. 

  73. static float sin_table[512];

  74. static VLC vtable[6];

  75. 

  76. static const unsigned code_prefix[] = {

  77.     0x0, 0x1, 0x2, 0x3, 0x4, 0x6, 0x8, 0xA,

  78.     0xC, 0x10, 0x14, 0x18, 0x1C, 0x24, 0x2C, 0x34,

  79.     0x3C, 0x4C, 0x5C, 0x6C, 0x7C, 0x9C, 0xBC, 0xDC,

  80.     0xFC, 0x13C, 0x17C, 0x1BC, 0x1FC, 0x27C, 0x2FC, 0x37C,

  81.     0x3FC, 0x4FC, 0x5FC, 0x6FC, 0x7FC, 0x9FC, 0xBFC, 0xDFC,

  82.     0xFFC, 0x13FC, 0x17FC, 0x1BFC, 0x1FFC, 0x27FC, 0x2FFC, 0x37FC,

  83.     0x3FFC, 0x4FFC, 0x5FFC, 0x6FFC, 0x7FFC, 0x9FFC, 0xBFFC, 0xDFFC,

  84.     0xFFFC, 0x13FFC, 0x17FFC, 0x1BFFC, 0x1FFFC, 0x27FFC, 0x2FFFC, 0x37FFC,

  85.     0x3FFFC

  86. };

  87. 

  88. static const float amplitude_tab[64] = {

  89.     1.18750000f, 1.68359380f, 2.37500000f, 3.36718750f, 4.75000000f,

  90.     6.73437500f, 9.50000000f, 13.4687500f, 19.0000000f, 26.9375000f,

  91.     38.0000000f, 53.8750000f, 76.0000000f, 107.750000f, 152.000000f,

  92.     215.500000f, 304.000000f, 431.000000f, 608.000000f, 862.000000f,

  93.     1216.00000f, 1724.00000f, 2432.00000f, 3448.00000f, 4864.00000f,

  94.     6896.00000f, 9728.00000f, 13792.0000f, 19456.0000f, 27584.0000f,

  95.     38912.0000f, 55168.0000f, 77824.0000f, 110336.000f, 155648.000f,

  96.     220672.000f, 311296.000f, 441344.000f, 622592.000f, 882688.000f,

  97.     1245184.00f, 1765376.00f, 2490368.00f, 3530752.00f, 4980736.00f,

  98.     7061504.00f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  99. };

  100. 

  101. static const uint16_t qdmc_nodes[112] = {

  102.     0, 1, 2, 4, 6, 8, 12, 16, 24, 32, 48, 56, 64,

  103.     80, 96, 120, 144, 176, 208, 240, 256,

  104.     0, 2, 4, 8, 16, 24, 32, 48, 56, 64, 80, 104,

  105.     128, 160, 208, 256, 0, 0, 0, 0, 0,

  106.     0, 2, 4, 8, 16, 32, 48, 64, 80, 112, 160, 208,

  107.     256, 0, 0, 0, 0, 0, 0, 0, 0,

  108.     0, 4, 8, 16, 32, 48, 64, 96, 144, 208, 256,

  109.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

  110.     0, 4, 16, 32, 64, 256, 0, 0, 0, 0, 0, 0, 0, 0,

  111.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

  112. };

  113. 

  114. static const uint8_t noise_bands_size[] = {

  115.     19, 14, 11, 9, 4, 2, 0

  116. };

  117. 

  118. static const uint8_t noise_bands_selector[] = {

  119.     4, 3, 2, 1, 0, 0, 0,

  120. };

  121. 

  122. static const uint8_t noise_value[][2] = {

  123.     {  1,  2 }, { 10,  7 }, { 26,  9 }, { 22,  9 }, { 24,  9 }, { 14,  9 },

  124.     {  8,  6 }, {  6,  5 }, {  7,  5 }, {  9,  7 }, { 30,  9 }, { 32, 10 },

  125.     { 13, 10 }, { 20,  9 }, { 28,  9 }, { 12,  7 }, { 15, 11 }, { 36, 12 },

  126.     {  0, 12 }, { 34, 10 }, { 18,  9 }, { 11,  9 }, { 16,  9 }, {  5,  3 },

  127.     {  2,  3 }, {  4,  3 }, {  3,  2 },

  128. };

  129. 

  130. static const uint8_t noise_segment_length[][2] = {

  131.     {  1,  1 }, {  2,  2 }, {  3,  4 }, {  8,  9 }, {  9, 10 }, {  0, 10 },

  132.     { 13,  8 }, {  7,  7 }, {  6,  6 }, { 17,  5 }, {  4,  4 }, {  5,  4 },

  133. };

  134. 

  135. static const uint8_t amplitude[][2] = {

  136.     { 18,  3 }, { 16,  3 }, { 22,  7 }, {  8, 10 }, {  4, 10 }, {  3,  9 },

  137.     {  2,  8 }, { 23,  8 }, { 10,  8 }, { 11,  7 }, { 21,  5 }, { 20,  4 },

  138.     {  1,  7 }, {  7, 10 }, {  5, 10 }, {  9,  9 }, {  6, 10 }, { 25, 11 },

  139.     { 26, 12 }, { 27, 13 }, {  0, 13 }, { 24,  9 }, { 12,  6 }, { 13,  5 },

  140.     { 14,  4 }, { 19,  3 }, { 15,  3 }, { 17,  2 },

  141. };

  142. 

  143. static const uint8_t freq_diff[][2] = {

  144.     {  2,  4 }, { 14,  6 }, { 26,  7 }, { 31,  8 }, { 32,  9 }, { 35,  9 },

  145.     {  7,  5 }, { 10,  5 }, { 22,  7 }, { 27,  7 }, { 19,  7 }, { 20,  7 },

  146.     {  4,  5 }, { 13,  5 }, { 17,  6 }, { 15,  6 }, {  8,  5 }, {  5,  4 },

  147.     { 28,  7 }, { 33,  9 }, { 36, 11 }, { 38, 12 }, { 42, 14 }, { 45, 16 },

  148.     { 44, 18 }, {  0, 18 }, { 46, 17 }, { 43, 15 }, { 40, 13 }, { 37, 11 },

  149.     { 39, 12 }, { 41, 12 }, { 34,  8 }, { 16,  6 }, { 11,  5 }, {  9,  4 },

  150.     {  1,  2 }, {  3,  4 }, { 30,  7 }, { 29,  7 }, { 23,  6 }, { 24,  6 },

  151.     { 18,  6 }, {  6,  4 }, { 12,  5 }, { 21,  6 }, { 25,  6 },

  152. };

  153. 

  154. static const uint8_t amplitude_diff_bits[] = {

  155.     8, 2, 1, 3, 4, 5, 6, 7, 8,

  156. };

  157. 

  158. static const uint8_t amplitude_diff_codes[] = {

  159.     0xFE, 0x0, 0x1, 0x2, 0x6, 0xE, 0x1E, 0x3E, 0x7E,

  160. };

  161. 

  162. static const uint8_t phase_diff_bits[] = {

  163.     6, 2, 2, 4, 4, 6, 5, 4, 2,

  164. };

  165. 

  166. static const uint8_t phase_diff_codes[] = {

  167.     0x35, 0x2, 0x0, 0x1, 0xD, 0x15, 0x5, 0x9, 0x3,

  168. };

  169. 

  170. #define INIT_VLC_STATIC_LE(vlc, nb_bits, nb_codes,                 \

  171.                            bits, bits_wrap, bits_size,             \

  172.                            codes, codes_wrap, codes_size,          \

  173.                            symbols, symbols_wrap, symbols_size,    \

  174.                            static_size)                            \

  175.     do {                                                           \

  176.         static VLC_TYPE table[static_size][2];                     \

  177.         (vlc)->table           = table;                            \

  178.         (vlc)->table_allocated = static_size;                      \

  179.         ff_init_vlc_sparse(vlc, nb_bits, nb_codes,                 \

  180.                            bits, bits_wrap, bits_size,             \

  181.                            codes, codes_wrap, codes_size,          \

  182.                            symbols, symbols_wrap, symbols_size,    \

  183.                            INIT_VLC_LE | INIT_VLC_USE_NEW_STATIC); \

  184.     } while (0)

  185. 

  186. static av_cold void qdmc_init_static_data(void)

  187. {

  188.     int i;

  189. 

  190.     INIT_VLC_STATIC_FROM_LENGTHS(&vtable[0], 12, FF_ARRAY_ELEMS(noise_value),

  191.                                  &noise_value[0][1], 2,

  192.                                  &noise_value[0][0], 2, 1, 0, INIT_VLC_LE, 4096);

  193.     INIT_VLC_STATIC_FROM_LENGTHS(&vtable[1], 10, FF_ARRAY_ELEMS(noise_segment_length),

  194.                                  &noise_segment_length[0][1], 2,

  195.                                  &noise_segment_length[0][0], 2, 1, 0, INIT_VLC_LE, 1024);

  196.     INIT_VLC_STATIC_FROM_LENGTHS(&vtable[2], 12, FF_ARRAY_ELEMS(amplitude),

  197.                                  &amplitude[0][1], 2,

  198.                                  &amplitude[0][0], 2, 1, 0, INIT_VLC_LE, 4098);

  199.     INIT_VLC_STATIC_FROM_LENGTHS(&vtable[3], 12, FF_ARRAY_ELEMS(freq_diff),

  200.                                  &freq_diff[0][1], 2,

  201.                                  &freq_diff[0][0], 2, 1, 0, INIT_VLC_LE, 4160);

  202.     INIT_VLC_STATIC_LE(&vtable[4], 8, FF_ARRAY_ELEMS(amplitude_diff_bits),

  203.                        amplitude_diff_bits, 1, 1, amplitude_diff_codes, 1, 1, NULL, 0, 0, 256);

  204.     INIT_VLC_STATIC_LE(&vtable[5], 6, FF_ARRAY_ELEMS(phase_diff_bits),

  205.                        phase_diff_bits, 1, 1, phase_diff_codes, 1, 1, NULL, 0, 0, 64);

  206. 

  207.     for (i = 0; i < 512; i++)

  208.         sin_table[i] = sin(2.0f * i * M_PI * 0.001953125f);

  209. }

  210. 

  211. static void make_noises(QDMCContext *s)

  212. {

  213.     int i, j, n0, n1, n2, diff;

  214.     float *nptr;

  215. 

  216.     for (j = 0; j < noise_bands_size[s->band_index]; j++) {

  217.         n0 = qdmc_nodes[j + 21 * s->band_index    ];

  218.         n1 = qdmc_nodes[j + 21 * s->band_index + 1];

  219.         n2 = qdmc_nodes[j + 21 * s->band_index + 2];

  220.         nptr = s->noise_buffer + 256 * j;

  221. 

  222.         for (i = 0; i + n0 < n1; i++, nptr++)

  223.             nptr[0] = i / (float)(n1 - n0);

  224. 

  225.         diff = n2 - n1;

  226.         nptr = s->noise_buffer + (j << 8) + n1 - n0;

  227. 

  228.         for (i = n1; i < n2; i++, nptr++, diff--)

  229.             nptr[0] = diff / (float)(n2 - n1);

  230.     }

  231. }

  232. 

  233. static av_cold int qdmc_decode_init(AVCodecContext *avctx)

  234. {

  235.     static AVOnce init_static_once = AV_ONCE_INIT;

  236.     QDMCContext *s = avctx->priv_data;

  237.     int ret, fft_size, fft_order, size, g, j, x;

  238.     GetByteContext b;

  239. 

  240.     ff_thread_once(&init_static_once, qdmc_init_static_data);

  241. 

  242.     if (!avctx->extradata || (avctx->extradata_size < 48)) {

  243.         av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n");

  244.         return AVERROR_INVALIDDATA;

  245.     }

  246. 

  247.     bytestream2_init(&b, avctx->extradata, avctx->extradata_size);

  248. 

  249.     while (bytestream2_get_bytes_left(&b) > 8) {

  250.         if (bytestream2_peek_be64(&b) == (((uint64_t)MKBETAG('f','r','m','a') << 32) |

  251.                                            (uint64_t)MKBETAG('Q','D','M','C')))

  252.             break;

  253.         bytestream2_skipu(&b, 1);

  254.     }

  255.     bytestream2_skipu(&b, 8);

  256. 

  257.     if (bytestream2_get_bytes_left(&b) < 36) {

  258.         av_log(avctx, AV_LOG_ERROR, "not enough extradata (%i)\n",

  259.                bytestream2_get_bytes_left(&b));

  260.         return AVERROR_INVALIDDATA;

  261.     }

  262. 

  263.     size = bytestream2_get_be32u(&b);

  264.     if (size > bytestream2_get_bytes_left(&b)) {

  265.         av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n",

  266.                bytestream2_get_bytes_left(&b), size);

  267.         return AVERROR_INVALIDDATA;

  268.     }

  269. 

  270.     if (bytestream2_get_be32u(&b) != MKBETAG('Q','D','C','A')) {

  271.         av_log(avctx, AV_LOG_ERROR, "invalid extradata, expecting QDCA\n");

  272.         return AVERROR_INVALIDDATA;

  273.     }

  274.     bytestream2_skipu(&b, 4);

  275. 

  276.     avctx->channels = s->nb_channels = bytestream2_get_be32u(&b);

  277.     if (s->nb_channels <= 0 || s->nb_channels > 2) {

  278.         av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");

  279.         return AVERROR_INVALIDDATA;

  280.     }

  281.     avctx->channel_layout = avctx->channels == 2 ? AV_CH_LAYOUT_STEREO :

  282.                                                    AV_CH_LAYOUT_MONO;

  283. 

  284.     avctx->sample_rate = bytestream2_get_be32u(&b);

  285.     avctx->bit_rate = bytestream2_get_be32u(&b);

  286.     bytestream2_skipu(&b, 4);

  287.     fft_size = bytestream2_get_be32u(&b);

  288.     fft_order = av_log2(fft_size) + 1;

  289.     s->checksum_size = bytestream2_get_be32u(&b);

  290.     if (s->checksum_size >= 1U << 28) {

  291.         av_log(avctx, AV_LOG_ERROR, "data block size too large (%u)\n", s->checksum_size);

  292.         return AVERROR_INVALIDDATA;

  293.     }

  294. 

  295.     if (avctx->sample_rate >= 32000) {

  296.         x = 28000;

  297.         s->frame_bits = 13;

  298.     } else if (avctx->sample_rate >= 16000) {

  299.         x = 20000;

  300.         s->frame_bits = 12;

  301.     } else {

  302.         x = 16000;

  303.         s->frame_bits = 11;

  304.     }

  305.     s->frame_size = 1 << s->frame_bits;

  306.     s->subframe_size = s->frame_size >> 5;

  307. 

  308.     if (avctx->channels == 2)

  309.         x = 3 * x / 2;

  310.     s->band_index = noise_bands_selector[FFMIN(6, llrint(floor(avctx->bit_rate * 3.0 / (double)x + 0.5)))];

  311. 

  312.     if ((fft_order < 7) || (fft_order > 9)) {

  313.         avpriv_request_sample(avctx, "Unknown FFT order %d", fft_order);

  314.         return AVERROR_PATCHWELCOME;

  315.     }

  316. 

  317.     if (fft_size != (1 << (fft_order - 1))) {

  318.         av_log(avctx, AV_LOG_ERROR, "FFT size %d not power of 2.\n", fft_size);

  319.         return AVERROR_INVALIDDATA;

  320.     }

  321. 

  322.     ret = ff_fft_init(&s->fft_ctx, fft_order, 1);

  323.     if (ret < 0)

  324.         return ret;

  325. 

  326.     avctx->sample_fmt = AV_SAMPLE_FMT_S16;

  327. 

  328.     for (g = 5; g > 0; g--) {

  329.         for (j = 0; j < (1 << g) - 1; j++)

  330.             s->alt_sin[5-g][j] = sin_table[(((j+1) << (8 - g)) & 0x1FF)];

  331.     }

  332. 

  333.     make_noises(s);

  334. 

  335.     return 0;

  336. }

  337. 

  338. static av_cold int qdmc_decode_close(AVCodecContext *avctx)

  339. {

  340.     QDMCContext *s = avctx->priv_data;

  341. 

  342.     ff_fft_end(&s->fft_ctx);

  343. 

  344.     return 0;

  345. }

  346. 

  347. static int qdmc_get_vlc(GetBitContext *gb, VLC *table, int flag)

  348. {

  349.     int v;

  350. 

  351.     if (get_bits_left(gb) < 1)

  352.         return AVERROR_INVALIDDATA;

  353.     v = get_vlc2(gb, table->table, table->bits, 2);

  354.     if (v)

  355.         v = v - 1;

  356.     else

  357.         v = get_bits(gb, get_bits(gb, 3) + 1);

  358. 

  359.     if (flag) {

  360.         if (v >= FF_ARRAY_ELEMS(code_prefix))

  361.             return AVERROR_INVALIDDATA;

  362. 

  363.         v = code_prefix[v] + get_bitsz(gb, v >> 2);

  364.     }

  365. 

  366.     return v;

  367. }

  368. 

  369. static int skip_label(QDMCContext *s, GetBitContext *gb)

  370. {

  371.     uint32_t label = get_bits_long(gb, 32);

  372.     uint16_t sum = 226, checksum = get_bits(gb, 16);

  373.     const uint8_t *ptr = gb->buffer + 6;

  374.     int i;

  375. 

  376.     if (label != MKTAG('Q', 'M', 'C', 1))

  377.         return AVERROR_INVALIDDATA;

  378. 

  379.     for (i = 0; i < s->checksum_size - 6; i++)

  380.         sum += ptr[i];

  381. 

  382.     return sum != checksum;

  383. }

  384. 

  385. static int read_noise_data(QDMCContext *s, GetBitContext *gb)

  386. {

  387.     int ch, j, k, v, idx, band, lastval, newval, len;

  388. 

  389.     for (ch = 0; ch < s->nb_channels; ch++) {

  390.         for (band = 0; band < noise_bands_size[s->band_index]; band++) {

  391.             v = qdmc_get_vlc(gb, &vtable[0], 0);

  392.             if (v < 0)

  393.                 return AVERROR_INVALIDDATA;

  394. 

  395.             if (v & 1)

  396.                 v = v + 1;

  397.             else

  398.                 v = -v;

  399. 

  400.             lastval = v / 2;

  401.             s->noise[ch][band][0] = lastval - 1;

  402.             for (j = 0; j < 15;) {

  403.                 len = qdmc_get_vlc(gb, &vtable[1], 1);

  404.                 if (len < 0)

  405.                     return AVERROR_INVALIDDATA;

  406.                 len += 1;

  407. 

  408.                 v = qdmc_get_vlc(gb, &vtable[0], 0);

  409.                 if (v < 0)

  410.                     return AVERROR_INVALIDDATA;

  411. 

  412.                 if (v & 1)

  413.                     newval = lastval + (v + 1) / 2;

  414.                 else

  415.                     newval = lastval - v / 2;

  416. 

  417.                 idx = j + 1;

  418.                 if (len + idx > 16)

  419.                     return AVERROR_INVALIDDATA;

  420. 

  421.                 for (k = 1; idx <= j + len; k++, idx++)

  422.                     s->noise[ch][band][idx] = lastval + k * (newval - lastval) / len - 1;

  423. 

  424.                 lastval = newval;

  425.                 j += len;

  426.             }

  427.         }

  428.     }

  429. 

  430.     return 0;

  431. }

  432. 

  433. static void add_tone(QDMCContext *s, int group, int offset, int freq, int stereo_mode, int amplitude, int phase)

  434. {

  435.     const int index = s->nb_tones[group];

  436. 

  437.     if (index >= FF_ARRAY_ELEMS(s->tones[group])) {

  438.         av_log(s->avctx, AV_LOG_WARNING, "Too many tones already in buffer, ignoring tone!\n");

  439.         return;

  440.     }

  441. 

  442.     s->tones[group][index].offset    = offset;

  443.     s->tones[group][index].freq      = freq;

  444.     s->tones[group][index].mode      = stereo_mode;

  445.     s->tones[group][index].amplitude = amplitude;

  446.     s->tones[group][index].phase     = phase;

  447.     s->nb_tones[group]++;

  448. }

  449. 

  450. static int read_wave_data(QDMCContext *s, GetBitContext *gb)

  451. {

  452.     int amp, phase, stereo_mode = 0, i, group, freq, group_size, group_bits;

  453.     int amp2, phase2, pos2, off;

  454. 

  455.     for (group = 0; group < 5; group++) {

  456.         group_size = 1 << (s->frame_bits - group - 1);

  457.         group_bits = 4 - group;

  458.         pos2 = 0;

  459.         off  = 0;

  460. 

  461.         for (i = 1; ; i = freq + 1) {

  462.             int v;

  463. 

  464.             v = qdmc_get_vlc(gb, &vtable[3], 1);

  465.             if (v < 0)

  466.                 return AVERROR_INVALIDDATA;

  467. 

  468.             freq = i + v;

  469.             while (freq >= group_size - 1) {

  470.                 freq += 2 - group_size;

  471.                 pos2 += group_size;

  472.                 off  += 1 << group_bits;

  473.             }

  474. 

  475.             if (pos2 >= s->frame_size)

  476.                 break;

  477. 

  478.             if (s->nb_channels > 1)

  479.                 stereo_mode = get_bits(gb, 2);

  480. 

  481.             amp   = qdmc_get_vlc(gb, &vtable[2], 0);

  482.             if (amp < 0)

  483.                 return AVERROR_INVALIDDATA;

  484.             phase = get_bits(gb, 3);

  485. 

  486.             if (stereo_mode > 1) {

  487.                 amp2   = qdmc_get_vlc(gb, &vtable[4], 0);

  488.                 if (amp2 < 0)

  489.                     return AVERROR_INVALIDDATA;

  490.                 amp2   = amp - amp2;

  491. 

  492.                 phase2 = qdmc_get_vlc(gb, &vtable[5], 0);

  493.                 if (phase2 < 0)

  494.                     return AVERROR_INVALIDDATA;

  495.                 phase2 = phase - phase2;

  496. 

  497.                 if (phase2 < 0)

  498.                     phase2 += 8;

  499.             }

  500. 

  501.             if ((freq >> group_bits) + 1 < s->subframe_size) {

  502.                 add_tone(s, group, off, freq, stereo_mode & 1, amp, phase);

  503.                 if (stereo_mode > 1)

  504.                     add_tone(s, group, off, freq, ~stereo_mode & 1, amp2, phase2);

  505.             }

  506.         }

  507.     }

  508. 

  509.     return 0;

  510. }

  511. 

  512. static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)

  513. {

  514.     int subframe_size, i, j, k, length;

  515.     float scale, *noise_ptr;

  516. 

  517.     scale = 0.5 * amplitude;

  518.     subframe_size = s->subframe_size;

  519.     if (subframe_size >= node2)

  520.         subframe_size = node2;

  521.     length = (subframe_size - node1) & 0xFFFC;

  522.     j = node1;

  523.     noise_ptr = &s->noise_buffer[256 * index];

  524. 

  525.     for (i = 0; i < length; i += 4, j+= 4, noise_ptr += 4) {

  526.         s->noise2_buffer[j    ] += scale * noise_ptr[0];

  527.         s->noise2_buffer[j + 1] += scale * noise_ptr[1];

  528.         s->noise2_buffer[j + 2] += scale * noise_ptr[2];

  529.         s->noise2_buffer[j + 3] += scale * noise_ptr[3];

  530.     }

  531. 

  532.     k = length + node1;

  533.     noise_ptr = s->noise_buffer + length + (index << 8);

  534.     for (i = length; i < subframe_size - node1; i++, k++, noise_ptr++)

  535.         s->noise2_buffer[k] += scale * noise_ptr[0];

  536. }

  537. 

  538. static void add_noise(QDMCContext *s, int ch, int current_subframe)

  539. {

  540.     int i, j, aindex;

  541.     float amplitude;

  542.     float *im = &s->fft_buffer[0 + ch][s->fft_offset + s->subframe_size * current_subframe];

  543.     float *re = &s->fft_buffer[2 + ch][s->fft_offset + s->subframe_size * current_subframe];

  544. 

  545.     memset(s->noise2_buffer, 0, 4 * s->subframe_size);

  546. 

  547.     for (i = 0; i < noise_bands_size[s->band_index]; i++) {

  548.         if (qdmc_nodes[i + 21 * s->band_index] > s->subframe_size - 1)

  549.             break;

  550. 

  551.         aindex = s->noise[ch][i][current_subframe / 2];

  552.         amplitude = aindex > 0 ? amplitude_tab[aindex & 0x3F] : 0.0f;

  553. 

  554.         lin_calc(s, amplitude, qdmc_nodes[21 * s->band_index + i],

  555.                  qdmc_nodes[21 * s->band_index + i + 2], i);

  556.     }

  557. 

  558.     for (j = 2; j < s->subframe_size - 1; j++) {

  559.         float rnd_re, rnd_im;

  560. 

  561.         s->rndval = 214013U * s->rndval + 2531011;

  562.         rnd_im = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];

  563.         s->rndval = 214013U * s->rndval + 2531011;

  564.         rnd_re = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];

  565.         im[j  ] += rnd_im;

  566.         re[j  ] += rnd_re;

  567.         im[j+1] -= rnd_im;

  568.         re[j+1] -= rnd_re;

  569.     }

  570. }

  571. 

  572. static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)

  573. {

  574.     int j, group_bits, pos, pindex;

  575.     float im, re, amplitude, level, *imptr, *reptr;

  576. 

  577.     if (s->nb_channels == 1)

  578.         stereo_mode = 0;

  579. 

  580.     group_bits = 4 - group;

  581.     pos = freqs >> (4 - group);

  582.     amplitude = amplitude_tab[amp & 0x3F];

  583.     imptr = &s->fft_buffer[    stereo_mode][s->fft_offset + s->subframe_size * offset + pos];

  584.     reptr = &s->fft_buffer[2 + stereo_mode][s->fft_offset + s->subframe_size * offset + pos];

  585.     pindex = (phase << 6) - ((2 * (freqs >> (4 - group)) + 1) << 7);

  586.     for (j = 0; j < (1 << (group_bits + 1)) - 1; j++) {

  587.         pindex += (2 * freqs + 1) << (7 - group_bits);

  588.         level = amplitude * s->alt_sin[group][j];

  589.         im = level * sin_table[ pindex        & 0x1FF];

  590.         re = level * sin_table[(pindex + 128) & 0x1FF];

  591.         imptr[0] += im;

  592.         imptr[1] -= im;

  593.         reptr[0] += re;

  594.         reptr[1] -= re;

  595.         imptr += s->subframe_size;

  596.         reptr += s->subframe_size;

  597.         if (imptr >= &s->fft_buffer[stereo_mode][2 * s->frame_size]) {

  598.             imptr = &s->fft_buffer[0 + stereo_mode][pos];

  599.             reptr = &s->fft_buffer[2 + stereo_mode][pos];

  600.         }

  601.     }

  602. }

  603. 

  604. static void add_wave0(QDMCContext *s, int offset, int freqs, int stereo_mode, int amp, int phase)

  605. {

  606.     float level, im, re;

  607.     int pos;

  608. 

  609.     if (s->nb_channels == 1)

  610.         stereo_mode = 0;

  611. 

  612.     level = amplitude_tab[amp & 0x3F];

  613.     im = level * sin_table[ (phase << 6)        & 0x1FF];

  614.     re = level * sin_table[((phase << 6) + 128) & 0x1FF];

  615.     pos = s->fft_offset + freqs + s->subframe_size * offset;

  616.     s->fft_buffer[    stereo_mode][pos    ] += im;

  617.     s->fft_buffer[2 + stereo_mode][pos    ] += re;

  618.     s->fft_buffer[    stereo_mode][pos + 1] -= im;

  619.     s->fft_buffer[2 + stereo_mode][pos + 1] -= re;

  620. }

  621. 

  622. static void add_waves(QDMCContext *s, int current_subframe)

  623. {

  624.     int w, g;

  625. 

  626.     for (g = 0; g < 4; g++) {

  627.         for (w = s->cur_tone[g]; w < s->nb_tones[g]; w++) {

  628.             QDMCTone *t = &s->tones[g][w];

  629. 

  630.             if (current_subframe < t->offset)

  631.                 break;

  632.             add_wave(s, t->offset, t->freq, g, t->mode, t->amplitude, t->phase);

  633.         }

  634.         s->cur_tone[g] = w;

  635.     }

  636.     for (w = s->cur_tone[4]; w < s->nb_tones[4]; w++) {

  637.         QDMCTone *t = &s->tones[4][w];

  638. 

  639.         if (current_subframe < t->offset)

  640.             break;

  641.         add_wave0(s, t->offset, t->freq, t->mode, t->amplitude, t->phase);

  642.     }

  643.     s->cur_tone[4] = w;

  644. }

  645. 

  646. static int decode_frame(QDMCContext *s, GetBitContext *gb, int16_t *out)

  647. {

  648.     int ret, ch, i, n;

  649. 

  650.     if (skip_label(s, gb))

  651.         return AVERROR_INVALIDDATA;

  652. 

  653.     s->fft_offset = s->frame_size - s->fft_offset;

  654.     s->buffer_ptr = &s->buffer[s->nb_channels * s->buffer_offset];

  655. 

  656.     ret = read_noise_data(s, gb);

  657.     if (ret < 0)

  658.         return ret;

  659. 

  660.     ret = read_wave_data(s, gb);

  661.     if (ret < 0)

  662.         return ret;

  663. 

  664.     for (n = 0; n < 32; n++) {

  665.         float *r;

  666. 

  667.         for (ch = 0; ch < s->nb_channels; ch++)

  668.             add_noise(s, ch, n);

  669. 

  670.         add_waves(s, n);

  671. 

  672.         for (ch = 0; ch < s->nb_channels; ch++) {

  673.             for (i = 0; i < s->subframe_size; i++) {

  674.                 s->cmplx[ch][i].re = s->fft_buffer[ch + 2][s->fft_offset + n * s->subframe_size + i];

  675.                 s->cmplx[ch][i].im = s->fft_buffer[ch + 0][s->fft_offset + n * s->subframe_size + i];

  676.                 s->cmplx[ch][s->subframe_size + i].re = 0;

  677.                 s->cmplx[ch][s->subframe_size + i].im = 0;

  678.             }

  679.         }

  680. 

  681.         for (ch = 0; ch < s->nb_channels; ch++) {

  682.             s->fft_ctx.fft_permute(&s->fft_ctx, s->cmplx[ch]);

  683.             s->fft_ctx.fft_calc(&s->fft_ctx, s->cmplx[ch]);

  684.         }

  685. 

  686.         r = &s->buffer_ptr[s->nb_channels * n * s->subframe_size];

  687.         for (i = 0; i < 2 * s->subframe_size; i++) {

  688.             for (ch = 0; ch < s->nb_channels; ch++) {

  689.                 *r++ += s->cmplx[ch][i].re;

  690.             }

  691.         }

  692. 

  693.         r = &s->buffer_ptr[n * s->subframe_size * s->nb_channels];

  694.         for (i = 0; i < s->nb_channels * s->subframe_size; i++) {

  695.             out[i] = av_clipf(r[i], INT16_MIN, INT16_MAX);

  696.         }

  697.         out += s->subframe_size * s->nb_channels;

  698. 

  699.         for (ch = 0; ch < s->nb_channels; ch++) {

  700.             memset(s->fft_buffer[ch+0] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);

  701.             memset(s->fft_buffer[ch+2] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);

  702.         }

  703.         memset(s->buffer + s->nb_channels * (n * s->subframe_size + s->frame_size + s->buffer_offset), 0, 4 * s->subframe_size * s->nb_channels);

  704.     }

  705. 

  706.     s->buffer_offset += s->frame_size;

  707.     if (s->buffer_offset >= 32768 - s->frame_size) {

  708.         memcpy(s->buffer, &s->buffer[s->nb_channels * s->buffer_offset], 4 * s->frame_size * s->nb_channels);

  709.         s->buffer_offset = 0;

  710.     }

  711. 

  712.     return 0;

  713. }

  714. 

  715. static av_cold void qdmc_flush(AVCodecContext *avctx)

  716. {

  717.     QDMCContext *s = avctx->priv_data;

  718. 

  719.     memset(s->buffer, 0, sizeof(s->buffer));

  720.     memset(s->fft_buffer, 0, sizeof(s->fft_buffer));

  721.     s->fft_offset = 0;

  722.     s->buffer_offset = 0;

  723. }

  724. 

  725. static int qdmc_decode_frame(AVCodecContext *avctx, void *data,

  726.                              int *got_frame_ptr, AVPacket *avpkt)

  727. {

  728.     QDMCContext *s = avctx->priv_data;

  729.     AVFrame *frame = data;

  730.     GetBitContext gb;

  731.     int ret;

  732. 

  733.     if (!avpkt->data)

  734.         return 0;

  735.     if (avpkt->size < s->checksum_size)

  736.         return AVERROR_INVALIDDATA;

  737. 

  738.     s->avctx = avctx;

  739.     frame->nb_samples = s->frame_size;

  740.     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

  741.         return ret;

  742. 

  743.     if ((ret = init_get_bits8(&gb, avpkt->data, s->checksum_size)) < 0)

  744.         return ret;

  745. 

  746.     memset(s->nb_tones, 0, sizeof(s->nb_tones));

  747.     memset(s->cur_tone, 0, sizeof(s->cur_tone));

  748. 

  749.     ret = decode_frame(s, &gb, (int16_t *)frame->data[0]);

  750.     if (ret >= 0) {

  751.         *got_frame_ptr = 1;

  752.         return s->checksum_size;

  753.     }

  754.     qdmc_flush(avctx);

  755.     return ret;

  756. }

  757. 

  758. AVCodec ff_qdmc_decoder = {

  759.     .name             = "qdmc",

  760.     .long_name        = NULL_IF_CONFIG_SMALL("QDesign Music Codec 1"),

  761.     .type             = AVMEDIA_TYPE_AUDIO,

  762.     .id               = AV_CODEC_ID_QDMC,

  763.     .priv_data_size   = sizeof(QDMCContext),

  764.     .init             = qdmc_decode_init,

  765.     .close            = qdmc_decode_close,

  766.     .decode           = qdmc_decode_frame,

  767.     .flush            = qdmc_flush,

  768.     .capabilities     = AV_CODEC_CAP_DR1,

  769. };