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 
69  DECLARE_ALIGNED(32, FFTComplex, cmplx)[2][512];
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);
283  if (size > bytestream2_get_bytes_left(&b)) {
284  av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n",
285  bytestream2_get_bytes_left(&b), size);
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 };
static const uint32_t freq_diff_codes[]
Definition: qdmc.c:157
static const uint16_t qdmc_nodes[112]
Definition: qdmc.c:101
static const uint16_t amplitude_codes[]
Definition: qdmc.c:170
#define NULL
Definition: coverity.c:32
static int qdmc_get_vlc(GetBitContext *gb, VLC *table, int flag)
Definition: qdmc.c:366
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static void flush(AVCodecContext *avctx)
AVCodec ff_qdmc_decoder
Definition: qdmc.c:779
float buffer[2 *32768]
Definition: qdmc.c:65
float re
Definition: fft.c:82
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1620
const char * g
Definition: vf_curves.c:115
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static const uint8_t noise_bands_size[]
Definition: qdmc.c:114
QDMCTone tones[5][8192]
Definition: qdmc.c:58
#define avpriv_request_sample(...)
static VLC vtable[6]
Definition: qdmc.c:74
static const uint16_t noise_segment_length_codes[]
Definition: qdmc.c:147
int rndval
Definition: qdmc.c:67
int size
Definition: avcodec.h:1483
const uint8_t * buffer
Definition: get_bits.h:62
int av_log2(unsigned v)
Definition: intmath.c:26
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
FFTSample re
Definition: avfft.h:38
int nb_tones[5]
Definition: qdmc.c:59
FFTComplex cmplx[2][512]
Definition: qdmc.c:69
#define AV_CH_LAYOUT_STEREO
Definition: qdmc.c:37
AVCodec.
Definition: avcodec.h:3494
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static float sin_table[512]
Definition: qdmc.c:73
static av_cold int qdmc_decode_close(AVCodecContext *avctx)
Definition: qdmc.c:357
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2238
uint8_t
#define av_cold
Definition: attributes.h:82
static const uint8_t amplitude_bits[]
Definition: qdmc.c:165
#define f(width, name)
Definition: cbs_vp9.c:255
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1671
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
uint8_t * data
Definition: avcodec.h:1482
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:170
bitstream reader API header.
ptrdiff_t size
Definition: opengl_enc.c:100
static av_cold void qdmc_flush(AVCodecContext *avctx)
Definition: qdmc.c:736
#define AVOnce
Definition: thread.h:159
#define av_log(a,...)
static const uint16_t table[]
Definition: prosumer.c:206
static const uint8_t phase_diff_bits[]
Definition: qdmc.c:184
#define U(x)
Definition: vp56_arith.h:37
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
#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
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
void(* fft_permute)(struct FFTContext *s, FFTComplex *z)
Do the permutation needed BEFORE calling fft_calc().
Definition: fft.h:101
float fft_buffer[4][8192 *2]
Definition: qdmc.c:62
static const uint8_t noise_bands_selector[]
Definition: qdmc.c:118
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
const char * r
Definition: vf_curves.c:114
uint8_t frame_bits
Definition: qdmc.c:48
int16_t amplitude
Definition: qdmc.c:42
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
GLsizei GLsizei * length
Definition: opengl_enc.c:114
const char * name
Name of the codec implementation.
Definition: avcodec.h:3501
static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)
Definition: qdmc.c:593
float alt_sin[5][31]
Definition: qdmc.c:61
static const uint8_t freq_diff_bits[]
Definition: qdmc.c:151
Definition: vlc.h:26
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2281
int subframe_size
Definition: qdmc.c:51
#define b
Definition: input.c:41
Definition: fft.h:88
int16_t freq
Definition: qdmc.c:41
audio channel layout utility functions
#define FFMIN(a, b)
Definition: common.h:96
static int decode_frame(QDMCContext *s, GetBitContext *gb, int16_t *out)
Definition: qdmc.c:667
uint8_t noise[2][19][17]
Definition: qdmc.c:57
uint8_t w
Definition: llviddspenc.c:38
#define ff_fft_init
Definition: fft.h:149
int buffer_offset
Definition: qdmc.c:53
static const uint8_t noise_segment_length_bits[]
Definition: qdmc.c:139
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
#define s(width, name)
Definition: cbs_vp9.c:257
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
int n
Definition: avisynth_c.h:760
static const uint8_t amplitude_diff_codes[]
Definition: qdmc.c:180
static void add_noise(QDMCContext *s, int ch, int current_subframe)
Definition: qdmc.c:559
static volatile int checksum
Definition: adler32.c:30
FFTContext fft_ctx
Definition: qdmc.c:70
static av_cold void qdmc_init_static_data(void)
Definition: qdmc.c:208
#define FF_ARRAY_ELEMS(a)
int bits
Definition: vlc.h:27
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static const uint16_t noise_value_codes[]
Definition: qdmc.c:132
float * buffer_ptr
Definition: qdmc.c:66
static void add_tone(QDMCContext *s, int group, int offset, int freq, int stereo_mode, int amplitude, int phase)
Definition: qdmc.c:454
static int skip_label(QDMCContext *s, GetBitContext *gb)
Definition: qdmc.c:390
#define AV_ONCE_INIT
Definition: thread.h:160
Libavcodec external API header.
int sample_rate
samples per second
Definition: avcodec.h:2230
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static void make_noises(QDMCContext *s)
Definition: qdmc.c:230
uint8_t offset
Definition: qdmc.c:40
main external API structure.
Definition: avcodec.h:1570
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1968
static int read_noise_data(QDMCContext *s, GetBitContext *gb)
Definition: qdmc.c:406
int extradata_size
Definition: avcodec.h:1672
#define llrint(x)
Definition: libm.h:394
static const uint8_t noise_value_bits[]
Definition: qdmc.c:122
int index
Definition: gxfenc.c:89
static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)
Definition: qdmc.c:533
float im
Definition: fft.c:82
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
float noise2_buffer[4096 *2]
Definition: qdmc.c:63
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63)))#define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};static void cpy1(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, len);}static void cpy2(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 2 *len);}static void cpy4(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 4 *len);}static void cpy8(uint8_t **dst, const uint8_t **src, int len){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;}void swri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len){int ch;int off=0;const int os=(out->planar?1:out->ch_count)*out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){int planes=in->planar?in->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){int planes=out->planar?out->ch_count:1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){int planes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
static const uint8_t phase_diff_codes[]
Definition: qdmc.c:188
static const uint8_t amplitude_diff_bits[]
Definition: qdmc.c:176
int band_index
Definition: qdmc.c:49
static int noise(AVBSFContext *ctx, AVPacket *pkt)
Definition: noise_bsf.c:38
uint8_t mode
Definition: qdmc.c:38
static void add_waves(QDMCContext *s, int current_subframe)
Definition: qdmc.c:643
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
uint8_t level
Definition: svq3.c:207
static void add_wave0(QDMCContext *s, int offset, int freqs, int stereo_mode, int amp, int phase)
Definition: qdmc.c:625
common internal api header.
FFTSample im
Definition: avfft.h:38
uint8_t phase
Definition: qdmc.c:39
int frame_size
Definition: qdmc.c:50
signed 16 bits
Definition: samplefmt.h:61
#define flag(name)
Definition: cbs_av1.c:553
int checksum_size
Definition: qdmc.c:55
static const float amplitude_tab[64]
Definition: qdmc.c:88
#define ff_fft_end
Definition: fft.h:150
void(* fft_calc)(struct FFTContext *s, FFTComplex *z)
Do a complex FFT with the parameters defined in ff_fft_init().
Definition: fft.h:106
static const unsigned code_prefix[]
Definition: qdmc.c:76
static const uint8_t noise_value_symbols[]
Definition: qdmc.c:127
#define MKBETAG(a, b, c, d)
Definition: common.h:367
int nb_channels
Definition: qdmc.c:54
void * priv_data
Definition: avcodec.h:1597
static av_always_inline int diff(const uint32_t a, const uint32_t b)
int fft_offset
Definition: qdmc.c:52
int len
int channels
number of audio channels
Definition: avcodec.h:2231
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:162
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
AVCodecContext * avctx
Definition: qdmc.c:46
FILE * out
Definition: movenc.c:54
#define M_PI
Definition: mathematics.h:52
static av_cold int qdmc_decode_init(AVCodecContext *avctx)
Definition: qdmc.c:252
#define AV_CH_LAYOUT_MONO
#define MKTAG(a, b, c, d)
Definition: common.h:366
This structure stores compressed data.
Definition: avcodec.h:1459
int cur_tone[5]
Definition: qdmc.c:60
static int read_wave_data(QDMCContext *s, GetBitContext *gb)
Definition: qdmc.c:471
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:986
static const uint8_t noise_segment_length_symbols[]
Definition: qdmc.c:143
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:415
GLuint buffer
Definition: opengl_enc.c:101
float noise_buffer[4096 *2]
Definition: qdmc.c:64
static int qdmc_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: qdmc.c:746