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 
25 #define BITSTREAM_READER_LE
26 
28 #include "libavutil/mem_internal.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 "decode.h"
36 #include "get_bits.h"
37 
38 typedef 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 
46 typedef struct QDMCContext {
48 
49  uint8_t frame_bits;
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 
74 } QDMCContext;
75 
76 static float sin_table[512];
77 static VLC vtable[6];
78 
79 static 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 
91 static 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 
104 static 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 
117 static const uint8_t noise_bands_size[] = {
118  19, 14, 11, 9, 4, 2, 0
119 };
120 
121 static const uint8_t noise_bands_selector[] = {
122  4, 3, 2, 1, 0, 0, 0,
123 };
124 
125 static 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 
158 static const uint8_t huff_sizes[] = {
159  27, 12, 28, 47, 9, 9
160 };
161 
162 static const uint8_t huff_bits[] = {
163  12, 10, 12, 12, 8, 6
164 };
165 
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;
176  &hufftab[0][1], 2, &hufftab[0][0], 2, 1, -1,
178  hufftab += huff_sizes[i];
180  }
181 
182  for (i = 0; i < 512; i++)
183  sin_table[i] = sin(2.0f * i * M_PI * 0.001953125f);
184 }
185 
186 static 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 
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;
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",
236  return AVERROR_INVALIDDATA;
237  }
238 
239  size = bytestream2_get_be32u(&b);
241  av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n",
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  }
258  avctx->ch_layout = s->nb_channels == 2 ? (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO :
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 
316 {
317  QDMCContext *s = avctx->priv_data;
318 
319  av_tx_uninit(&s->fft_ctx);
320 
321  return 0;
322 }
323 
324 static 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 
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 
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 
408 static 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 
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 
487 static 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 
513 static 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 
547 static 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 
579 static 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 
597 static 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 
621 static 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 
689 static 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 
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 
732  .p.name = "qdmc",
733  CODEC_LONG_NAME("QDesign Music Codec 1"),
734  .p.type = AVMEDIA_TYPE_AUDIO,
735  .p.id = AV_CODEC_ID_QDMC,
736  .priv_data_size = sizeof(QDMCContext),
738  .close = qdmc_decode_close,
740  .flush = qdmc_flush,
741  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
742 };
add_waves
static void add_waves(QDMCContext *s, int current_subframe)
Definition: qdmc.c:597
make_noises
static void make_noises(QDMCContext *s)
Definition: qdmc.c:186
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
ff_vlc_init_from_lengths
int ff_vlc_init_from_lengths(VLC *vlc, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
Definition: vlc.c:306
level
uint8_t level
Definition: svq3.c:204
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
r
const char * r
Definition: vf_curves.c:126
mem_internal.h
QDMCContext::fft_buffer
float fft_buffer[4][8192 *2]
Definition: qdmc.c:63
out
FILE * out
Definition: movenc.c:54
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:379
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1050
GetByteContext
Definition: bytestream.h:33
QDMCContext::cmplx_out
AVComplexFloat cmplx_out[2][512]
Definition: qdmc.c:71
QDMCContext::nb_channels
int nb_channels
Definition: qdmc.c:55
thread.h
skip_label
static int skip_label(QDMCContext *s, GetBitContext *gb)
Definition: qdmc.c:344
AVTXContext
Definition: tx_priv.h:235
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:421
noise_bands_selector
static const uint8_t noise_bands_selector[]
Definition: qdmc.c:121
QDMCContext::noise_buffer
float noise_buffer[4096 *2]
Definition: qdmc.c:65
bytestream2_skipu
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:174
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:344
lin_calc
static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)
Definition: qdmc.c:487
w
uint8_t w
Definition: llviddspenc.c:38
QDMCContext::buffer
float buffer[2 *32768]
Definition: qdmc.c:66
AVPacket::data
uint8_t * data
Definition: packet.h:522
QDMCContext::noise2_buffer
float noise2_buffer[4096 *2]
Definition: qdmc.c:64
b
#define b
Definition: input.c:41
table
static const uint16_t table[]
Definition: prosumer.c:205
FFCodec
Definition: codec_internal.h:127
AVComplexFloat
Definition: tx.h:27
read_wave_data
static int read_wave_data(QDMCContext *s, GetBitContext *gb)
Definition: qdmc.c:425
QDMCContext::fft_ctx
AVTXContext * fft_ctx
Definition: qdmc.c:72
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
av_tx_init
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
Definition: tx.c:902
ff_qdmc_decoder
const FFCodec ff_qdmc_decoder
Definition: qdmc.c:731
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:365
QDMCTone::freq
int16_t freq
Definition: qdmc.c:42
QDMCTone
Definition: qdmc.c:38
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
QDMCContext::alt_sin
float alt_sin[5][31]
Definition: qdmc.c:62
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
qdmc_get_vlc
static int qdmc_get_vlc(GetBitContext *gb, VLC *table, int flag)
Definition: qdmc.c:324
GetBitContext
Definition: get_bits.h:108
amplitude_tab
static const float amplitude_tab[64]
Definition: qdmc.c:91
qdmc_decode_close
static av_cold int qdmc_decode_close(AVCodecContext *avctx)
Definition: qdmc.c:315
QDMCContext::frame_size
int frame_size
Definition: qdmc.c:51
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
sin_table
static float sin_table[512]
Definition: qdmc.c:76
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
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:545
av_tx_fn
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
Definition: tx.h:151
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
QDMCContext::subframe_size
int subframe_size
Definition: qdmc.c:52
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:287
s
#define s(width, name)
Definition: cbs_vp9.c:198
VLC_INIT_LE
#define VLC_INIT_LE
Definition: vlc.h:186
floor
static __device__ float floor(float a)
Definition: cuda_runtime.h:173
g
const char * g
Definition: vf_curves.c:127
QDMCContext::cur_tone
int cur_tone[5]
Definition: qdmc.c:61
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:208
QDMCContext::buffer_ptr
float * buffer_ptr
Definition: qdmc.c:67
QDMCContext
Definition: qdmc.c:46
AV_TX_FLOAT_FFT
@ AV_TX_FLOAT_FFT
Standard complex to complex FFT with sample data type of AVComplexFloat, AVComplexDouble or AVComplex...
Definition: tx.h:47
qdmc_hufftab
static const uint8_t qdmc_hufftab[][2]
Definition: qdmc.c:125
decode.h
get_bits.h
QDMCContext::band_index
int band_index
Definition: qdmc.c:50
decode_frame
static int decode_frame(QDMCContext *s, GetBitContext *gb, int16_t *out)
Definition: qdmc.c:621
QDMCTone::amplitude
int16_t amplitude
Definition: qdmc.c:43
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
frame
static AVFrame * frame
Definition: demux_decode.c:54
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:109
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
add_wave0
static void add_wave0(QDMCContext *s, int offset, int freqs, int stereo_mode, int amp, int phase)
Definition: qdmc.c:579
NULL
#define NULL
Definition: coverity.c:32
add_noise
static void add_noise(QDMCContext *s, int ch, int current_subframe)
Definition: qdmc.c:513
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
QDMCContext::rndval
int rndval
Definition: qdmc.c:68
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:495
QDMCContext::noise
uint8_t noise[2][19][17]
Definition: qdmc.c:58
QDMCTone::offset
uint8_t offset
Definition: qdmc.c:41
av_clipf
av_clipf
Definition: af_crystalizer.c:121
vtable
static VLC vtable[6]
Definition: qdmc.c:77
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:652
AVOnce
#define AVOnce
Definition: thread.h:202
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:158
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:106
QDMCContext::fft_offset
int fft_offset
Definition: qdmc.c:53
VLC::table_allocated
int table_allocated
Definition: vlc.h:39
f
f
Definition: af_crystalizer.c:121
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1569
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:523
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: vvc_intra.c:291
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:303
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:109
add_wave
static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)
Definition: qdmc.c:547
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1057
size
int size
Definition: twinvq_data.h:10344
VLCElem
Definition: vlc.h:32
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
AV_CODEC_ID_QDMC
@ AV_CODEC_ID_QDMC
Definition: codec_id.h:490
qdmc_decode_frame
static int qdmc_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Definition: qdmc.c:699
QDMCTone::mode
uint8_t mode
Definition: qdmc.c:39
QDMCContext::itx_fn
av_tx_fn itx_fn
Definition: qdmc.c:73
QDMCContext::buffer_offset
int buffer_offset
Definition: qdmc.c:54
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:164
QDMCContext::checksum_size
int checksum_size
Definition: qdmc.c:56
code_prefix
static const unsigned code_prefix[]
Definition: qdmc.c:79
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
huff_sizes
static const uint8_t huff_sizes[]
Definition: qdmc.c:158
M_PI
#define M_PI
Definition: mathematics.h:67
av_tx_uninit
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
Definition: tx.c:294
QDMCContext::cmplx_in
AVComplexFloat cmplx_in[2][512]
Definition: qdmc.c:70
flag
#define flag(name)
Definition: cbs_av1.c:474
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:424
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
QDMCContext::avctx
AVCodecContext * avctx
Definition: qdmc.c:47
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:58
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
len
int len
Definition: vorbis_enc_data.h:426
avcodec.h
ret
ret
Definition: filter_design.txt:187
QDMCContext::tones
QDMCTone tones[5][8192]
Definition: qdmc.c:59
huff_bits
static const uint8_t huff_bits[]
Definition: qdmc.c:162
pos
unsigned int pos
Definition: spdifenc.c:413
qdmc_flush
static av_cold void qdmc_flush(AVCodecContext *avctx)
Definition: qdmc.c:689
U
#define U(x)
Definition: vpx_arith.h:37
QDMCContext::frame_bits
uint8_t frame_bits
Definition: qdmc.c:49
AVCodecContext
main external API structure.
Definition: avcodec.h:445
VLC_INIT_STATIC_OVERLONG
#define VLC_INIT_STATIC_OVERLONG
Definition: vlc.h:180
channel_layout.h
VLC
Definition: vlc.h:36
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:432
qdmc_init_static_data
static av_cold void qdmc_init_static_data(void)
Definition: qdmc.c:166
add_tone
static void add_tone(QDMCContext *s, int group, int offset, int freq, int stereo_mode, int amplitude, int phase)
Definition: qdmc.c:408
VLC::table
VLCElem * table
Definition: vlc.h:38
VLC::table_size
int table_size
Definition: vlc.h:39
get_bitsz
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:351
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
llrint
#define llrint(x)
Definition: libm.h:394
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:378
qdmc_nodes
static const uint16_t qdmc_nodes[112]
Definition: qdmc.c:104
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
QDMCContext::nb_tones
int nb_tones[5]
Definition: qdmc.c:60
read_noise_data
static int read_noise_data(QDMCContext *s, GetBitContext *gb)
Definition: qdmc.c:360
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
QDMCTone::phase
uint8_t phase
Definition: qdmc.c:40
noise_bands_size
static const uint8_t noise_bands_size[]
Definition: qdmc.c:117
tx.h