LCOV - code coverage report
Current view: top level - libavcodec - qdmc.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 351 0.0 %
Date: 2018-02-23 01:21:18 Functions: 0 17 0.0 %

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

Generated by: LCOV version 1.13