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