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 
30 #include "avcodec.h"
31 #include "bytestream.h"
32 #include "get_bits.h"
33 #include "internal.h"
34 #include "fft.h"
35 
36 typedef struct QDMCTone {
40  int16_t freq;
41  int16_t amplitude;
42 } QDMCTone;
43 
44 typedef struct QDMCContext {
46 
55 
56  uint8_t noise[2][19][17];
57  QDMCTone tones[5][8192];
58  int nb_tones[5];
59  int cur_tone[5];
60  float alt_sin[5][31];
61  float fft_buffer[4][8192 * 2];
62  float noise2_buffer[4096 * 2];
63  float noise_buffer[4096 * 2];
64  float buffer[2 * 32768];
65  float *buffer_ptr;
66  int rndval;
67 
70 } QDMCContext;
71 
72 static float sin_table[512];
73 static VLC vtable[6];
74 
75 static const unsigned code_prefix[] = {
76  0x0, 0x1, 0x2, 0x3, 0x4, 0x6, 0x8, 0xA,
77  0xC, 0x10, 0x14, 0x18, 0x1C, 0x24, 0x2C, 0x34,
78  0x3C, 0x4C, 0x5C, 0x6C, 0x7C, 0x9C, 0xBC, 0xDC,
79  0xFC, 0x13C, 0x17C, 0x1BC, 0x1FC, 0x27C, 0x2FC, 0x37C,
80  0x3FC, 0x4FC, 0x5FC, 0x6FC, 0x7FC, 0x9FC, 0xBFC, 0xDFC,
81  0xFFC, 0x13FC, 0x17FC, 0x1BFC, 0x1FFC, 0x27FC, 0x2FFC, 0x37FC,
82  0x3FFC, 0x4FFC, 0x5FFC, 0x6FFC, 0x7FFC, 0x9FFC, 0xBFFC, 0xDFFC,
83  0xFFFC, 0x13FFC, 0x17FFC, 0x1BFFC, 0x1FFFC, 0x27FFC, 0x2FFFC, 0x37FFC,
84  0x3FFFC
85 };
86 
87 static const float amplitude_tab[64] = {
88  1.18750000f, 1.68359380f, 2.37500000f, 3.36718750f, 4.75000000f,
89  6.73437500f, 9.50000000f, 13.4687500f, 19.0000000f, 26.9375000f,
90  38.0000000f, 53.8750000f, 76.0000000f, 107.750000f, 152.000000f,
91  215.500000f, 304.000000f, 431.000000f, 608.000000f, 862.000000f,
92  1216.00000f, 1724.00000f, 2432.00000f, 3448.00000f, 4864.00000f,
93  6896.00000f, 9728.00000f, 13792.0000f, 19456.0000f, 27584.0000f,
94  38912.0000f, 55168.0000f, 77824.0000f, 110336.000f, 155648.000f,
95  220672.000f, 311296.000f, 441344.000f, 622592.000f, 882688.000f,
96  1245184.00f, 1765376.00f, 2490368.00f, 3530752.00f, 4980736.00f,
97  7061504.00f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
98 };
99 
100 static const uint16_t qdmc_nodes[112] = {
101  0, 1, 2, 4, 6, 8, 12, 16, 24, 32, 48, 56, 64,
102  80, 96, 120, 144, 176, 208, 240, 256,
103  0, 2, 4, 8, 16, 24, 32, 48, 56, 64, 80, 104,
104  128, 160, 208, 256, 0, 0, 0, 0, 0,
105  0, 2, 4, 8, 16, 32, 48, 64, 80, 112, 160, 208,
106  256, 0, 0, 0, 0, 0, 0, 0, 0,
107  0, 4, 8, 16, 32, 48, 64, 96, 144, 208, 256,
108  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
109  0, 4, 16, 32, 64, 256, 0, 0, 0, 0, 0, 0, 0, 0,
110  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
111 };
112 
113 static const uint8_t noise_bands_size[] = {
114  19, 14, 11, 9, 4, 2, 0
115 };
116 
117 static const uint8_t noise_bands_selector[] = {
118  4, 3, 2, 1, 0, 0, 0,
119 };
120 
121 static const uint8_t noise_value_bits[] = {
122  12, 7, 9, 7, 10, 9, 11, 9, 9, 2, 9, 9, 9, 9,
123  9, 3, 9, 10, 10, 12, 2, 3, 3, 5, 5, 6, 7,
124 };
125 
126 static const uint8_t noise_value_symbols[] = {
127  0, 10, 11, 12, 13, 14, 15, 16, 18, 1, 20, 22, 24,
128  26, 28, 2, 30, 32, 34, 36, 3, 4, 5, 6, 7, 8, 9,
129 };
130 
131 static const uint16_t noise_value_codes[] = {
132  0xC7A, 0x002, 0x0FA, 0x03A, 0x35A, 0x1C2, 0x07A, 0x1FA,
133  0x17A, 0x000, 0x0DA, 0x142, 0x0C2, 0x042, 0x1DA, 0x001,
134  0x05A, 0x15A, 0x27A, 0x47A, 0x003, 0x005, 0x006, 0x012,
135  0x00A, 0x022, 0x01A,
136 };
137 
139  10, 8, 5, 1, 2, 4, 4, 4, 6, 7, 9, 10,
140 };
141 
143  0, 13, 17, 1, 2, 3, 4, 5, 6, 7, 8, 9,
144 };
145 
146 static const uint16_t noise_segment_length_codes[] = {
147  0x30B, 0x8B, 0x1B, 0x0, 0x1, 0x3, 0x7, 0xF, 0x2b, 0x4B, 0xB, 0x10B,
148 };
149 
150 static const uint8_t freq_diff_bits[] = {
151  18, 2, 4, 4, 5, 4, 4, 5, 5, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 6,
152  7, 6, 6, 6, 7, 7, 7, 7, 7, 8, 9, 9, 8, 9, 11, 11, 12, 12, 13, 12,
153  14, 15, 18, 16, 17,
154 };
155 
156 static const uint32_t freq_diff_codes[] = {
157  0x2AD46, 0x1, 0x0, 0x3, 0xC, 0xA, 0x7, 0x18, 0x12, 0xE, 0x4, 0x16,
158  0xF, 0x1C, 0x8, 0x22, 0x26, 0x2, 0x3B, 0x34, 0x74, 0x1F, 0x14, 0x2B,
159  0x1B, 0x3F, 0x28, 0x54, 0x6, 0x4B, 0xB, 0x68, 0xE8, 0x46, 0xC6, 0x1E8,
160  0x146, 0x346, 0x546, 0x746, 0x1D46, 0xF46, 0xD46, 0x6D46, 0xAD46, 0x2D46,
161  0x1AD46,
162 };
163 
164 static const uint8_t amplitude_bits[] = {
165  13, 7, 8, 9, 10, 10, 10, 10, 10, 9, 8, 7, 6,
166  5, 4, 3, 3, 2, 3, 3, 4, 5, 7, 8, 9, 11, 12, 13,
167 };
168 
169 static const uint16_t amplitude_codes[] = {
170  0x1EC6, 0x6, 0xC2, 0x142, 0x242, 0x246, 0xC6, 0x46, 0x42, 0x146, 0xA2,
171  0x62, 0x26, 0x16, 0xE, 0x5, 0x4, 0x3, 0x0, 0x1, 0xA, 0x12, 0x2, 0x22,
172  0x1C6, 0x2C6, 0x6C6, 0xEC6,
173 };
174 
175 static const uint8_t amplitude_diff_bits[] = {
176  8, 2, 1, 3, 4, 5, 6, 7, 8,
177 };
178 
179 static const uint8_t amplitude_diff_codes[] = {
180  0xFE, 0x0, 0x1, 0x2, 0x6, 0xE, 0x1E, 0x3E, 0x7E,
181 };
182 
183 static const uint8_t phase_diff_bits[] = {
184  6, 2, 2, 4, 4, 6, 5, 4, 2,
185 };
186 
187 static const uint8_t phase_diff_codes[] = {
188  0x35, 0x2, 0x0, 0x1, 0xD, 0x15, 0x5, 0x9, 0x3,
189 };
190 
191 #define INIT_VLC_STATIC_LE(vlc, nb_bits, nb_codes, \
192  bits, bits_wrap, bits_size, \
193  codes, codes_wrap, codes_size, \
194  symbols, symbols_wrap, symbols_size, \
195  static_size) \
196  do { \
197  static VLC_TYPE table[static_size][2]; \
198  (vlc)->table = table; \
199  (vlc)->table_allocated = static_size; \
200  ff_init_vlc_sparse(vlc, nb_bits, nb_codes, \
201  bits, bits_wrap, bits_size, \
202  codes, codes_wrap, codes_size, \
203  symbols, symbols_wrap, symbols_size, \
204  INIT_VLC_LE | INIT_VLC_USE_NEW_STATIC); \
205  } while (0)
206 
208 {
209  int i;
210 
212  noise_value_bits, 1, 1, noise_value_codes, 2, 2, noise_value_symbols, 1, 1, 4096);
215  noise_segment_length_symbols, 1, 1, 1024);
217  amplitude_bits, 1, 1, amplitude_codes, 2, 2, NULL, 0, 0, 8192);
219  freq_diff_bits, 1, 1, freq_diff_codes, 4, 4, NULL, 0, 0, 262144);
221  amplitude_diff_bits, 1, 1, amplitude_diff_codes, 1, 1, NULL, 0, 0, 256);
223  phase_diff_bits, 1, 1, phase_diff_codes, 1, 1, NULL, 0, 0, 64);
224 
225  for (i = 0; i < 512; i++)
226  sin_table[i] = sin(2.0f * i * M_PI * 0.001953125f);
227 }
228 
229 static void make_noises(QDMCContext *s)
230 {
231  int i, j, n0, n1, n2, diff;
232  float *nptr;
233 
234  for (j = 0; j < noise_bands_size[s->band_index]; j++) {
235  n0 = qdmc_nodes[j + 21 * s->band_index ];
236  n1 = qdmc_nodes[j + 21 * s->band_index + 1];
237  n2 = qdmc_nodes[j + 21 * s->band_index + 2];
238  nptr = s->noise_buffer + 256 * j;
239 
240  for (i = 0; i + n0 < n1; i++, nptr++)
241  nptr[0] = i / (float)(n1 - n0);
242 
243  diff = n2 - n1;
244  nptr = s->noise_buffer + (j << 8) + n1 - n0;
245 
246  for (i = n1; i < n2; i++, nptr++, diff--)
247  nptr[0] = diff / (float)(n2 - n1);
248  }
249 }
250 
252 {
253  QDMCContext *s = avctx->priv_data;
254  int fft_size, fft_order, size, g, j, x;
256 
257  if (!avctx->extradata || (avctx->extradata_size < 48)) {
258  av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n");
259  return AVERROR_INVALIDDATA;
260  }
261 
262  bytestream2_init(&b, avctx->extradata, avctx->extradata_size);
263 
264  while (bytestream2_get_bytes_left(&b) > 8) {
265  if (bytestream2_peek_be64(&b) == (((uint64_t)MKBETAG('f','r','m','a') << 32) |
266  (uint64_t)MKBETAG('Q','D','M','C')))
267  break;
268  bytestream2_skipu(&b, 1);
269  }
270  bytestream2_skipu(&b, 8);
271 
272  if (bytestream2_get_bytes_left(&b) < 36) {
273  av_log(avctx, AV_LOG_ERROR, "not enough extradata (%i)\n",
275  return AVERROR_INVALIDDATA;
276  }
277 
278  size = bytestream2_get_be32u(&b);
279  if (size > bytestream2_get_bytes_left(&b)) {
280  av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n",
281  bytestream2_get_bytes_left(&b), size);
282  return AVERROR_INVALIDDATA;
283  }
284 
285  if (bytestream2_get_be32u(&b) != MKBETAG('Q','D','C','A')) {
286  av_log(avctx, AV_LOG_ERROR, "invalid extradata, expecting QDCA\n");
287  return AVERROR_INVALIDDATA;
288  }
289  bytestream2_skipu(&b, 4);
290 
291  avctx->channels = s->nb_channels = bytestream2_get_be32u(&b);
292  if (s->nb_channels <= 0 || s->nb_channels > 2) {
293  av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
294  return AVERROR_INVALIDDATA;
295  }
296  avctx->channel_layout = avctx->channels == 2 ? AV_CH_LAYOUT_STEREO :
298 
299  avctx->sample_rate = bytestream2_get_be32u(&b);
300  avctx->bit_rate = bytestream2_get_be32u(&b);
301  bytestream2_skipu(&b, 4);
302  fft_size = bytestream2_get_be32u(&b);
303  fft_order = av_log2(fft_size) + 1;
304  s->checksum_size = bytestream2_get_be32u(&b);
305  if (s->checksum_size >= 1U << 28) {
306  av_log(avctx, AV_LOG_ERROR, "data block size too large (%u)\n", s->checksum_size);
307  return AVERROR_INVALIDDATA;
308  }
309 
310  if (avctx->sample_rate >= 32000) {
311  x = 28000;
312  s->frame_bits = 13;
313  } else if (avctx->sample_rate >= 16000) {
314  x = 20000;
315  s->frame_bits = 12;
316  } else {
317  x = 16000;
318  s->frame_bits = 11;
319  }
320  s->frame_size = 1 << s->frame_bits;
321  s->subframe_size = s->frame_size >> 5;
322 
323  if (avctx->channels == 2)
324  x = 3 * x / 2;
325  s->band_index = noise_bands_selector[FFMIN(6, llrint(floor(avctx->bit_rate * 3.0 / (double)x + 0.5)))];
326 
327  if ((fft_order < 7) || (fft_order > 9)) {
328  avpriv_request_sample(avctx, "Unknown FFT order %d", fft_order);
329  return AVERROR_PATCHWELCOME;
330  }
331 
332  if (fft_size != (1 << (fft_order - 1))) {
333  av_log(avctx, AV_LOG_ERROR, "FFT size %d not power of 2.\n", fft_size);
334  return AVERROR_INVALIDDATA;
335  }
336 
337  ff_fft_init(&s->fft_ctx, fft_order, 1);
338 
339  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
340 
341  for (g = 5; g > 0; g--) {
342  for (j = 0; j < (1 << g) - 1; j++)
343  s->alt_sin[5-g][j] = sin_table[(((j+1) << (8 - g)) & 0x1FF)];
344  }
345 
346  make_noises(s);
347 
348  return 0;
349 }
350 
352 {
353  QDMCContext *s = avctx->priv_data;
354 
355  ff_fft_end(&s->fft_ctx);
356 
357  return 0;
358 }
359 
360 static int qdmc_get_vlc(GetBitContext *gb, VLC *table, int flag)
361 {
362  int v;
363 
364  v = get_vlc2(gb, table->table, table->bits, 1);
365  if (v < 0)
366  return AVERROR_INVALIDDATA;
367  if (v)
368  v = v - 1;
369  else
370  v = get_bits(gb, get_bits(gb, 3) + 1);
371 
372  if (flag) {
373  if (v >= FF_ARRAY_ELEMS(code_prefix))
374  return AVERROR_INVALIDDATA;
375 
376  v = code_prefix[v] + get_bitsz(gb, v >> 2);
377  }
378 
379  return v;
380 }
381 
383 {
384  uint32_t label = get_bits_long(gb, 32);
385  uint16_t sum = 226, checksum = get_bits(gb, 16);
386  const uint8_t *ptr = gb->buffer + 6;
387  int i;
388 
389  if (label != MKTAG('Q', 'M', 'C', 1))
390  return AVERROR_INVALIDDATA;
391 
392  for (i = 0; i < s->checksum_size - 6; i++)
393  sum += ptr[i];
394 
395  return sum != checksum;
396 }
397 
399 {
400  int ch, j, k, v, idx, band, lastval, newval, len;
401 
402  for (ch = 0; ch < s->nb_channels; ch++) {
403  for (band = 0; band < noise_bands_size[s->band_index]; band++) {
404  v = qdmc_get_vlc(gb, &vtable[0], 0);
405  if (v < 0)
406  return AVERROR_INVALIDDATA;
407 
408  if (v & 1)
409  v = v + 1;
410  else
411  v = -v;
412 
413  lastval = v / 2;
414  s->noise[ch][band][0] = lastval - 1;
415  for (j = 0; j < 15;) {
416  len = qdmc_get_vlc(gb, &vtable[1], 1);
417  if (len < 0)
418  return AVERROR_INVALIDDATA;
419  len += 1;
420 
421  v = qdmc_get_vlc(gb, &vtable[0], 0);
422  if (v < 0)
423  return AVERROR_INVALIDDATA;
424 
425  if (v & 1)
426  newval = lastval + (v + 1) / 2;
427  else
428  newval = lastval - v / 2;
429 
430  idx = j + 1;
431  if (len + idx > 16)
432  return AVERROR_INVALIDDATA;
433 
434  for (k = 1; idx <= j + len; k++, idx++)
435  s->noise[ch][band][idx] = lastval + k * (newval - lastval) / len - 1;
436 
437  lastval = newval;
438  j += len;
439  }
440  }
441  }
442 
443  return 0;
444 }
445 
446 static void add_tone(QDMCContext *s, int group, int offset, int freq, int stereo_mode, int amplitude, int phase)
447 {
448  const int index = s->nb_tones[group];
449 
450  if (index >= FF_ARRAY_ELEMS(s->tones[group])) {
451  av_log(s->avctx, AV_LOG_WARNING, "Too many tones already in buffer, ignoring tone!\n");
452  return;
453  }
454 
455  s->tones[group][index].offset = offset;
456  s->tones[group][index].freq = freq;
457  s->tones[group][index].mode = stereo_mode;
458  s->tones[group][index].amplitude = amplitude;
459  s->tones[group][index].phase = phase;
460  s->nb_tones[group]++;
461 }
462 
464 {
465  int amp, phase, stereo_mode = 0, i, group, freq, group_size, group_bits;
466  int amp2, phase2, pos2, off;
467 
468  for (group = 0; group < 5; group++) {
469  group_size = 1 << (s->frame_bits - group - 1);
470  group_bits = 4 - group;
471  pos2 = 0;
472  off = 0;
473 
474  for (i = 1; ; i = freq + 1) {
475  int v;
476 
477  v = qdmc_get_vlc(gb, &vtable[3], 1);
478  if (v < 0)
479  return AVERROR_INVALIDDATA;
480 
481  freq = i + v;
482  while (freq >= group_size - 1) {
483  freq += 2 - group_size;
484  pos2 += group_size;
485  off += 1 << group_bits;
486  }
487 
488  if (pos2 >= s->frame_size)
489  break;
490 
491  if (s->nb_channels > 1)
492  stereo_mode = get_bits(gb, 2);
493 
494  amp = qdmc_get_vlc(gb, &vtable[2], 0);
495  if (amp < 0)
496  return AVERROR_INVALIDDATA;
497  phase = get_bits(gb, 3);
498 
499  if (stereo_mode > 1) {
500  amp2 = qdmc_get_vlc(gb, &vtable[4], 0);
501  if (amp2 < 0)
502  return AVERROR_INVALIDDATA;
503  amp2 = amp - amp2;
504 
505  phase2 = qdmc_get_vlc(gb, &vtable[5], 0);
506  if (phase2 < 0)
507  return AVERROR_INVALIDDATA;
508  phase2 = phase - phase2;
509 
510  if (phase2 < 0)
511  phase2 += 8;
512  }
513 
514  if ((freq >> group_bits) + 1 < s->subframe_size) {
515  add_tone(s, group, off, freq, stereo_mode & 1, amp, phase);
516  if (stereo_mode > 1)
517  add_tone(s, group, off, freq, ~stereo_mode & 1, amp2, phase2);
518  }
519  }
520  }
521 
522  return 0;
523 }
524 
525 static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)
526 {
527  int subframe_size, i, j, k, length;
528  float scale, *noise_ptr;
529 
530  scale = 0.5 * amplitude;
531  subframe_size = s->subframe_size;
532  if (subframe_size >= node2)
533  subframe_size = node2;
534  length = (subframe_size - node1) & 0xFFFC;
535  j = node1;
536  noise_ptr = &s->noise_buffer[256 * index];
537 
538  for (i = 0; i < length; i += 4, j+= 4, noise_ptr += 4) {
539  s->noise2_buffer[j ] += scale * noise_ptr[0];
540  s->noise2_buffer[j + 1] += scale * noise_ptr[1];
541  s->noise2_buffer[j + 2] += scale * noise_ptr[2];
542  s->noise2_buffer[j + 3] += scale * noise_ptr[3];
543  }
544 
545  k = length + node1;
546  noise_ptr = s->noise_buffer + length + (index << 8);
547  for (i = length; i < subframe_size - node1; i++, k++, noise_ptr++)
548  s->noise2_buffer[k] += scale * noise_ptr[0];
549 }
550 
551 static void add_noise(QDMCContext *s, int ch, int current_subframe)
552 {
553  int i, j, aindex;
554  float amplitude;
555  float *im = &s->fft_buffer[0 + ch][s->fft_offset + s->subframe_size * current_subframe];
556  float *re = &s->fft_buffer[2 + ch][s->fft_offset + s->subframe_size * current_subframe];
557 
558  memset(s->noise2_buffer, 0, 4 * s->subframe_size);
559 
560  for (i = 0; i < noise_bands_size[s->band_index]; i++) {
561  if (qdmc_nodes[i + 21 * s->band_index] > s->subframe_size - 1)
562  break;
563 
564  aindex = s->noise[ch][i][current_subframe / 2];
565  amplitude = aindex > 0 ? amplitude_tab[aindex & 0x3F] : 0.0f;
566 
567  lin_calc(s, amplitude, qdmc_nodes[21 * s->band_index + i],
568  qdmc_nodes[21 * s->band_index + i + 2], i);
569  }
570 
571  for (j = 2; j < s->subframe_size - 1; j++) {
572  float rnd_re, rnd_im;
573 
574  s->rndval = 214013 * s->rndval + 2531011;
575  rnd_im = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
576  s->rndval = 214013 * s->rndval + 2531011;
577  rnd_re = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
578  im[j ] += rnd_im;
579  re[j ] += rnd_re;
580  im[j+1] -= rnd_im;
581  re[j+1] -= rnd_re;
582  }
583 }
584 
585 static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)
586 {
587  int j, group_bits, pos, pindex;
588  float im, re, amplitude, level, *imptr, *reptr;
589 
590  if (s->nb_channels == 1)
591  stereo_mode = 0;
592 
593  group_bits = 4 - group;
594  pos = freqs >> (4 - group);
595  amplitude = amplitude_tab[amp & 0x3F];
596  imptr = &s->fft_buffer[ stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
597  reptr = &s->fft_buffer[2 + stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
598  pindex = (phase << 6) - ((2 * (freqs >> (4 - group)) + 1) << 7);
599  for (j = 0; j < (1 << (group_bits + 1)) - 1; j++) {
600  pindex += (2 * freqs + 1) << (7 - group_bits);
601  level = amplitude * s->alt_sin[group][j];
602  im = level * sin_table[ pindex & 0x1FF];
603  re = level * sin_table[(pindex + 128) & 0x1FF];
604  imptr[0] += im;
605  imptr[1] -= im;
606  reptr[0] += re;
607  reptr[1] -= re;
608  imptr += s->subframe_size;
609  reptr += s->subframe_size;
610  if (imptr >= &s->fft_buffer[stereo_mode][2 * s->frame_size]) {
611  imptr = &s->fft_buffer[0 + stereo_mode][pos];
612  reptr = &s->fft_buffer[2 + stereo_mode][pos];
613  }
614  }
615 }
616 
617 static void add_wave0(QDMCContext *s, int offset, int freqs, int stereo_mode, int amp, int phase)
618 {
619  float level, im, re;
620  int pos;
621 
622  if (s->nb_channels == 1)
623  stereo_mode = 0;
624 
625  level = amplitude_tab[amp & 0x3F];
626  im = level * sin_table[ (phase << 6) & 0x1FF];
627  re = level * sin_table[((phase << 6) + 128) & 0x1FF];
628  pos = s->fft_offset + freqs + s->subframe_size * offset;
629  s->fft_buffer[ stereo_mode][pos ] += im;
630  s->fft_buffer[2 + stereo_mode][pos ] += re;
631  s->fft_buffer[ stereo_mode][pos + 1] -= im;
632  s->fft_buffer[2 + stereo_mode][pos + 1] -= re;
633 }
634 
635 static void add_waves(QDMCContext *s, int current_subframe)
636 {
637  int w, g;
638 
639  for (g = 0; g < 4; g++) {
640  for (w = s->cur_tone[g]; w < s->nb_tones[g]; w++) {
641  QDMCTone *t = &s->tones[g][w];
642 
643  if (current_subframe < t->offset)
644  break;
645  add_wave(s, t->offset, t->freq, g, t->mode, t->amplitude, t->phase);
646  }
647  s->cur_tone[g] = w;
648  }
649  for (w = s->cur_tone[4]; w < s->nb_tones[4]; w++) {
650  QDMCTone *t = &s->tones[4][w];
651 
652  if (current_subframe < t->offset)
653  break;
654  add_wave0(s, t->offset, t->freq, t->mode, t->amplitude, t->phase);
655  }
656  s->cur_tone[4] = w;
657 }
658 
659 static int decode_frame(QDMCContext *s, GetBitContext *gb, int16_t *out)
660 {
661  int ret, ch, i, n;
662 
663  if (skip_label(s, gb))
664  return AVERROR_INVALIDDATA;
665 
666  s->fft_offset = s->frame_size - s->fft_offset;
667  s->buffer_ptr = &s->buffer[s->nb_channels * s->buffer_offset];
668 
669  ret = read_noise_data(s, gb);
670  if (ret < 0)
671  return ret;
672 
673  ret = read_wave_data(s, gb);
674  if (ret < 0)
675  return ret;
676 
677  for (n = 0; n < 32; n++) {
678  float *r;
679 
680  for (ch = 0; ch < s->nb_channels; ch++)
681  add_noise(s, ch, n);
682 
683  add_waves(s, n);
684 
685  for (ch = 0; ch < s->nb_channels; ch++) {
686  for (i = 0; i < s->subframe_size; i++) {
687  s->cmplx[ch][i].re = s->fft_buffer[ch + 2][s->fft_offset + n * s->subframe_size + i];
688  s->cmplx[ch][i].im = s->fft_buffer[ch + 0][s->fft_offset + n * s->subframe_size + i];
689  s->cmplx[ch][s->subframe_size + i].re = 0;
690  s->cmplx[ch][s->subframe_size + i].im = 0;
691  }
692  }
693 
694  for (ch = 0; ch < s->nb_channels; ch++) {
695  s->fft_ctx.fft_permute(&s->fft_ctx, s->cmplx[ch]);
696  s->fft_ctx.fft_calc(&s->fft_ctx, s->cmplx[ch]);
697  }
698 
699  r = &s->buffer_ptr[s->nb_channels * n * s->subframe_size];
700  for (i = 0; i < 2 * s->subframe_size; i++) {
701  for (ch = 0; ch < s->nb_channels; ch++) {
702  *r++ += s->cmplx[ch][i].re;
703  }
704  }
705 
706  r = &s->buffer_ptr[n * s->subframe_size * s->nb_channels];
707  for (i = 0; i < s->nb_channels * s->subframe_size; i++) {
708  out[i] = av_clipf(r[i], INT16_MIN, INT16_MAX);
709  }
710  out += s->subframe_size * s->nb_channels;
711 
712  for (ch = 0; ch < s->nb_channels; ch++) {
713  memset(s->fft_buffer[ch+0] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
714  memset(s->fft_buffer[ch+2] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
715  }
716  memset(s->buffer + s->nb_channels * (n * s->subframe_size + s->frame_size + s->buffer_offset), 0, 4 * s->subframe_size * s->nb_channels);
717  }
718 
719  s->buffer_offset += s->frame_size;
720  if (s->buffer_offset >= 32768 - s->frame_size) {
721  memcpy(s->buffer, &s->buffer[s->nb_channels * s->buffer_offset], 4 * s->frame_size * s->nb_channels);
722  s->buffer_offset = 0;
723  }
724 
725  return 0;
726 }
727 
728 static av_cold void qdmc_flush(AVCodecContext *avctx)
729 {
730  QDMCContext *s = avctx->priv_data;
731 
732  memset(s->buffer, 0, sizeof(s->buffer));
733  memset(s->fft_buffer, 0, sizeof(s->fft_buffer));
734  s->fft_offset = 0;
735  s->buffer_offset = 0;
736 }
737 
738 static int qdmc_decode_frame(AVCodecContext *avctx, void *data,
739  int *got_frame_ptr, AVPacket *avpkt)
740 {
741  QDMCContext *s = avctx->priv_data;
742  AVFrame *frame = data;
743  GetBitContext gb;
744  int ret;
745 
746  if (!avpkt->data)
747  return 0;
748  if (avpkt->size < s->checksum_size)
749  return AVERROR_INVALIDDATA;
750 
751  s->avctx = avctx;
752  frame->nb_samples = s->frame_size;
753  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
754  return ret;
755 
756  if ((ret = init_get_bits8(&gb, avpkt->data, s->checksum_size)) < 0)
757  return ret;
758 
759  memset(s->nb_tones, 0, sizeof(s->nb_tones));
760  memset(s->cur_tone, 0, sizeof(s->cur_tone));
761 
762  ret = decode_frame(s, &gb, (int16_t *)frame->data[0]);
763  if (ret >= 0) {
764  *got_frame_ptr = 1;
765  return s->checksum_size;
766  }
767  qdmc_flush(avctx);
768  return ret;
769 }
770 
772  .name = "qdmc",
773  .long_name = NULL_IF_CONFIG_SMALL("QDesign Music Codec 1"),
774  .type = AVMEDIA_TYPE_AUDIO,
775  .id = AV_CODEC_ID_QDMC,
776  .priv_data_size = sizeof(QDMCContext),
778  .init_static_data = qdmc_init_static_data,
779  .close = qdmc_decode_close,
781  .flush = qdmc_flush,
782  .capabilities = AV_CODEC_CAP_DR1,
783 };
static const uint32_t freq_diff_codes[]
Definition: qdmc.c:156
static const uint16_t qdmc_nodes[112]
Definition: qdmc.c:100
static const uint16_t amplitude_codes[]
Definition: qdmc.c:169
#define NULL
Definition: coverity.c:32
static int qdmc_get_vlc(GetBitContext *gb, VLC *table, int flag)
Definition: qdmc.c:360
const char * s
Definition: avisynth_c.h:768
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define flag(name)
Definition: cbs_h2645.c:345
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
static void flush(AVCodecContext *avctx)
AVCodec ff_qdmc_decoder
Definition: qdmc.c:771
float buffer[2 *32768]
Definition: qdmc.c:64
float re
Definition: fft.c:82
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:261
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1538
const char * g
Definition: vf_curves.c:112
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static const uint8_t noise_bands_size[]
Definition: qdmc.c:113
QDMCTone tones[5][8192]
Definition: qdmc.c:57
static VLC vtable[6]
Definition: qdmc.c:73
static const uint16_t noise_segment_length_codes[]
Definition: qdmc.c:146
int rndval
Definition: qdmc.c:66
int size
Definition: avcodec.h:1401
const char * b
Definition: vf_curves.c:113
const uint8_t * buffer
Definition: get_bits.h:56
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:58
FFTComplex cmplx[2][512]
Definition: qdmc.c:68
#define AV_CH_LAYOUT_STEREO
Definition: qdmc.c:36
AVCodec.
Definition: avcodec.h:3351
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:72
static av_cold int qdmc_decode_close(AVCodecContext *avctx)
Definition: qdmc.c:351
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:2151
uint8_t
#define av_cold
Definition: attributes.h:82
static const uint8_t amplitude_bits[]
Definition: qdmc.c:164
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1588
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:1400
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:728
#define av_log(a,...)
static const uint8_t phase_diff_bits[]
Definition: qdmc.c:183
#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:191
#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:61
static const struct endianess table[]
static const uint8_t noise_bands_selector[]
Definition: qdmc.c:117
#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:111
uint8_t frame_bits
Definition: qdmc.c:47
int16_t amplitude
Definition: qdmc.c:41
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:3358
static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)
Definition: qdmc.c:585
float alt_sin[5][31]
Definition: qdmc.c:60
static const uint8_t freq_diff_bits[]
Definition: qdmc.c:150
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:2194
int subframe_size
Definition: qdmc.c:50
Definition: fft.h:88
int16_t freq
Definition: qdmc.c:40
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:659
uint8_t noise[2][19][17]
Definition: qdmc.c:56
#define ff_fft_init
Definition: fft.h:149
int buffer_offset
Definition: qdmc.c:52
static const uint8_t noise_segment_length_bits[]
Definition: qdmc.c:138
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:554
int n
Definition: avisynth_c.h:684
static const uint8_t amplitude_diff_codes[]
Definition: qdmc.c:179
static void add_noise(QDMCContext *s, int ch, int current_subframe)
Definition: qdmc.c:551
static volatile int checksum
Definition: adler32.c:30
FFTContext fft_ctx
Definition: qdmc.c:69
#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:131
float * buffer_ptr
Definition: qdmc.c:65
static void add_tone(QDMCContext *s, int group, int offset, int freq, int stereo_mode, int amplitude, int phase)
Definition: qdmc.c:446
static int skip_label(QDMCContext *s, GetBitContext *gb)
Definition: qdmc.c:382
Libavcodec external API header.
int sample_rate
samples per second
Definition: avcodec.h:2143
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:456
static void make_noises(QDMCContext *s)
Definition: qdmc.c:229
uint8_t offset
Definition: qdmc.c:39
main external API structure.
Definition: avcodec.h:1488
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1886
static int read_noise_data(QDMCContext *s, GetBitContext *gb)
Definition: qdmc.c:398
int extradata_size
Definition: avcodec.h:1589
#define llrint(x)
Definition: libm.h:394
static const uint8_t noise_value_bits[]
Definition: qdmc.c:121
int index
Definition: gxfenc.c:89
static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)
Definition: qdmc.c:525
float im
Definition: fft.c:82
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:346
float noise2_buffer[4096 *2]
Definition: qdmc.c:62
static const uint8_t phase_diff_codes[]
Definition: qdmc.c:187
static const uint8_t amplitude_diff_bits[]
Definition: qdmc.c:175
int band_index
Definition: qdmc.c:48
uint8_t mode
Definition: qdmc.c:37
static void add_waves(QDMCContext *s, int current_subframe)
Definition: qdmc.c:635
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:215
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:617
common internal api header.
FFTSample im
Definition: avfft.h:38
uint8_t phase
Definition: qdmc.c:38
int frame_size
Definition: qdmc.c:49
signed 16 bits
Definition: samplefmt.h:61
int checksum_size
Definition: qdmc.c:54
static const float amplitude_tab[64]
Definition: qdmc.c:87
#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:75
static const uint8_t noise_value_symbols[]
Definition: qdmc.c:126
#define MKBETAG(a, b, c, d)
Definition: common.h:367
int nb_channels
Definition: qdmc.c:53
void * priv_data
Definition: avcodec.h:1515
static av_always_inline int diff(const uint32_t a, const uint32_t b)
int fft_offset
Definition: qdmc.c:51
int len
int channels
number of audio channels
Definition: avcodec.h:2144
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
AVCodecContext * avctx
Definition: qdmc.c:45
static av_cold void qdmc_init_static_data(AVCodec *codec)
Definition: qdmc.c:207
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:251
#define AV_CH_LAYOUT_MONO
#define MKTAG(a, b, c, d)
Definition: common.h:366
This structure stores compressed data.
Definition: avcodec.h:1377
int cur_tone[5]
Definition: qdmc.c:59
static int read_wave_data(QDMCContext *s, GetBitContext *gb)
Definition: qdmc.c:463
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:267
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:956
static const uint8_t noise_segment_length_symbols[]
Definition: qdmc.c:142
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:276
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:63
static int qdmc_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: qdmc.c:738