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 #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 
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  .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),
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
level
uint8_t level
Definition: svq3.c:206
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
r
const char * r
Definition: vf_curves.c:116
QDMCContext::fft_buffer
float fft_buffer[4][8192 *2]
Definition: qdmc.c:63
out
FILE * out
Definition: movenc.c:54
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1007
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:201
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: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
im
float im
Definition: fft.c:79
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
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
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
QDMCContext::noise2_buffer
float noise2_buffer[4096 *2]
Definition: qdmc.c:64
b
#define b
Definition: input.c:34
table
static const uint16_t table[]
Definition: prosumer.c:206
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:353
FFCodec
Definition: codec_internal.h:118
AVComplexFloat
Definition: tx.h:27
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:354
read_wave_data
static int read_wave_data(QDMCContext *s, GetBitContext *gb)
Definition: qdmc.c:425
INIT_VLC_LE
#define INIT_VLC_LE
Definition: vlc.h:99
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:300
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:649
ff_qdmc_decoder
const FFCodec ff_qdmc_decoder
Definition: qdmc.c:731
QDMCTone::freq
int16_t freq
Definition: qdmc.c:42
QDMCTone
Definition: qdmc.c:38
init
static int init
Definition: av_tx.c:47
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:62
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2065
qdmc_get_vlc
static int qdmc_get_vlc(GetBitContext *gb, VLC *table, int flag)
Definition: qdmc.c:324
GetBitContext
Definition: get_bits.h:61
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
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:179
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:667
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:111
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:500
QDMCContext::subframe_size
int subframe_size
Definition: qdmc.c:52
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:260
s
#define s(width, name)
Definition: cbs_vp9.c:256
floor
static __device__ float floor(float a)
Definition: cuda_runtime.h:173
g
const char * g
Definition: vf_curves.c:117
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
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
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:62
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:177
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:448
ff_init_vlc_from_lengths
int ff_init_vlc_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:328
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:122
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:787
AVOnce
#define AVOnce
Definition: thread.h:176
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_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:630
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:109
QDMCContext::fft_offset
int fft_offset
Definition: qdmc.c:53
VLC::table_allocated
int table_allocated
Definition: vlc.h:34
f
f
Definition: af_crystalizer.c:122
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1462
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:375
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:117
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:290
codec_internal.h
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:1023
size
int size
Definition: twinvq_data.h:10344
VLCElem
Definition: vlc.h:27
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
AV_CODEC_ID_QDMC
@ AV_CODEC_ID_QDMC
Definition: codec_id.h:479
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
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:52
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:251
QDMCContext::cmplx_in
AVComplexFloat cmplx_in[2][512]
Definition: qdmc.c:70
flag
#define flag(name)
Definition: cbs_av1.c:553
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
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:499
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:211
len
int len
Definition: vorbis_enc_data.h:426
avcodec.h
ret
ret
Definition: filter_design.txt:187
INIT_VLC_STATIC_OVERLONG
#define INIT_VLC_STATIC_OVERLONG
Definition: vlc.h:101
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:59
huff_bits
static const uint8_t huff_bits[]
Definition: qdmc.c:162
pos
unsigned int pos
Definition: spdifenc.c:412
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:398
channel_layout.h
VLC
Definition: vlc.h:31
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:33
VLC::table_size
int table_size
Definition: vlc.h:34
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:36
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:139
qdmc_nodes
static const uint16_t qdmc_nodes[112]
Definition: qdmc.c:104
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
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
re
float re
Definition: fft.c:79