FFmpeg
qdmc.c
Go to the documentation of this file.
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 
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 {
41  int16_t freq;
42  int16_t amplitude;
43 } QDMCTone;
44 
45 typedef struct QDMCContext {
47 
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 
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 
140  10, 8, 5, 1, 2, 4, 4, 4, 6, 7, 9, 10,
141 };
142 
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 
209 {
210  int i;
211 
213  noise_value_bits, 1, 1, noise_value_codes, 2, 2, noise_value_symbols, 1, 1, 4096);
216  noise_segment_length_symbols, 1, 1, 1024);
218  amplitude_bits, 1, 1, amplitude_codes, 2, 2, NULL, 0, 0, 8192);
220  freq_diff_bits, 1, 1, freq_diff_codes, 4, 4, NULL, 0, 0, 262144);
222  amplitude_diff_bits, 1, 1, amplitude_diff_codes, 1, 1, NULL, 0, 0, 256);
224  phase_diff_bits, 1, 1, phase_diff_codes, 1, 1, NULL, 0, 0, 64);
225 
226  for (i = 0; i < 512; i++)
227  sin_table[i] = sin(2.0f * i * M_PI * 0.001953125f);
228 }
229 
230 static void make_noises(QDMCContext *s)
231 {
232  int i, j, n0, n1, n2, diff;
233  float *nptr;
234 
235  for (j = 0; j < noise_bands_size[s->band_index]; j++) {
236  n0 = qdmc_nodes[j + 21 * s->band_index ];
237  n1 = qdmc_nodes[j + 21 * s->band_index + 1];
238  n2 = qdmc_nodes[j + 21 * s->band_index + 2];
239  nptr = s->noise_buffer + 256 * j;
240 
241  for (i = 0; i + n0 < n1; i++, nptr++)
242  nptr[0] = i / (float)(n1 - n0);
243 
244  diff = n2 - n1;
245  nptr = s->noise_buffer + (j << 8) + n1 - n0;
246 
247  for (i = n1; i < n2; i++, nptr++, diff--)
248  nptr[0] = diff / (float)(n2 - n1);
249  }
250 }
251 
253 {
254  static AVOnce init_static_once = AV_ONCE_INIT;
255  QDMCContext *s = avctx->priv_data;
256  int ret, fft_size, fft_order, size, g, j, x;
258 
259  ff_thread_once(&init_static_once, qdmc_init_static_data);
260 
261  if (!avctx->extradata || (avctx->extradata_size < 48)) {
262  av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n");
263  return AVERROR_INVALIDDATA;
264  }
265 
266  bytestream2_init(&b, avctx->extradata, avctx->extradata_size);
267 
268  while (bytestream2_get_bytes_left(&b) > 8) {
269  if (bytestream2_peek_be64(&b) == (((uint64_t)MKBETAG('f','r','m','a') << 32) |
270  (uint64_t)MKBETAG('Q','D','M','C')))
271  break;
272  bytestream2_skipu(&b, 1);
273  }
274  bytestream2_skipu(&b, 8);
275 
276  if (bytestream2_get_bytes_left(&b) < 36) {
277  av_log(avctx, AV_LOG_ERROR, "not enough extradata (%i)\n",
279  return AVERROR_INVALIDDATA;
280  }
281 
282  size = bytestream2_get_be32u(&b);
284  av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n",
286  return AVERROR_INVALIDDATA;
287  }
288 
289  if (bytestream2_get_be32u(&b) != MKBETAG('Q','D','C','A')) {
290  av_log(avctx, AV_LOG_ERROR, "invalid extradata, expecting QDCA\n");
291  return AVERROR_INVALIDDATA;
292  }
293  bytestream2_skipu(&b, 4);
294 
295  avctx->channels = s->nb_channels = bytestream2_get_be32u(&b);
296  if (s->nb_channels <= 0 || s->nb_channels > 2) {
297  av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
298  return AVERROR_INVALIDDATA;
299  }
300  avctx->channel_layout = avctx->channels == 2 ? AV_CH_LAYOUT_STEREO :
302 
303  avctx->sample_rate = bytestream2_get_be32u(&b);
304  avctx->bit_rate = bytestream2_get_be32u(&b);
305  bytestream2_skipu(&b, 4);
306  fft_size = bytestream2_get_be32u(&b);
307  fft_order = av_log2(fft_size) + 1;
308  s->checksum_size = bytestream2_get_be32u(&b);
309  if (s->checksum_size >= 1U << 28) {
310  av_log(avctx, AV_LOG_ERROR, "data block size too large (%u)\n", s->checksum_size);
311  return AVERROR_INVALIDDATA;
312  }
313 
314  if (avctx->sample_rate >= 32000) {
315  x = 28000;
316  s->frame_bits = 13;
317  } else if (avctx->sample_rate >= 16000) {
318  x = 20000;
319  s->frame_bits = 12;
320  } else {
321  x = 16000;
322  s->frame_bits = 11;
323  }
324  s->frame_size = 1 << s->frame_bits;
325  s->subframe_size = s->frame_size >> 5;
326 
327  if (avctx->channels == 2)
328  x = 3 * x / 2;
329  s->band_index = noise_bands_selector[FFMIN(6, llrint(floor(avctx->bit_rate * 3.0 / (double)x + 0.5)))];
330 
331  if ((fft_order < 7) || (fft_order > 9)) {
332  avpriv_request_sample(avctx, "Unknown FFT order %d", fft_order);
333  return AVERROR_PATCHWELCOME;
334  }
335 
336  if (fft_size != (1 << (fft_order - 1))) {
337  av_log(avctx, AV_LOG_ERROR, "FFT size %d not power of 2.\n", fft_size);
338  return AVERROR_INVALIDDATA;
339  }
340 
341  ret = ff_fft_init(&s->fft_ctx, fft_order, 1);
342  if (ret < 0)
343  return ret;
344 
345  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
346 
347  for (g = 5; g > 0; g--) {
348  for (j = 0; j < (1 << g) - 1; j++)
349  s->alt_sin[5-g][j] = sin_table[(((j+1) << (8 - g)) & 0x1FF)];
350  }
351 
352  make_noises(s);
353 
354  return 0;
355 }
356 
358 {
359  QDMCContext *s = avctx->priv_data;
360 
361  ff_fft_end(&s->fft_ctx);
362 
363  return 0;
364 }
365 
366 static int qdmc_get_vlc(GetBitContext *gb, VLC *table, int flag)
367 {
368  int v;
369 
370  if (get_bits_left(gb) < 1)
371  return AVERROR_INVALIDDATA;
372  v = get_vlc2(gb, table->table, table->bits, 1);
373  if (v < 0)
374  return AVERROR_INVALIDDATA;
375  if (v)
376  v = v - 1;
377  else
378  v = get_bits(gb, get_bits(gb, 3) + 1);
379 
380  if (flag) {
381  if (v >= FF_ARRAY_ELEMS(code_prefix))
382  return AVERROR_INVALIDDATA;
383 
384  v = code_prefix[v] + get_bitsz(gb, v >> 2);
385  }
386 
387  return v;
388 }
389 
391 {
392  uint32_t label = get_bits_long(gb, 32);
393  uint16_t sum = 226, checksum = get_bits(gb, 16);
394  const uint8_t *ptr = gb->buffer + 6;
395  int i;
396 
397  if (label != MKTAG('Q', 'M', 'C', 1))
398  return AVERROR_INVALIDDATA;
399 
400  for (i = 0; i < s->checksum_size - 6; i++)
401  sum += ptr[i];
402 
403  return sum != checksum;
404 }
405 
407 {
408  int ch, j, k, v, idx, band, lastval, newval, len;
409 
410  for (ch = 0; ch < s->nb_channels; ch++) {
411  for (band = 0; band < noise_bands_size[s->band_index]; band++) {
412  v = qdmc_get_vlc(gb, &vtable[0], 0);
413  if (v < 0)
414  return AVERROR_INVALIDDATA;
415 
416  if (v & 1)
417  v = v + 1;
418  else
419  v = -v;
420 
421  lastval = v / 2;
422  s->noise[ch][band][0] = lastval - 1;
423  for (j = 0; j < 15;) {
424  len = qdmc_get_vlc(gb, &vtable[1], 1);
425  if (len < 0)
426  return AVERROR_INVALIDDATA;
427  len += 1;
428 
429  v = qdmc_get_vlc(gb, &vtable[0], 0);
430  if (v < 0)
431  return AVERROR_INVALIDDATA;
432 
433  if (v & 1)
434  newval = lastval + (v + 1) / 2;
435  else
436  newval = lastval - v / 2;
437 
438  idx = j + 1;
439  if (len + idx > 16)
440  return AVERROR_INVALIDDATA;
441 
442  for (k = 1; idx <= j + len; k++, idx++)
443  s->noise[ch][band][idx] = lastval + k * (newval - lastval) / len - 1;
444 
445  lastval = newval;
446  j += len;
447  }
448  }
449  }
450 
451  return 0;
452 }
453 
454 static void add_tone(QDMCContext *s, int group, int offset, int freq, int stereo_mode, int amplitude, int phase)
455 {
456  const int index = s->nb_tones[group];
457 
458  if (index >= FF_ARRAY_ELEMS(s->tones[group])) {
459  av_log(s->avctx, AV_LOG_WARNING, "Too many tones already in buffer, ignoring tone!\n");
460  return;
461  }
462 
463  s->tones[group][index].offset = offset;
464  s->tones[group][index].freq = freq;
465  s->tones[group][index].mode = stereo_mode;
466  s->tones[group][index].amplitude = amplitude;
467  s->tones[group][index].phase = phase;
468  s->nb_tones[group]++;
469 }
470 
472 {
473  int amp, phase, stereo_mode = 0, i, group, freq, group_size, group_bits;
474  int amp2, phase2, pos2, off;
475 
476  for (group = 0; group < 5; group++) {
477  group_size = 1 << (s->frame_bits - group - 1);
478  group_bits = 4 - group;
479  pos2 = 0;
480  off = 0;
481 
482  for (i = 1; ; i = freq + 1) {
483  int v;
484 
485  v = qdmc_get_vlc(gb, &vtable[3], 1);
486  if (v < 0)
487  return AVERROR_INVALIDDATA;
488 
489  freq = i + v;
490  while (freq >= group_size - 1) {
491  freq += 2 - group_size;
492  pos2 += group_size;
493  off += 1 << group_bits;
494  }
495 
496  if (pos2 >= s->frame_size)
497  break;
498 
499  if (s->nb_channels > 1)
500  stereo_mode = get_bits(gb, 2);
501 
502  amp = qdmc_get_vlc(gb, &vtable[2], 0);
503  if (amp < 0)
504  return AVERROR_INVALIDDATA;
505  phase = get_bits(gb, 3);
506 
507  if (stereo_mode > 1) {
508  amp2 = qdmc_get_vlc(gb, &vtable[4], 0);
509  if (amp2 < 0)
510  return AVERROR_INVALIDDATA;
511  amp2 = amp - amp2;
512 
513  phase2 = qdmc_get_vlc(gb, &vtable[5], 0);
514  if (phase2 < 0)
515  return AVERROR_INVALIDDATA;
516  phase2 = phase - phase2;
517 
518  if (phase2 < 0)
519  phase2 += 8;
520  }
521 
522  if ((freq >> group_bits) + 1 < s->subframe_size) {
523  add_tone(s, group, off, freq, stereo_mode & 1, amp, phase);
524  if (stereo_mode > 1)
525  add_tone(s, group, off, freq, ~stereo_mode & 1, amp2, phase2);
526  }
527  }
528  }
529 
530  return 0;
531 }
532 
533 static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)
534 {
535  int subframe_size, i, j, k, length;
536  float scale, *noise_ptr;
537 
538  scale = 0.5 * amplitude;
539  subframe_size = s->subframe_size;
540  if (subframe_size >= node2)
541  subframe_size = node2;
542  length = (subframe_size - node1) & 0xFFFC;
543  j = node1;
544  noise_ptr = &s->noise_buffer[256 * index];
545 
546  for (i = 0; i < length; i += 4, j+= 4, noise_ptr += 4) {
547  s->noise2_buffer[j ] += scale * noise_ptr[0];
548  s->noise2_buffer[j + 1] += scale * noise_ptr[1];
549  s->noise2_buffer[j + 2] += scale * noise_ptr[2];
550  s->noise2_buffer[j + 3] += scale * noise_ptr[3];
551  }
552 
553  k = length + node1;
554  noise_ptr = s->noise_buffer + length + (index << 8);
555  for (i = length; i < subframe_size - node1; i++, k++, noise_ptr++)
556  s->noise2_buffer[k] += scale * noise_ptr[0];
557 }
558 
559 static void add_noise(QDMCContext *s, int ch, int current_subframe)
560 {
561  int i, j, aindex;
562  float amplitude;
563  float *im = &s->fft_buffer[0 + ch][s->fft_offset + s->subframe_size * current_subframe];
564  float *re = &s->fft_buffer[2 + ch][s->fft_offset + s->subframe_size * current_subframe];
565 
566  memset(s->noise2_buffer, 0, 4 * s->subframe_size);
567 
568  for (i = 0; i < noise_bands_size[s->band_index]; i++) {
569  if (qdmc_nodes[i + 21 * s->band_index] > s->subframe_size - 1)
570  break;
571 
572  aindex = s->noise[ch][i][current_subframe / 2];
573  amplitude = aindex > 0 ? amplitude_tab[aindex & 0x3F] : 0.0f;
574 
575  lin_calc(s, amplitude, qdmc_nodes[21 * s->band_index + i],
576  qdmc_nodes[21 * s->band_index + i + 2], i);
577  }
578 
579  for (j = 2; j < s->subframe_size - 1; j++) {
580  float rnd_re, rnd_im;
581 
582  s->rndval = 214013U * s->rndval + 2531011;
583  rnd_im = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
584  s->rndval = 214013U * s->rndval + 2531011;
585  rnd_re = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
586  im[j ] += rnd_im;
587  re[j ] += rnd_re;
588  im[j+1] -= rnd_im;
589  re[j+1] -= rnd_re;
590  }
591 }
592 
593 static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)
594 {
595  int j, group_bits, pos, pindex;
596  float im, re, amplitude, level, *imptr, *reptr;
597 
598  if (s->nb_channels == 1)
599  stereo_mode = 0;
600 
601  group_bits = 4 - group;
602  pos = freqs >> (4 - group);
603  amplitude = amplitude_tab[amp & 0x3F];
604  imptr = &s->fft_buffer[ stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
605  reptr = &s->fft_buffer[2 + stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
606  pindex = (phase << 6) - ((2 * (freqs >> (4 - group)) + 1) << 7);
607  for (j = 0; j < (1 << (group_bits + 1)) - 1; j++) {
608  pindex += (2 * freqs + 1) << (7 - group_bits);
609  level = amplitude * s->alt_sin[group][j];
610  im = level * sin_table[ pindex & 0x1FF];
611  re = level * sin_table[(pindex + 128) & 0x1FF];
612  imptr[0] += im;
613  imptr[1] -= im;
614  reptr[0] += re;
615  reptr[1] -= re;
616  imptr += s->subframe_size;
617  reptr += s->subframe_size;
618  if (imptr >= &s->fft_buffer[stereo_mode][2 * s->frame_size]) {
619  imptr = &s->fft_buffer[0 + stereo_mode][pos];
620  reptr = &s->fft_buffer[2 + stereo_mode][pos];
621  }
622  }
623 }
624 
625 static void add_wave0(QDMCContext *s, int offset, int freqs, int stereo_mode, int amp, int phase)
626 {
627  float level, im, re;
628  int pos;
629 
630  if (s->nb_channels == 1)
631  stereo_mode = 0;
632 
633  level = amplitude_tab[amp & 0x3F];
634  im = level * sin_table[ (phase << 6) & 0x1FF];
635  re = level * sin_table[((phase << 6) + 128) & 0x1FF];
636  pos = s->fft_offset + freqs + s->subframe_size * offset;
637  s->fft_buffer[ stereo_mode][pos ] += im;
638  s->fft_buffer[2 + stereo_mode][pos ] += re;
639  s->fft_buffer[ stereo_mode][pos + 1] -= im;
640  s->fft_buffer[2 + stereo_mode][pos + 1] -= re;
641 }
642 
643 static void add_waves(QDMCContext *s, int current_subframe)
644 {
645  int w, g;
646 
647  for (g = 0; g < 4; g++) {
648  for (w = s->cur_tone[g]; w < s->nb_tones[g]; w++) {
649  QDMCTone *t = &s->tones[g][w];
650 
651  if (current_subframe < t->offset)
652  break;
653  add_wave(s, t->offset, t->freq, g, t->mode, t->amplitude, t->phase);
654  }
655  s->cur_tone[g] = w;
656  }
657  for (w = s->cur_tone[4]; w < s->nb_tones[4]; w++) {
658  QDMCTone *t = &s->tones[4][w];
659 
660  if (current_subframe < t->offset)
661  break;
662  add_wave0(s, t->offset, t->freq, t->mode, t->amplitude, t->phase);
663  }
664  s->cur_tone[4] = w;
665 }
666 
667 static int decode_frame(QDMCContext *s, GetBitContext *gb, int16_t *out)
668 {
669  int ret, ch, i, n;
670 
671  if (skip_label(s, gb))
672  return AVERROR_INVALIDDATA;
673 
674  s->fft_offset = s->frame_size - s->fft_offset;
675  s->buffer_ptr = &s->buffer[s->nb_channels * s->buffer_offset];
676 
677  ret = read_noise_data(s, gb);
678  if (ret < 0)
679  return ret;
680 
681  ret = read_wave_data(s, gb);
682  if (ret < 0)
683  return ret;
684 
685  for (n = 0; n < 32; n++) {
686  float *r;
687 
688  for (ch = 0; ch < s->nb_channels; ch++)
689  add_noise(s, ch, n);
690 
691  add_waves(s, n);
692 
693  for (ch = 0; ch < s->nb_channels; ch++) {
694  for (i = 0; i < s->subframe_size; i++) {
695  s->cmplx[ch][i].re = s->fft_buffer[ch + 2][s->fft_offset + n * s->subframe_size + i];
696  s->cmplx[ch][i].im = s->fft_buffer[ch + 0][s->fft_offset + n * s->subframe_size + i];
697  s->cmplx[ch][s->subframe_size + i].re = 0;
698  s->cmplx[ch][s->subframe_size + i].im = 0;
699  }
700  }
701 
702  for (ch = 0; ch < s->nb_channels; ch++) {
703  s->fft_ctx.fft_permute(&s->fft_ctx, s->cmplx[ch]);
704  s->fft_ctx.fft_calc(&s->fft_ctx, s->cmplx[ch]);
705  }
706 
707  r = &s->buffer_ptr[s->nb_channels * n * s->subframe_size];
708  for (i = 0; i < 2 * s->subframe_size; i++) {
709  for (ch = 0; ch < s->nb_channels; ch++) {
710  *r++ += s->cmplx[ch][i].re;
711  }
712  }
713 
714  r = &s->buffer_ptr[n * s->subframe_size * s->nb_channels];
715  for (i = 0; i < s->nb_channels * s->subframe_size; i++) {
716  out[i] = av_clipf(r[i], INT16_MIN, INT16_MAX);
717  }
718  out += s->subframe_size * s->nb_channels;
719 
720  for (ch = 0; ch < s->nb_channels; ch++) {
721  memset(s->fft_buffer[ch+0] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
722  memset(s->fft_buffer[ch+2] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
723  }
724  memset(s->buffer + s->nb_channels * (n * s->subframe_size + s->frame_size + s->buffer_offset), 0, 4 * s->subframe_size * s->nb_channels);
725  }
726 
727  s->buffer_offset += s->frame_size;
728  if (s->buffer_offset >= 32768 - s->frame_size) {
729  memcpy(s->buffer, &s->buffer[s->nb_channels * s->buffer_offset], 4 * s->frame_size * s->nb_channels);
730  s->buffer_offset = 0;
731  }
732 
733  return 0;
734 }
735 
736 static av_cold void qdmc_flush(AVCodecContext *avctx)
737 {
738  QDMCContext *s = avctx->priv_data;
739 
740  memset(s->buffer, 0, sizeof(s->buffer));
741  memset(s->fft_buffer, 0, sizeof(s->fft_buffer));
742  s->fft_offset = 0;
743  s->buffer_offset = 0;
744 }
745 
746 static int qdmc_decode_frame(AVCodecContext *avctx, void *data,
747  int *got_frame_ptr, AVPacket *avpkt)
748 {
749  QDMCContext *s = avctx->priv_data;
750  AVFrame *frame = data;
751  GetBitContext gb;
752  int ret;
753 
754  if (!avpkt->data)
755  return 0;
756  if (avpkt->size < s->checksum_size)
757  return AVERROR_INVALIDDATA;
758 
759  s->avctx = avctx;
760  frame->nb_samples = s->frame_size;
761  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
762  return ret;
763 
764  if ((ret = init_get_bits8(&gb, avpkt->data, s->checksum_size)) < 0)
765  return ret;
766 
767  memset(s->nb_tones, 0, sizeof(s->nb_tones));
768  memset(s->cur_tone, 0, sizeof(s->cur_tone));
769 
770  ret = decode_frame(s, &gb, (int16_t *)frame->data[0]);
771  if (ret >= 0) {
772  *got_frame_ptr = 1;
773  return s->checksum_size;
774  }
775  qdmc_flush(avctx);
776  return ret;
777 }
778 
780  .name = "qdmc",
781  .long_name = NULL_IF_CONFIG_SMALL("QDesign Music Codec 1"),
782  .type = AVMEDIA_TYPE_AUDIO,
783  .id = AV_CODEC_ID_QDMC,
784  .priv_data_size = sizeof(QDMCContext),
786  .close = qdmc_decode_close,
788  .flush = qdmc_flush,
789  .capabilities = AV_CODEC_CAP_DR1,
790 };
add_waves
static void add_waves(QDMCContext *s, int current_subframe)
Definition: qdmc.c:643
make_noises
static void make_noises(QDMCContext *s)
Definition: qdmc.c:230
ff_fft_init
#define ff_fft_init
Definition: fft.h:149
amplitude_codes
static const uint16_t amplitude_codes[]
Definition: qdmc.c:170
AVCodec
AVCodec.
Definition: codec.h:190
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
level
uint8_t level
Definition: svq3.c:210
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
r
const char * r
Definition: vf_curves.c:114
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1237
QDMCContext::fft_buffer
float fft_buffer[4][8192 *2]
Definition: qdmc.c:62
out
FILE * out
Definition: movenc.c:54
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1186
GetByteContext
Definition: bytestream.h:33
amplitude_diff_bits
static const uint8_t amplitude_diff_bits[]
Definition: qdmc.c:176
QDMCContext::nb_channels
int nb_channels
Definition: qdmc.c:54
thread.h
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:406
skip_label
static int skip_label(QDMCContext *s, GetBitContext *gb)
Definition: qdmc.c:390
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:85
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
noise_bands_selector
static const uint8_t noise_bands_selector[]
Definition: qdmc.c:118
QDMCContext::noise_buffer
float noise_buffer[4096 *2]
Definition: qdmc.c:64
bytestream2_skipu
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:170
im
float im
Definition: fft.c:82
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
lin_calc
static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)
Definition: qdmc.c:533
w
uint8_t w
Definition: llviddspenc.c:38
QDMCContext::buffer
float buffer[2 *32768]
Definition: qdmc.c:65
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:355
QDMCContext::noise2_buffer
float noise2_buffer[4096 *2]
Definition: qdmc.c:63
b
#define b
Definition: input.c:41
table
static const uint16_t table[]
Definition: prosumer.c:206
data
const char data[16]
Definition: mxf.c:91
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
read_wave_data
static int read_wave_data(QDMCContext *s, GetBitContext *gb)
Definition: qdmc.c:471
QDMCContext::cmplx
FFTComplex cmplx[2][512]
Definition: qdmc.c:69
phase_diff_codes
static const uint8_t phase_diff_codes[]
Definition: qdmc.c:188
QDMCTone::freq
int16_t freq
Definition: qdmc.c:41
QDMCTone
Definition: qdmc.c:37
amplitude_bits
static const uint8_t amplitude_bits[]
Definition: qdmc.c:165
noise_segment_length_symbols
static const uint8_t noise_segment_length_symbols[]
Definition: qdmc.c:143
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
QDMCContext::alt_sin
float alt_sin[5][31]
Definition: qdmc.c:61
qdmc_decode_frame
static int qdmc_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: qdmc.c:746
phase_diff_bits
static const uint8_t phase_diff_bits[]
Definition: qdmc.c:184
U
#define U(x)
Definition: vp56_arith.h:37
qdmc_get_vlc
static int qdmc_get_vlc(GetBitContext *gb, VLC *table, int flag)
Definition: qdmc.c:366
GetBitContext
Definition: get_bits.h:61
freq_diff_codes
static const uint32_t freq_diff_codes[]
Definition: qdmc.c:157
amplitude_tab
static const float amplitude_tab[64]
Definition: qdmc.c:88
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:86
noise_value_symbols
static const uint8_t noise_value_symbols[]
Definition: qdmc.c:127
qdmc_decode_close
static av_cold int qdmc_decode_close(AVCodecContext *avctx)
Definition: qdmc.c:357
QDMCContext::frame_size
int frame_size
Definition: qdmc.c:50
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
sin_table
static float sin_table[512]
Definition: qdmc.c:73
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:628
QDMCContext::subframe_size
int subframe_size
Definition: qdmc.c:51
s
#define s(width, name)
Definition: cbs_vp9.c:257
g
const char * g
Definition: vf_curves.c:115
QDMCContext::cur_tone
int cur_tone[5]
Definition: qdmc.c:60
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
qdmc_decode_init
static av_cold int qdmc_decode_init(AVCodecContext *avctx)
Definition: qdmc.c:252
ff_fft_end
#define ff_fft_end
Definition: fft.h:150
QDMCContext::buffer_ptr
float * buffer_ptr
Definition: qdmc.c:66
INIT_VLC_STATIC_LE
#define INIT_VLC_STATIC_LE(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, symbols, symbols_wrap, symbols_size, static_size)
Definition: qdmc.c:192
QDMCContext
Definition: qdmc.c:45
get_bits.h
QDMCContext::band_index
int band_index
Definition: qdmc.c:49
decode_frame
static int decode_frame(QDMCContext *s, GetBitContext *gb, int16_t *out)
Definition: qdmc.c:667
f
#define f(width, name)
Definition: cbs_vp9.c:255
QDMCTone::amplitude
int16_t amplitude
Definition: qdmc.c:42
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:62
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
add_wave0
static void add_wave0(QDMCContext *s, int offset, int freqs, int stereo_mode, int amp, int phase)
Definition: qdmc.c:625
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:500
NULL
#define NULL
Definition: coverity.c:32
add_noise
static void add_noise(QDMCContext *s, int ch, int current_subframe)
Definition: qdmc.c:559
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
QDMCContext::rndval
int rndval
Definition: qdmc.c:67
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
QDMCContext::noise
uint8_t noise[2][19][17]
Definition: qdmc.c:57
QDMCTone::offset
uint8_t offset
Definition: qdmc.c:40
vtable
static VLC vtable[6]
Definition: qdmc.c:74
AVOnce
#define AVOnce
Definition: thread.h:172
index
int index
Definition: gxfenc.c:89
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
QDMCContext::fft_offset
int fft_offset
Definition: qdmc.c:52
noise_segment_length_bits
static const uint8_t noise_segment_length_bits[]
Definition: qdmc.c:139
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1854
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
AVPacket::size
int size
Definition: packet.h:356
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
add_wave
static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)
Definition: qdmc.c:593
freq_diff_bits
static const uint8_t freq_diff_bits[]
Definition: qdmc.c:151
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1194
size
int size
Definition: twinvq_data.h:11134
AV_CODEC_ID_QDMC
@ AV_CODEC_ID_QDMC
Definition: codec_id.h:460
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: common.h:407
QDMCTone::mode
uint8_t mode
Definition: qdmc.c:38
QDMCContext::buffer_offset
int buffer_offset
Definition: qdmc.c:53
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
QDMCContext::checksum_size
int checksum_size
Definition: qdmc.c:55
code_prefix
static const unsigned code_prefix[]
Definition: qdmc.c:76
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
QDMCContext::fft_ctx
FFTContext fft_ctx
Definition: qdmc.c:70
M_PI
#define M_PI
Definition: mathematics.h:52
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1187
noise_segment_length_codes
static const uint16_t noise_segment_length_codes[]
Definition: qdmc.c:147
flag
#define flag(name)
Definition: cbs_av1.c:557
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:112
FFTContext
Definition: fft.h:88
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
amplitude_diff_codes
static const uint8_t amplitude_diff_codes[]
Definition: qdmc.c:180
QDMCContext::avctx
AVCodecContext * avctx
Definition: qdmc.c:46
uint8_t
uint8_t
Definition: audio_convert.c:194
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
len
int len
Definition: vorbis_enc_data.h:452
avcodec.h
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
QDMCContext::tones
QDMCTone tones[5][8192]
Definition: qdmc.c:58
pos
unsigned int pos
Definition: spdifenc.c:412
checksum
static volatile int checksum
Definition: adler32.c:30
qdmc_flush
static av_cold void qdmc_flush(AVCodecContext *avctx)
Definition: qdmc.c:736
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:38
QDMCContext::frame_bits
uint8_t frame_bits
Definition: qdmc.c:48
fft.h
AVCodecContext
main external API structure.
Definition: avcodec.h:526
channel_layout.h
VLC
Definition: vlc.h:26
noise_value_bits
static const uint8_t noise_value_bits[]
Definition: qdmc.c:122
qdmc_init_static_data
static av_cold void qdmc_init_static_data(void)
Definition: qdmc.c:208
add_tone
static void add_tone(QDMCContext *s, int group, int offset, int freq, int stereo_mode, int amplitude, int phase)
Definition: qdmc.c:454
get_bitsz
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:415
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
llrint
#define llrint(x)
Definition: libm.h:394
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
qdmc_nodes
static const uint16_t qdmc_nodes[112]
Definition: qdmc.c:101
AVPacket
This structure stores compressed data.
Definition: packet.h:332
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
QDMCContext::nb_tones
int nb_tones[5]
Definition: qdmc.c:59
read_noise_data
static int read_noise_data(QDMCContext *s, GetBitContext *gb)
Definition: qdmc.c:406
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
ff_qdmc_decoder
AVCodec ff_qdmc_decoder
Definition: qdmc.c:779
noise_value_codes
static const uint16_t noise_value_codes[]
Definition: qdmc.c:132
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
QDMCTone::phase
uint8_t phase
Definition: qdmc.c:39
FFTComplex
Definition: avfft.h:37
noise_bands_size
static const uint8_t noise_bands_size[]
Definition: qdmc.c:114
re
float re
Definition: fft.c:82