FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
qdmc.c
Go to the documentation of this file.
1 /*
2  * QDMC compatible decoder
3  * Copyright (c) 2017 Paul B Mahol
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <math.h>
23 #include <stddef.h>
24 #include <stdio.h>
25 
26 #define BITSTREAM_READER_LE
27 
29 #include "libavutil/thread.h"
30 
31 #include "avcodec.h"
32 #include "bytestream.h"
33 #include "get_bits.h"
34 #include "internal.h"
35 #include "fft.h"
36 
37 typedef struct QDMCTone {
41  int16_t freq;
42  int16_t amplitude;
43 } QDMCTone;
44 
45 typedef struct QDMCContext {
47 
56 
57  uint8_t noise[2][19][17];
58  QDMCTone tones[5][8192];
59  int nb_tones[5];
60  int cur_tone[5];
61  float alt_sin[5][31];
62  float fft_buffer[4][8192 * 2];
63  float noise2_buffer[4096 * 2];
64  float noise_buffer[4096 * 2];
65  float buffer[2 * 32768];
66  float *buffer_ptr;
67  int rndval;
68 
71 } QDMCContext;
72 
73 static float sin_table[512];
74 static VLC vtable[6];
75 
76 static const unsigned code_prefix[] = {
77  0x0, 0x1, 0x2, 0x3, 0x4, 0x6, 0x8, 0xA,
78  0xC, 0x10, 0x14, 0x18, 0x1C, 0x24, 0x2C, 0x34,
79  0x3C, 0x4C, 0x5C, 0x6C, 0x7C, 0x9C, 0xBC, 0xDC,
80  0xFC, 0x13C, 0x17C, 0x1BC, 0x1FC, 0x27C, 0x2FC, 0x37C,
81  0x3FC, 0x4FC, 0x5FC, 0x6FC, 0x7FC, 0x9FC, 0xBFC, 0xDFC,
82  0xFFC, 0x13FC, 0x17FC, 0x1BFC, 0x1FFC, 0x27FC, 0x2FFC, 0x37FC,
83  0x3FFC, 0x4FFC, 0x5FFC, 0x6FFC, 0x7FFC, 0x9FFC, 0xBFFC, 0xDFFC,
84  0xFFFC, 0x13FFC, 0x17FFC, 0x1BFFC, 0x1FFFC, 0x27FFC, 0x2FFFC, 0x37FFC,
85  0x3FFFC
86 };
87 
88 static const float amplitude_tab[64] = {
89  1.18750000f, 1.68359380f, 2.37500000f, 3.36718750f, 4.75000000f,
90  6.73437500f, 9.50000000f, 13.4687500f, 19.0000000f, 26.9375000f,
91  38.0000000f, 53.8750000f, 76.0000000f, 107.750000f, 152.000000f,
92  215.500000f, 304.000000f, 431.000000f, 608.000000f, 862.000000f,
93  1216.00000f, 1724.00000f, 2432.00000f, 3448.00000f, 4864.00000f,
94  6896.00000f, 9728.00000f, 13792.0000f, 19456.0000f, 27584.0000f,
95  38912.0000f, 55168.0000f, 77824.0000f, 110336.000f, 155648.000f,
96  220672.000f, 311296.000f, 441344.000f, 622592.000f, 882688.000f,
97  1245184.00f, 1765376.00f, 2490368.00f, 3530752.00f, 4980736.00f,
98  7061504.00f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
99 };
100 
101 static const uint16_t qdmc_nodes[112] = {
102  0, 1, 2, 4, 6, 8, 12, 16, 24, 32, 48, 56, 64,
103  80, 96, 120, 144, 176, 208, 240, 256,
104  0, 2, 4, 8, 16, 24, 32, 48, 56, 64, 80, 104,
105  128, 160, 208, 256, 0, 0, 0, 0, 0,
106  0, 2, 4, 8, 16, 32, 48, 64, 80, 112, 160, 208,
107  256, 0, 0, 0, 0, 0, 0, 0, 0,
108  0, 4, 8, 16, 32, 48, 64, 96, 144, 208, 256,
109  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
110  0, 4, 16, 32, 64, 256, 0, 0, 0, 0, 0, 0, 0, 0,
111  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
112 };
113 
114 static const uint8_t noise_bands_size[] = {
115  19, 14, 11, 9, 4, 2, 0
116 };
117 
118 static const uint8_t noise_bands_selector[] = {
119  4, 3, 2, 1, 0, 0, 0,
120 };
121 
122 static const uint8_t noise_value_bits[] = {
123  12, 7, 9, 7, 10, 9, 11, 9, 9, 2, 9, 9, 9, 9,
124  9, 3, 9, 10, 10, 12, 2, 3, 3, 5, 5, 6, 7,
125 };
126 
127 static const uint8_t noise_value_symbols[] = {
128  0, 10, 11, 12, 13, 14, 15, 16, 18, 1, 20, 22, 24,
129  26, 28, 2, 30, 32, 34, 36, 3, 4, 5, 6, 7, 8, 9,
130 };
131 
132 static const uint16_t noise_value_codes[] = {
133  0xC7A, 0x002, 0x0FA, 0x03A, 0x35A, 0x1C2, 0x07A, 0x1FA,
134  0x17A, 0x000, 0x0DA, 0x142, 0x0C2, 0x042, 0x1DA, 0x001,
135  0x05A, 0x15A, 0x27A, 0x47A, 0x003, 0x005, 0x006, 0x012,
136  0x00A, 0x022, 0x01A,
137 };
138 
140  10, 8, 5, 1, 2, 4, 4, 4, 6, 7, 9, 10,
141 };
142 
144  0, 13, 17, 1, 2, 3, 4, 5, 6, 7, 8, 9,
145 };
146 
147 static const uint16_t noise_segment_length_codes[] = {
148  0x30B, 0x8B, 0x1B, 0x0, 0x1, 0x3, 0x7, 0xF, 0x2b, 0x4B, 0xB, 0x10B,
149 };
150 
151 static const uint8_t freq_diff_bits[] = {
152  18, 2, 4, 4, 5, 4, 4, 5, 5, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 6,
153  7, 6, 6, 6, 7, 7, 7, 7, 7, 8, 9, 9, 8, 9, 11, 11, 12, 12, 13, 12,
154  14, 15, 18, 16, 17,
155 };
156 
157 static const uint32_t freq_diff_codes[] = {
158  0x2AD46, 0x1, 0x0, 0x3, 0xC, 0xA, 0x7, 0x18, 0x12, 0xE, 0x4, 0x16,
159  0xF, 0x1C, 0x8, 0x22, 0x26, 0x2, 0x3B, 0x34, 0x74, 0x1F, 0x14, 0x2B,
160  0x1B, 0x3F, 0x28, 0x54, 0x6, 0x4B, 0xB, 0x68, 0xE8, 0x46, 0xC6, 0x1E8,
161  0x146, 0x346, 0x546, 0x746, 0x1D46, 0xF46, 0xD46, 0x6D46, 0xAD46, 0x2D46,
162  0x1AD46,
163 };
164 
165 static const uint8_t amplitude_bits[] = {
166  13, 7, 8, 9, 10, 10, 10, 10, 10, 9, 8, 7, 6,
167  5, 4, 3, 3, 2, 3, 3, 4, 5, 7, 8, 9, 11, 12, 13,
168 };
169 
170 static const uint16_t amplitude_codes[] = {
171  0x1EC6, 0x6, 0xC2, 0x142, 0x242, 0x246, 0xC6, 0x46, 0x42, 0x146, 0xA2,
172  0x62, 0x26, 0x16, 0xE, 0x5, 0x4, 0x3, 0x0, 0x1, 0xA, 0x12, 0x2, 0x22,
173  0x1C6, 0x2C6, 0x6C6, 0xEC6,
174 };
175 
176 static const uint8_t amplitude_diff_bits[] = {
177  8, 2, 1, 3, 4, 5, 6, 7, 8,
178 };
179 
180 static const uint8_t amplitude_diff_codes[] = {
181  0xFE, 0x0, 0x1, 0x2, 0x6, 0xE, 0x1E, 0x3E, 0x7E,
182 };
183 
184 static const uint8_t phase_diff_bits[] = {
185  6, 2, 2, 4, 4, 6, 5, 4, 2,
186 };
187 
188 static const uint8_t phase_diff_codes[] = {
189  0x35, 0x2, 0x0, 0x1, 0xD, 0x15, 0x5, 0x9, 0x3,
190 };
191 
192 #define INIT_VLC_STATIC_LE(vlc, nb_bits, nb_codes, \
193  bits, bits_wrap, bits_size, \
194  codes, codes_wrap, codes_size, \
195  symbols, symbols_wrap, symbols_size, \
196  static_size) \
197  do { \
198  static VLC_TYPE table[static_size][2]; \
199  (vlc)->table = table; \
200  (vlc)->table_allocated = static_size; \
201  ff_init_vlc_sparse(vlc, nb_bits, nb_codes, \
202  bits, bits_wrap, bits_size, \
203  codes, codes_wrap, codes_size, \
204  symbols, symbols_wrap, symbols_size, \
205  INIT_VLC_LE | INIT_VLC_USE_NEW_STATIC); \
206  } while (0)
207 
209 {
210  int i;
211 
213  noise_value_bits, 1, 1, noise_value_codes, 2, 2, noise_value_symbols, 1, 1, 4096);
216  noise_segment_length_symbols, 1, 1, 1024);
218  amplitude_bits, 1, 1, amplitude_codes, 2, 2, NULL, 0, 0, 8192);
220  freq_diff_bits, 1, 1, freq_diff_codes, 4, 4, NULL, 0, 0, 262144);
222  amplitude_diff_bits, 1, 1, amplitude_diff_codes, 1, 1, NULL, 0, 0, 256);
224  phase_diff_bits, 1, 1, phase_diff_codes, 1, 1, NULL, 0, 0, 64);
225 
226  for (i = 0; i < 512; i++)
227  sin_table[i] = sin(2.0f * i * M_PI * 0.001953125f);
228 }
229 
230 static void make_noises(QDMCContext *s)
231 {
232  int i, j, n0, n1, n2, diff;
233  float *nptr;
234 
235  for (j = 0; j < noise_bands_size[s->band_index]; j++) {
236  n0 = qdmc_nodes[j + 21 * s->band_index ];
237  n1 = qdmc_nodes[j + 21 * s->band_index + 1];
238  n2 = qdmc_nodes[j + 21 * s->band_index + 2];
239  nptr = s->noise_buffer + 256 * j;
240 
241  for (i = 0; i + n0 < n1; i++, nptr++)
242  nptr[0] = i / (float)(n1 - n0);
243 
244  diff = n2 - n1;
245  nptr = s->noise_buffer + (j << 8) + n1 - n0;
246 
247  for (i = n1; i < n2; i++, nptr++, diff--)
248  nptr[0] = diff / (float)(n2 - n1);
249  }
250 }
251 
253 {
254  static AVOnce init_static_once = AV_ONCE_INIT;
255  QDMCContext *s = avctx->priv_data;
256  int ret, fft_size, fft_order, size, g, j, x;
258 
259  ff_thread_once(&init_static_once, qdmc_init_static_data);
260 
261  if (!avctx->extradata || (avctx->extradata_size < 48)) {
262  av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n");
263  return AVERROR_INVALIDDATA;
264  }
265 
266  bytestream2_init(&b, avctx->extradata, avctx->extradata_size);
267 
268  while (bytestream2_get_bytes_left(&b) > 8) {
269  if (bytestream2_peek_be64(&b) == (((uint64_t)MKBETAG('f','r','m','a') << 32) |
270  (uint64_t)MKBETAG('Q','D','M','C')))
271  break;
272  bytestream2_skipu(&b, 1);
273  }
274  bytestream2_skipu(&b, 8);
275 
276  if (bytestream2_get_bytes_left(&b) < 36) {
277  av_log(avctx, AV_LOG_ERROR, "not enough extradata (%i)\n",
279  return AVERROR_INVALIDDATA;
280  }
281 
282  size = bytestream2_get_be32u(&b);
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  v = get_vlc2(gb, table->table, table->bits, 1);
371  if (v < 0)
372  return AVERROR_INVALIDDATA;
373  if (v)
374  v = v - 1;
375  else
376  v = get_bits(gb, get_bits(gb, 3) + 1);
377 
378  if (flag) {
379  if (v >= FF_ARRAY_ELEMS(code_prefix))
380  return AVERROR_INVALIDDATA;
381 
382  v = code_prefix[v] + get_bitsz(gb, v >> 2);
383  }
384 
385  return v;
386 }
387 
389 {
390  uint32_t label = get_bits_long(gb, 32);
391  uint16_t sum = 226, checksum = get_bits(gb, 16);
392  const uint8_t *ptr = gb->buffer + 6;
393  int i;
394 
395  if (label != MKTAG('Q', 'M', 'C', 1))
396  return AVERROR_INVALIDDATA;
397 
398  for (i = 0; i < s->checksum_size - 6; i++)
399  sum += ptr[i];
400 
401  return sum != checksum;
402 }
403 
405 {
406  int ch, j, k, v, idx, band, lastval, newval, len;
407 
408  for (ch = 0; ch < s->nb_channels; ch++) {
409  for (band = 0; band < noise_bands_size[s->band_index]; band++) {
410  v = qdmc_get_vlc(gb, &vtable[0], 0);
411  if (v < 0)
412  return AVERROR_INVALIDDATA;
413 
414  if (v & 1)
415  v = v + 1;
416  else
417  v = -v;
418 
419  lastval = v / 2;
420  s->noise[ch][band][0] = lastval - 1;
421  for (j = 0; j < 15;) {
422  len = qdmc_get_vlc(gb, &vtable[1], 1);
423  if (len < 0)
424  return AVERROR_INVALIDDATA;
425  len += 1;
426 
427  v = qdmc_get_vlc(gb, &vtable[0], 0);
428  if (v < 0)
429  return AVERROR_INVALIDDATA;
430 
431  if (v & 1)
432  newval = lastval + (v + 1) / 2;
433  else
434  newval = lastval - v / 2;
435 
436  idx = j + 1;
437  if (len + idx > 16)
438  return AVERROR_INVALIDDATA;
439 
440  for (k = 1; idx <= j + len; k++, idx++)
441  s->noise[ch][band][idx] = lastval + k * (newval - lastval) / len - 1;
442 
443  lastval = newval;
444  j += len;
445  }
446  }
447  }
448 
449  return 0;
450 }
451 
452 static void add_tone(QDMCContext *s, int group, int offset, int freq, int stereo_mode, int amplitude, int phase)
453 {
454  const int index = s->nb_tones[group];
455 
456  if (index >= FF_ARRAY_ELEMS(s->tones[group])) {
457  av_log(s->avctx, AV_LOG_WARNING, "Too many tones already in buffer, ignoring tone!\n");
458  return;
459  }
460 
461  s->tones[group][index].offset = offset;
462  s->tones[group][index].freq = freq;
463  s->tones[group][index].mode = stereo_mode;
464  s->tones[group][index].amplitude = amplitude;
465  s->tones[group][index].phase = phase;
466  s->nb_tones[group]++;
467 }
468 
470 {
471  int amp, phase, stereo_mode = 0, i, group, freq, group_size, group_bits;
472  int amp2, phase2, pos2, off;
473 
474  for (group = 0; group < 5; group++) {
475  group_size = 1 << (s->frame_bits - group - 1);
476  group_bits = 4 - group;
477  pos2 = 0;
478  off = 0;
479 
480  for (i = 1; ; i = freq + 1) {
481  int v;
482 
483  v = qdmc_get_vlc(gb, &vtable[3], 1);
484  if (v < 0)
485  return AVERROR_INVALIDDATA;
486 
487  freq = i + v;
488  while (freq >= group_size - 1) {
489  freq += 2 - group_size;
490  pos2 += group_size;
491  off += 1 << group_bits;
492  }
493 
494  if (pos2 >= s->frame_size)
495  break;
496 
497  if (s->nb_channels > 1)
498  stereo_mode = get_bits(gb, 2);
499 
500  amp = qdmc_get_vlc(gb, &vtable[2], 0);
501  if (amp < 0)
502  return AVERROR_INVALIDDATA;
503  phase = get_bits(gb, 3);
504 
505  if (stereo_mode > 1) {
506  amp2 = qdmc_get_vlc(gb, &vtable[4], 0);
507  if (amp2 < 0)
508  return AVERROR_INVALIDDATA;
509  amp2 = amp - amp2;
510 
511  phase2 = qdmc_get_vlc(gb, &vtable[5], 0);
512  if (phase2 < 0)
513  return AVERROR_INVALIDDATA;
514  phase2 = phase - phase2;
515 
516  if (phase2 < 0)
517  phase2 += 8;
518  }
519 
520  if ((freq >> group_bits) + 1 < s->subframe_size) {
521  add_tone(s, group, off, freq, stereo_mode & 1, amp, phase);
522  if (stereo_mode > 1)
523  add_tone(s, group, off, freq, ~stereo_mode & 1, amp2, phase2);
524  }
525  }
526  }
527 
528  return 0;
529 }
530 
531 static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)
532 {
533  int subframe_size, i, j, k, length;
534  float scale, *noise_ptr;
535 
536  scale = 0.5 * amplitude;
537  subframe_size = s->subframe_size;
538  if (subframe_size >= node2)
539  subframe_size = node2;
540  length = (subframe_size - node1) & 0xFFFC;
541  j = node1;
542  noise_ptr = &s->noise_buffer[256 * index];
543 
544  for (i = 0; i < length; i += 4, j+= 4, noise_ptr += 4) {
545  s->noise2_buffer[j ] += scale * noise_ptr[0];
546  s->noise2_buffer[j + 1] += scale * noise_ptr[1];
547  s->noise2_buffer[j + 2] += scale * noise_ptr[2];
548  s->noise2_buffer[j + 3] += scale * noise_ptr[3];
549  }
550 
551  k = length + node1;
552  noise_ptr = s->noise_buffer + length + (index << 8);
553  for (i = length; i < subframe_size - node1; i++, k++, noise_ptr++)
554  s->noise2_buffer[k] += scale * noise_ptr[0];
555 }
556 
557 static void add_noise(QDMCContext *s, int ch, int current_subframe)
558 {
559  int i, j, aindex;
560  float amplitude;
561  float *im = &s->fft_buffer[0 + ch][s->fft_offset + s->subframe_size * current_subframe];
562  float *re = &s->fft_buffer[2 + ch][s->fft_offset + s->subframe_size * current_subframe];
563 
564  memset(s->noise2_buffer, 0, 4 * s->subframe_size);
565 
566  for (i = 0; i < noise_bands_size[s->band_index]; i++) {
567  if (qdmc_nodes[i + 21 * s->band_index] > s->subframe_size - 1)
568  break;
569 
570  aindex = s->noise[ch][i][current_subframe / 2];
571  amplitude = aindex > 0 ? amplitude_tab[aindex & 0x3F] : 0.0f;
572 
573  lin_calc(s, amplitude, qdmc_nodes[21 * s->band_index + i],
574  qdmc_nodes[21 * s->band_index + i + 2], i);
575  }
576 
577  for (j = 2; j < s->subframe_size - 1; j++) {
578  float rnd_re, rnd_im;
579 
580  s->rndval = 214013 * s->rndval + 2531011;
581  rnd_im = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
582  s->rndval = 214013 * s->rndval + 2531011;
583  rnd_re = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
584  im[j ] += rnd_im;
585  re[j ] += rnd_re;
586  im[j+1] -= rnd_im;
587  re[j+1] -= rnd_re;
588  }
589 }
590 
591 static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)
592 {
593  int j, group_bits, pos, pindex;
594  float im, re, amplitude, level, *imptr, *reptr;
595 
596  if (s->nb_channels == 1)
597  stereo_mode = 0;
598 
599  group_bits = 4 - group;
600  pos = freqs >> (4 - group);
601  amplitude = amplitude_tab[amp & 0x3F];
602  imptr = &s->fft_buffer[ stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
603  reptr = &s->fft_buffer[2 + stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
604  pindex = (phase << 6) - ((2 * (freqs >> (4 - group)) + 1) << 7);
605  for (j = 0; j < (1 << (group_bits + 1)) - 1; j++) {
606  pindex += (2 * freqs + 1) << (7 - group_bits);
607  level = amplitude * s->alt_sin[group][j];
608  im = level * sin_table[ pindex & 0x1FF];
609  re = level * sin_table[(pindex + 128) & 0x1FF];
610  imptr[0] += im;
611  imptr[1] -= im;
612  reptr[0] += re;
613  reptr[1] -= re;
614  imptr += s->subframe_size;
615  reptr += s->subframe_size;
616  if (imptr >= &s->fft_buffer[stereo_mode][2 * s->frame_size]) {
617  imptr = &s->fft_buffer[0 + stereo_mode][pos];
618  reptr = &s->fft_buffer[2 + stereo_mode][pos];
619  }
620  }
621 }
622 
623 static void add_wave0(QDMCContext *s, int offset, int freqs, int stereo_mode, int amp, int phase)
624 {
625  float level, im, re;
626  int pos;
627 
628  if (s->nb_channels == 1)
629  stereo_mode = 0;
630 
631  level = amplitude_tab[amp & 0x3F];
632  im = level * sin_table[ (phase << 6) & 0x1FF];
633  re = level * sin_table[((phase << 6) + 128) & 0x1FF];
634  pos = s->fft_offset + freqs + s->subframe_size * offset;
635  s->fft_buffer[ stereo_mode][pos ] += im;
636  s->fft_buffer[2 + stereo_mode][pos ] += re;
637  s->fft_buffer[ stereo_mode][pos + 1] -= im;
638  s->fft_buffer[2 + stereo_mode][pos + 1] -= re;
639 }
640 
641 static void add_waves(QDMCContext *s, int current_subframe)
642 {
643  int w, g;
644 
645  for (g = 0; g < 4; g++) {
646  for (w = s->cur_tone[g]; w < s->nb_tones[g]; w++) {
647  QDMCTone *t = &s->tones[g][w];
648 
649  if (current_subframe < t->offset)
650  break;
651  add_wave(s, t->offset, t->freq, g, t->mode, t->amplitude, t->phase);
652  }
653  s->cur_tone[g] = w;
654  }
655  for (w = s->cur_tone[4]; w < s->nb_tones[4]; w++) {
656  QDMCTone *t = &s->tones[4][w];
657 
658  if (current_subframe < t->offset)
659  break;
660  add_wave0(s, t->offset, t->freq, t->mode, t->amplitude, t->phase);
661  }
662  s->cur_tone[4] = w;
663 }
664 
665 static int decode_frame(QDMCContext *s, GetBitContext *gb, int16_t *out)
666 {
667  int ret, ch, i, n;
668 
669  if (skip_label(s, gb))
670  return AVERROR_INVALIDDATA;
671 
672  s->fft_offset = s->frame_size - s->fft_offset;
673  s->buffer_ptr = &s->buffer[s->nb_channels * s->buffer_offset];
674 
675  ret = read_noise_data(s, gb);
676  if (ret < 0)
677  return ret;
678 
679  ret = read_wave_data(s, gb);
680  if (ret < 0)
681  return ret;
682 
683  for (n = 0; n < 32; n++) {
684  float *r;
685 
686  for (ch = 0; ch < s->nb_channels; ch++)
687  add_noise(s, ch, n);
688 
689  add_waves(s, n);
690 
691  for (ch = 0; ch < s->nb_channels; ch++) {
692  for (i = 0; i < s->subframe_size; i++) {
693  s->cmplx[ch][i].re = s->fft_buffer[ch + 2][s->fft_offset + n * s->subframe_size + i];
694  s->cmplx[ch][i].im = s->fft_buffer[ch + 0][s->fft_offset + n * s->subframe_size + i];
695  s->cmplx[ch][s->subframe_size + i].re = 0;
696  s->cmplx[ch][s->subframe_size + i].im = 0;
697  }
698  }
699 
700  for (ch = 0; ch < s->nb_channels; ch++) {
701  s->fft_ctx.fft_permute(&s->fft_ctx, s->cmplx[ch]);
702  s->fft_ctx.fft_calc(&s->fft_ctx, s->cmplx[ch]);
703  }
704 
705  r = &s->buffer_ptr[s->nb_channels * n * s->subframe_size];
706  for (i = 0; i < 2 * s->subframe_size; i++) {
707  for (ch = 0; ch < s->nb_channels; ch++) {
708  *r++ += s->cmplx[ch][i].re;
709  }
710  }
711 
712  r = &s->buffer_ptr[n * s->subframe_size * s->nb_channels];
713  for (i = 0; i < s->nb_channels * s->subframe_size; i++) {
714  out[i] = av_clipf(r[i], INT16_MIN, INT16_MAX);
715  }
716  out += s->subframe_size * s->nb_channels;
717 
718  for (ch = 0; ch < s->nb_channels; ch++) {
719  memset(s->fft_buffer[ch+0] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
720  memset(s->fft_buffer[ch+2] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
721  }
722  memset(s->buffer + s->nb_channels * (n * s->subframe_size + s->frame_size + s->buffer_offset), 0, 4 * s->subframe_size * s->nb_channels);
723  }
724 
725  s->buffer_offset += s->frame_size;
726  if (s->buffer_offset >= 32768 - s->frame_size) {
727  memcpy(s->buffer, &s->buffer[s->nb_channels * s->buffer_offset], 4 * s->frame_size * s->nb_channels);
728  s->buffer_offset = 0;
729  }
730 
731  return 0;
732 }
733 
734 static av_cold void qdmc_flush(AVCodecContext *avctx)
735 {
736  QDMCContext *s = avctx->priv_data;
737 
738  memset(s->buffer, 0, sizeof(s->buffer));
739  memset(s->fft_buffer, 0, sizeof(s->fft_buffer));
740  s->fft_offset = 0;
741  s->buffer_offset = 0;
742 }
743 
744 static int qdmc_decode_frame(AVCodecContext *avctx, void *data,
745  int *got_frame_ptr, AVPacket *avpkt)
746 {
747  QDMCContext *s = avctx->priv_data;
748  AVFrame *frame = data;
749  GetBitContext gb;
750  int ret;
751 
752  if (!avpkt->data)
753  return 0;
754  if (avpkt->size < s->checksum_size)
755  return AVERROR_INVALIDDATA;
756 
757  s->avctx = avctx;
758  frame->nb_samples = s->frame_size;
759  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
760  return ret;
761 
762  if ((ret = init_get_bits8(&gb, avpkt->data, s->checksum_size)) < 0)
763  return ret;
764 
765  memset(s->nb_tones, 0, sizeof(s->nb_tones));
766  memset(s->cur_tone, 0, sizeof(s->cur_tone));
767 
768  ret = decode_frame(s, &gb, (int16_t *)frame->data[0]);
769  if (ret >= 0) {
770  *got_frame_ptr = 1;
771  return s->checksum_size;
772  }
773  qdmc_flush(avctx);
774  return ret;
775 }
776 
778  .name = "qdmc",
779  .long_name = NULL_IF_CONFIG_SMALL("QDesign Music Codec 1"),
780  .type = AVMEDIA_TYPE_AUDIO,
781  .id = AV_CODEC_ID_QDMC,
782  .priv_data_size = sizeof(QDMCContext),
784  .close = qdmc_decode_close,
786  .flush = qdmc_flush,
787  .capabilities = AV_CODEC_CAP_DR1,
788 };
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:226
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
static void flush(AVCodecContext *avctx)
AVCodec ff_qdmc_decoder
Definition: qdmc.c:777
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:381
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1590
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
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:1453
const char * b
Definition: vf_curves.c:116
const uint8_t * buffer
Definition: get_bits.h:62
int av_log2(unsigned v)
Definition: intmath.c:26
void(* fft_permute)(struct FFTContext *s, FFTComplex *z)
Do the permutation needed BEFORE calling fft_calc().
Definition: fft.h:101
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:3441
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
static float sin_table[512]
Definition: qdmc.c:73
static av_cold int qdmc_decode_close(AVCodecContext *avctx)
Definition: qdmc.c:357
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2204
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:1641
static AVFrame * frame
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:112
uint8_t * data
Definition: avcodec.h:1452
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:101
static av_cold void qdmc_flush(AVCodecContext *avctx)
Definition: qdmc.c:734
#define AVOnce
Definition: thread.h:159
#define av_log(a,...)
static const uint16_t table[]
Definition: prosumer.c:203
static const uint8_t phase_diff_bits[]
Definition: qdmc.c:184
#define U(x)
Definition: vp56_arith.h:37
#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 AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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:115
const char * name
Name of the codec implementation.
Definition: avcodec.h:3448
static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)
Definition: qdmc.c:591
float alt_sin[5][31]
Definition: qdmc.c:61
static const uint8_t freq_diff_bits[]
Definition: qdmc.c:151
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
Definition: vlc.h:26
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2247
int subframe_size
Definition: qdmc.c:51
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:665
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
#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:762
int n
Definition: avisynth_c.h:684
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:557
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:452
static int skip_label(QDMCContext *s, GetBitContext *gb)
Definition: qdmc.c:388
#define AV_ONCE_INIT
Definition: thread.h:160
Libavcodec external API header.
int sample_rate
samples per second
Definition: avcodec.h:2196
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:650
static void make_noises(QDMCContext *s)
Definition: qdmc.c:230
uint8_t offset
Definition: qdmc.c:40
main external API structure.
Definition: avcodec.h:1540
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1919
static int read_noise_data(QDMCContext *s, GetBitContext *gb)
Definition: qdmc.c:404
int extradata_size
Definition: avcodec.h:1642
#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:531
float im
Definition: fft.c:82
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:531
float noise2_buffer[4096 *2]
Definition: qdmc.c:63
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
uint8_t mode
Definition: qdmc.c:38
static void add_waves(QDMCContext *s, int current_subframe)
Definition: qdmc.c:641
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:240
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:623
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:576
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:1567
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:2197
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:1429
int cur_tone[5]
Definition: qdmc.c:60
static int read_wave_data(QDMCContext *s, GetBitContext *gb)
Definition: qdmc.c:469
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:292
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:968
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:412
GLuint buffer
Definition: opengl_enc.c:102
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_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),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){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) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;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)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8: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);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=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){intplanes=out->planar?out->ch_count:1;unsignedm=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){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
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:744