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