FFmpeg
qdm2.c
Go to the documentation of this file.
1 /*
2  * QDM2 compatible decoder
3  * Copyright (c) 2003 Ewald Snel
4  * Copyright (c) 2005 Benjamin Larsson
5  * Copyright (c) 2005 Alex Beregszaszi
6  * Copyright (c) 2005 Roberto Togni
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 /**
26  * @file
27  * QDM2 decoder
28  * @author Ewald Snel, Benjamin Larsson, Alex Beregszaszi, Roberto Togni
29  *
30  * The decoder is not perfect yet, there are still some distortions
31  * especially on files encoded with 16 or 8 subbands.
32  */
33 
34 #include <math.h>
35 #include <stddef.h>
36 #include <stdio.h>
37 
39 #include "libavutil/mem_internal.h"
40 #include "libavutil/thread.h"
41 
42 #define BITSTREAM_READER_LE
43 #include "avcodec.h"
44 #include "get_bits.h"
45 #include "bytestream.h"
46 #include "internal.h"
47 #include "mpegaudio.h"
48 #include "mpegaudiodsp.h"
49 #include "rdft.h"
50 
51 #include "qdm2_tablegen.h"
52 
53 #define QDM2_LIST_ADD(list, size, packet) \
54 do { \
55  if (size > 0) { \
56  list[size - 1].next = &list[size]; \
57  } \
58  list[size].packet = packet; \
59  list[size].next = NULL; \
60  size++; \
61 } while(0)
62 
63 // Result is 8, 16 or 30
64 #define QDM2_SB_USED(sub_sampling) (((sub_sampling) >= 2) ? 30 : 8 << (sub_sampling))
65 
66 #define FIX_NOISE_IDX(noise_idx) \
67  if ((noise_idx) >= 3840) \
68  (noise_idx) -= 3840; \
69 
70 #define SB_DITHERING_NOISE(sb,noise_idx) (noise_table[(noise_idx)++] * sb_noise_attenuation[(sb)])
71 
72 #define SAMPLES_NEEDED \
73  av_log (NULL,AV_LOG_INFO,"This file triggers some untested code. Please contact the developers.\n");
74 
75 #define SAMPLES_NEEDED_2(why) \
76  av_log (NULL,AV_LOG_INFO,"This file triggers some missing code. Please contact the developers.\nPosition: %s\n",why);
77 
78 #define QDM2_MAX_FRAME_SIZE 512
79 
80 typedef int8_t sb_int8_array[2][30][64];
81 
82 /**
83  * Subpacket
84  */
85 typedef struct QDM2SubPacket {
86  int type; ///< subpacket type
87  unsigned int size; ///< subpacket size
88  const uint8_t *data; ///< pointer to subpacket data (points to input data buffer, it's not a private copy)
90 
91 /**
92  * A node in the subpacket list
93  */
94 typedef struct QDM2SubPNode {
95  QDM2SubPacket *packet; ///< packet
96  struct QDM2SubPNode *next; ///< pointer to next packet in the list, NULL if leaf node
97 } QDM2SubPNode;
98 
99 typedef struct QDM2Complex {
100  float re;
101  float im;
102 } QDM2Complex;
103 
104 typedef struct FFTTone {
105  float level;
107  const float *table;
108  int phase;
110  int duration;
111  short time_index;
112  short cutoff;
113 } FFTTone;
114 
115 typedef struct FFTCoefficient {
116  int16_t sub_packet;
117  uint8_t channel;
118  int16_t offset;
119  int16_t exp;
120  uint8_t phase;
122 
123 typedef struct QDM2FFT {
125 } QDM2FFT;
126 
127 /**
128  * QDM2 decoder context
129  */
130 typedef struct QDM2Context {
131  /// Parameters from codec header, do not change during playback
132  int nb_channels; ///< number of channels
133  int channels; ///< number of channels
134  int group_size; ///< size of frame group (16 frames per group)
135  int fft_size; ///< size of FFT, in complex numbers
136  int checksum_size; ///< size of data block, used also for checksum
137 
138  /// Parameters built from header parameters, do not change during playback
139  int group_order; ///< order of frame group
140  int fft_order; ///< order of FFT (actually fftorder+1)
141  int frame_size; ///< size of data frame
143  int sub_sampling; ///< subsampling: 0=25%, 1=50%, 2=100% */
144  int coeff_per_sb_select; ///< selector for "num. of coeffs. per subband" tables. Can be 0, 1, 2
145  int cm_table_select; ///< selector for "coding method" tables. Can be 0, 1 (from init: 0-4)
146 
147  /// Packets and packet lists
148  QDM2SubPacket sub_packets[16]; ///< the packets themselves
149  QDM2SubPNode sub_packet_list_A[16]; ///< list of all packets
150  QDM2SubPNode sub_packet_list_B[16]; ///< FFT packets B are on list
151  int sub_packets_B; ///< number of packets on 'B' list
152  QDM2SubPNode sub_packet_list_C[16]; ///< packets with errors?
153  QDM2SubPNode sub_packet_list_D[16]; ///< DCT packets
154 
155  /// FFT and tones
166 
167  /// I/O data
168  const uint8_t *compressed_data;
171 
172  /// Synthesis filter
178 
179  /// Mixed temporary data used in decoding
180  float tone_level[MPA_MAX_CHANNELS][30][64];
189 
190  // Flags
191  int has_errors; ///< packet has errors
192  int superblocktype_2_3; ///< select fft tables and some algorithm based on superblock type
193  int do_synth_filter; ///< used to perform or skip synthesis filter
194 
196  int noise_idx; ///< index for dithering noise table
197 } QDM2Context;
198 
199 static const int switchtable[23] = {
200  0, 5, 1, 5, 5, 5, 5, 5, 2, 5, 5, 5, 5, 5, 5, 5, 3, 5, 5, 5, 5, 5, 4
201 };
202 
203 static int qdm2_get_vlc(GetBitContext *gb, const VLC *vlc, int flag, int depth)
204 {
205  int value;
206 
207  value = get_vlc2(gb, vlc->table, vlc->bits, depth);
208 
209  /* stage-2, 3 bits exponent escape sequence */
210  if (value < 0)
211  value = get_bits(gb, get_bits(gb, 3) + 1);
212 
213  /* stage-3, optional */
214  if (flag) {
215  int tmp;
216 
217  if (value >= 60) {
218  av_log(NULL, AV_LOG_ERROR, "value %d in qdm2_get_vlc too large\n", value);
219  return 0;
220  }
221 
223 
224  if ((value & ~3) > 0)
225  tmp += get_bits(gb, (value >> 2));
226  value = tmp;
227  }
228 
229  return value;
230 }
231 
232 static int qdm2_get_se_vlc(const VLC *vlc, GetBitContext *gb, int depth)
233 {
234  int value = qdm2_get_vlc(gb, vlc, 0, depth);
235 
236  return (value & 1) ? ((value + 1) >> 1) : -(value >> 1);
237 }
238 
239 /**
240  * QDM2 checksum
241  *
242  * @param data pointer to data to be checksummed
243  * @param length data length
244  * @param value checksum value
245  *
246  * @return 0 if checksum is OK
247  */
248 static uint16_t qdm2_packet_checksum(const uint8_t *data, int length, int value)
249 {
250  int i;
251 
252  for (i = 0; i < length; i++)
253  value -= data[i];
254 
255  return (uint16_t)(value & 0xffff);
256 }
257 
258 /**
259  * Fill a QDM2SubPacket structure with packet type, size, and data pointer.
260  *
261  * @param gb bitreader context
262  * @param sub_packet packet under analysis
263  */
265  QDM2SubPacket *sub_packet)
266 {
267  sub_packet->type = get_bits(gb, 8);
268 
269  if (sub_packet->type == 0) {
270  sub_packet->size = 0;
271  sub_packet->data = NULL;
272  } else {
273  sub_packet->size = get_bits(gb, 8);
274 
275  if (sub_packet->type & 0x80) {
276  sub_packet->size <<= 8;
277  sub_packet->size |= get_bits(gb, 8);
278  sub_packet->type &= 0x7f;
279  }
280 
281  if (sub_packet->type == 0x7f)
282  sub_packet->type |= (get_bits(gb, 8) << 8);
283 
284  // FIXME: this depends on bitreader-internal data
285  sub_packet->data = &gb->buffer[get_bits_count(gb) / 8];
286  }
287 
288  av_log(NULL, AV_LOG_DEBUG, "Subpacket: type=%d size=%d start_offs=%x\n",
289  sub_packet->type, sub_packet->size, get_bits_count(gb) / 8);
290 }
291 
292 /**
293  * Return node pointer to first packet of requested type in list.
294  *
295  * @param list list of subpackets to be scanned
296  * @param type type of searched subpacket
297  * @return node pointer for subpacket if found, else NULL
298  */
300  int type)
301 {
302  while (list && list->packet) {
303  if (list->packet->type == type)
304  return list;
305  list = list->next;
306  }
307  return NULL;
308 }
309 
310 /**
311  * Replace 8 elements with their average value.
312  * Called by qdm2_decode_superblock before starting subblock decoding.
313  *
314  * @param q context
315  */
317 {
318  int i, j, n, ch, sum;
319 
321 
322  for (ch = 0; ch < q->nb_channels; ch++)
323  for (i = 0; i < n; i++) {
324  sum = 0;
325 
326  for (j = 0; j < 8; j++)
327  sum += q->quantized_coeffs[ch][i][j];
328 
329  sum /= 8;
330  if (sum > 0)
331  sum--;
332 
333  for (j = 0; j < 8; j++)
334  q->quantized_coeffs[ch][i][j] = sum;
335  }
336 }
337 
338 /**
339  * Build subband samples with noise weighted by q->tone_level.
340  * Called by synthfilt_build_sb_samples.
341  *
342  * @param q context
343  * @param sb subband index
344  */
346 {
347  int ch, j;
348 
350 
351  if (!q->nb_channels)
352  return;
353 
354  for (ch = 0; ch < q->nb_channels; ch++) {
355  for (j = 0; j < 64; j++) {
356  q->sb_samples[ch][j * 2][sb] =
357  SB_DITHERING_NOISE(sb, q->noise_idx) * q->tone_level[ch][sb][j];
358  q->sb_samples[ch][j * 2 + 1][sb] =
359  SB_DITHERING_NOISE(sb, q->noise_idx) * q->tone_level[ch][sb][j];
360  }
361  }
362 }
363 
364 /**
365  * Called while processing data from subpackets 11 and 12.
366  * Used after making changes to coding_method array.
367  *
368  * @param sb subband index
369  * @param channels number of channels
370  * @param coding_method q->coding_method[0][0][0]
371  */
372 static int fix_coding_method_array(int sb, int channels,
373  sb_int8_array coding_method)
374 {
375  int j, k;
376  int ch;
377  int run, case_val;
378 
379  for (ch = 0; ch < channels; ch++) {
380  for (j = 0; j < 64; ) {
381  if (coding_method[ch][sb][j] < 8)
382  return -1;
383  if ((coding_method[ch][sb][j] - 8) > 22) {
384  run = 1;
385  case_val = 8;
386  } else {
387  switch (switchtable[coding_method[ch][sb][j] - 8]) {
388  case 0: run = 10;
389  case_val = 10;
390  break;
391  case 1: run = 1;
392  case_val = 16;
393  break;
394  case 2: run = 5;
395  case_val = 24;
396  break;
397  case 3: run = 3;
398  case_val = 30;
399  break;
400  case 4: run = 1;
401  case_val = 30;
402  break;
403  case 5: run = 1;
404  case_val = 8;
405  break;
406  default: run = 1;
407  case_val = 8;
408  break;
409  }
410  }
411  for (k = 0; k < run; k++) {
412  if (j + k < 128) {
413  int sbjk = sb + (j + k) / 64;
414  if (sbjk > 29) {
416  continue;
417  }
418  if (coding_method[ch][sbjk][(j + k) % 64] > coding_method[ch][sb][j]) {
419  if (k > 0) {
421  //not debugged, almost never used
422  memset(&coding_method[ch][sb][j + k], case_val,
423  k *sizeof(int8_t));
424  memset(&coding_method[ch][sb][j + k], case_val,
425  3 * sizeof(int8_t));
426  }
427  }
428  }
429  }
430  j += run;
431  }
432  }
433  return 0;
434 }
435 
436 /**
437  * Related to synthesis filter
438  * Called by process_subpacket_10
439  *
440  * @param q context
441  * @param flag 1 if called after getting data from subpacket 10, 0 if no subpacket 10
442  */
444 {
445  int i, sb, ch, sb_used;
446  int tmp, tab;
447 
448  for (ch = 0; ch < q->nb_channels; ch++)
449  for (sb = 0; sb < 30; sb++)
450  for (i = 0; i < 8; i++) {
452  tmp = q->quantized_coeffs[ch][tab + 1][i] * dequant_table[q->coeff_per_sb_select][tab + 1][sb]+
454  else
456  if(tmp < 0)
457  tmp += 0xff;
458  q->tone_level_idx_base[ch][sb][i] = (tmp / 256) & 0xff;
459  }
460 
461  sb_used = QDM2_SB_USED(q->sub_sampling);
462 
463  if ((q->superblocktype_2_3 != 0) && !flag) {
464  for (sb = 0; sb < sb_used; sb++)
465  for (ch = 0; ch < q->nb_channels; ch++)
466  for (i = 0; i < 64; i++) {
467  q->tone_level_idx[ch][sb][i] = q->tone_level_idx_base[ch][sb][i / 8];
468  if (q->tone_level_idx[ch][sb][i] < 0)
469  q->tone_level[ch][sb][i] = 0;
470  else
471  q->tone_level[ch][sb][i] = fft_tone_level_table[0][q->tone_level_idx[ch][sb][i] & 0x3f];
472  }
473  } else {
474  tab = q->superblocktype_2_3 ? 0 : 1;
475  for (sb = 0; sb < sb_used; sb++) {
476  if ((sb >= 4) && (sb <= 23)) {
477  for (ch = 0; ch < q->nb_channels; ch++)
478  for (i = 0; i < 64; i++) {
479  tmp = q->tone_level_idx_base[ch][sb][i / 8] -
480  q->tone_level_idx_hi1[ch][sb / 8][i / 8][i % 8] -
481  q->tone_level_idx_mid[ch][sb - 4][i / 8] -
482  q->tone_level_idx_hi2[ch][sb - 4];
483  q->tone_level_idx[ch][sb][i] = tmp & 0xff;
484  if ((tmp < 0) || (!q->superblocktype_2_3 && !tmp))
485  q->tone_level[ch][sb][i] = 0;
486  else
487  q->tone_level[ch][sb][i] = fft_tone_level_table[tab][tmp & 0x3f];
488  }
489  } else {
490  if (sb > 4) {
491  for (ch = 0; ch < q->nb_channels; ch++)
492  for (i = 0; i < 64; i++) {
493  tmp = q->tone_level_idx_base[ch][sb][i / 8] -
494  q->tone_level_idx_hi1[ch][2][i / 8][i % 8] -
495  q->tone_level_idx_hi2[ch][sb - 4];
496  q->tone_level_idx[ch][sb][i] = tmp & 0xff;
497  if ((tmp < 0) || (!q->superblocktype_2_3 && !tmp))
498  q->tone_level[ch][sb][i] = 0;
499  else
500  q->tone_level[ch][sb][i] = fft_tone_level_table[tab][tmp & 0x3f];
501  }
502  } else {
503  for (ch = 0; ch < q->nb_channels; ch++)
504  for (i = 0; i < 64; i++) {
505  tmp = q->tone_level_idx[ch][sb][i] = q->tone_level_idx_base[ch][sb][i / 8];
506  if ((tmp < 0) || (!q->superblocktype_2_3 && !tmp))
507  q->tone_level[ch][sb][i] = 0;
508  else
509  q->tone_level[ch][sb][i] = fft_tone_level_table[tab][tmp & 0x3f];
510  }
511  }
512  }
513  }
514  }
515 }
516 
517 /**
518  * Related to synthesis filter
519  * Called by process_subpacket_11
520  * c is built with data from subpacket 11
521  * Most of this function is used only if superblock_type_2_3 == 0,
522  * never seen it in samples.
523  *
524  * @param tone_level_idx
525  * @param tone_level_idx_temp
526  * @param coding_method q->coding_method[0][0][0]
527  * @param nb_channels number of channels
528  * @param c coming from subpacket 11, passed as 8*c
529  * @param superblocktype_2_3 flag based on superblock packet type
530  * @param cm_table_select q->cm_table_select
531  */
532 static void fill_coding_method_array(sb_int8_array tone_level_idx,
533  sb_int8_array tone_level_idx_temp,
534  sb_int8_array coding_method,
535  int nb_channels,
536  int c, int superblocktype_2_3,
537  int cm_table_select)
538 {
539  int ch, sb, j;
540  int tmp, acc, esp_40, comp;
541  int add1, add2, add3, add4;
542  int64_t multres;
543 
544  if (!superblocktype_2_3) {
545  /* This case is untested, no samples available */
546  avpriv_request_sample(NULL, "!superblocktype_2_3");
547  return;
548  for (ch = 0; ch < nb_channels; ch++) {
549  for (sb = 0; sb < 30; sb++) {
550  for (j = 1; j < 63; j++) { // The loop only iterates to 63 so the code doesn't overflow the buffer
551  add1 = tone_level_idx[ch][sb][j] - 10;
552  if (add1 < 0)
553  add1 = 0;
554  add2 = add3 = add4 = 0;
555  if (sb > 1) {
556  add2 = tone_level_idx[ch][sb - 2][j] + tone_level_idx_offset_table[sb][0] - 6;
557  if (add2 < 0)
558  add2 = 0;
559  }
560  if (sb > 0) {
561  add3 = tone_level_idx[ch][sb - 1][j] + tone_level_idx_offset_table[sb][1] - 6;
562  if (add3 < 0)
563  add3 = 0;
564  }
565  if (sb < 29) {
566  add4 = tone_level_idx[ch][sb + 1][j] + tone_level_idx_offset_table[sb][3] - 6;
567  if (add4 < 0)
568  add4 = 0;
569  }
570  tmp = tone_level_idx[ch][sb][j + 1] * 2 - add4 - add3 - add2 - add1;
571  if (tmp < 0)
572  tmp = 0;
573  tone_level_idx_temp[ch][sb][j + 1] = tmp & 0xff;
574  }
575  tone_level_idx_temp[ch][sb][0] = tone_level_idx_temp[ch][sb][1];
576  }
577  }
578  acc = 0;
579  for (ch = 0; ch < nb_channels; ch++)
580  for (sb = 0; sb < 30; sb++)
581  for (j = 0; j < 64; j++)
582  acc += tone_level_idx_temp[ch][sb][j];
583 
584  multres = 0x66666667LL * (acc * 10);
585  esp_40 = (multres >> 32) / 8 + ((multres & 0xffffffff) >> 31);
586  for (ch = 0; ch < nb_channels; ch++)
587  for (sb = 0; sb < 30; sb++)
588  for (j = 0; j < 64; j++) {
589  comp = tone_level_idx_temp[ch][sb][j]* esp_40 * 10;
590  if (comp < 0)
591  comp += 0xff;
592  comp /= 256; // signed shift
593  switch(sb) {
594  case 0:
595  if (comp < 30)
596  comp = 30;
597  comp += 15;
598  break;
599  case 1:
600  if (comp < 24)
601  comp = 24;
602  comp += 10;
603  break;
604  case 2:
605  case 3:
606  case 4:
607  if (comp < 16)
608  comp = 16;
609  }
610  if (comp <= 5)
611  tmp = 0;
612  else if (comp <= 10)
613  tmp = 10;
614  else if (comp <= 16)
615  tmp = 16;
616  else if (comp <= 24)
617  tmp = -1;
618  else
619  tmp = 0;
620  coding_method[ch][sb][j] = ((tmp & 0xfffa) + 30 )& 0xff;
621  }
622  for (sb = 0; sb < 30; sb++)
623  fix_coding_method_array(sb, nb_channels, coding_method);
624  for (ch = 0; ch < nb_channels; ch++)
625  for (sb = 0; sb < 30; sb++)
626  for (j = 0; j < 64; j++)
627  if (sb >= 10) {
628  if (coding_method[ch][sb][j] < 10)
629  coding_method[ch][sb][j] = 10;
630  } else {
631  if (sb >= 2) {
632  if (coding_method[ch][sb][j] < 16)
633  coding_method[ch][sb][j] = 16;
634  } else {
635  if (coding_method[ch][sb][j] < 30)
636  coding_method[ch][sb][j] = 30;
637  }
638  }
639  } else { // superblocktype_2_3 != 0
640  for (ch = 0; ch < nb_channels; ch++)
641  for (sb = 0; sb < 30; sb++)
642  for (j = 0; j < 64; j++)
643  coding_method[ch][sb][j] = coding_method_table[cm_table_select][sb];
644  }
645 }
646 
647 /**
648  * Called by process_subpacket_11 to process more data from subpacket 11
649  * with sb 0-8.
650  * Called by process_subpacket_12 to process data from subpacket 12 with
651  * sb 8-sb_used.
652  *
653  * @param q context
654  * @param gb bitreader context
655  * @param length packet length in bits
656  * @param sb_min lower subband processed (sb_min included)
657  * @param sb_max higher subband processed (sb_max excluded)
658  */
660  int length, int sb_min, int sb_max)
661 {
662  int sb, j, k, n, ch, run, channels;
663  int joined_stereo, zero_encoding;
664  int type34_first;
665  float type34_div = 0;
666  float type34_predictor;
667  float samples[10];
668  int sign_bits[16] = {0};
669 
670  if (length == 0) {
671  // If no data use noise
672  for (sb=sb_min; sb < sb_max; sb++)
674 
675  return 0;
676  }
677 
678  for (sb = sb_min; sb < sb_max; sb++) {
679  channels = q->nb_channels;
680 
681  if (q->nb_channels <= 1 || sb < 12)
682  joined_stereo = 0;
683  else if (sb >= 24)
684  joined_stereo = 1;
685  else
686  joined_stereo = (get_bits_left(gb) >= 1) ? get_bits1(gb) : 0;
687 
688  if (joined_stereo) {
689  if (get_bits_left(gb) >= 16)
690  for (j = 0; j < 16; j++)
691  sign_bits[j] = get_bits1(gb);
692 
693  for (j = 0; j < 64; j++)
694  if (q->coding_method[1][sb][j] > q->coding_method[0][sb][j])
695  q->coding_method[0][sb][j] = q->coding_method[1][sb][j];
696 
698  q->coding_method)) {
699  av_log(NULL, AV_LOG_ERROR, "coding method invalid\n");
701  continue;
702  }
703  channels = 1;
704  }
705 
706  for (ch = 0; ch < channels; ch++) {
708  zero_encoding = (get_bits_left(gb) >= 1) ? get_bits1(gb) : 0;
709  type34_predictor = 0.0;
710  type34_first = 1;
711 
712  for (j = 0; j < 128; ) {
713  switch (q->coding_method[ch][sb][j / 2]) {
714  case 8:
715  if (get_bits_left(gb) >= 10) {
716  if (zero_encoding) {
717  for (k = 0; k < 5; k++) {
718  if ((j + 2 * k) >= 128)
719  break;
720  samples[2 * k] = get_bits1(gb) ? dequant_1bit[joined_stereo][2 * get_bits1(gb)] : 0;
721  }
722  } else {
723  n = get_bits(gb, 8);
724  if (n >= 243) {
725  av_log(NULL, AV_LOG_ERROR, "Invalid 8bit codeword\n");
726  return AVERROR_INVALIDDATA;
727  }
728 
729  for (k = 0; k < 5; k++)
730  samples[2 * k] = dequant_1bit[joined_stereo][random_dequant_index[n][k]];
731  }
732  for (k = 0; k < 5; k++)
733  samples[2 * k + 1] = SB_DITHERING_NOISE(sb,q->noise_idx);
734  } else {
735  for (k = 0; k < 10; k++)
737  }
738  run = 10;
739  break;
740 
741  case 10:
742  if (get_bits_left(gb) >= 1) {
743  float f = 0.81;
744 
745  if (get_bits1(gb))
746  f = -f;
747  f -= noise_samples[((sb + 1) * (j +5 * ch + 1)) & 127] * 9.0 / 40.0;
748  samples[0] = f;
749  } else {
751  }
752  run = 1;
753  break;
754 
755  case 16:
756  if (get_bits_left(gb) >= 10) {
757  if (zero_encoding) {
758  for (k = 0; k < 5; k++) {
759  if ((j + k) >= 128)
760  break;
761  samples[k] = (get_bits1(gb) == 0) ? 0 : dequant_1bit[joined_stereo][2 * get_bits1(gb)];
762  }
763  } else {
764  n = get_bits (gb, 8);
765  if (n >= 243) {
766  av_log(NULL, AV_LOG_ERROR, "Invalid 8bit codeword\n");
767  return AVERROR_INVALIDDATA;
768  }
769 
770  for (k = 0; k < 5; k++)
771  samples[k] = dequant_1bit[joined_stereo][random_dequant_index[n][k]];
772  }
773  } else {
774  for (k = 0; k < 5; k++)
776  }
777  run = 5;
778  break;
779 
780  case 24:
781  if (get_bits_left(gb) >= 7) {
782  n = get_bits(gb, 7);
783  if (n >= 125) {
784  av_log(NULL, AV_LOG_ERROR, "Invalid 7bit codeword\n");
785  return AVERROR_INVALIDDATA;
786  }
787 
788  for (k = 0; k < 3; k++)
789  samples[k] = (random_dequant_type24[n][k] - 2.0) * 0.5;
790  } else {
791  for (k = 0; k < 3; k++)
793  }
794  run = 3;
795  break;
796 
797  case 30:
798  if (get_bits_left(gb) >= 4) {
799  unsigned index = qdm2_get_vlc(gb, &vlc_tab_type30, 0, 1);
801  av_log(NULL, AV_LOG_ERROR, "index %d out of type30_dequant array\n", index);
802  return AVERROR_INVALIDDATA;
803  }
805  } else
807 
808  run = 1;
809  break;
810 
811  case 34:
812  if (get_bits_left(gb) >= 7) {
813  if (type34_first) {
814  type34_div = (float)(1 << get_bits(gb, 2));
815  samples[0] = ((float)get_bits(gb, 5) - 16.0) / 15.0;
816  type34_predictor = samples[0];
817  type34_first = 0;
818  } else {
819  unsigned index = qdm2_get_vlc(gb, &vlc_tab_type34, 0, 1);
821  av_log(NULL, AV_LOG_ERROR, "index %d out of type34_delta array\n", index);
822  return AVERROR_INVALIDDATA;
823  }
824  samples[0] = type34_delta[index] / type34_div + type34_predictor;
825  type34_predictor = samples[0];
826  }
827  } else {
829  }
830  run = 1;
831  break;
832 
833  default:
835  run = 1;
836  break;
837  }
838 
839  if (joined_stereo) {
840  for (k = 0; k < run && j + k < 128; k++) {
841  q->sb_samples[0][j + k][sb] =
842  q->tone_level[0][sb][(j + k) / 2] * samples[k];
843  if (q->nb_channels == 2) {
844  if (sign_bits[(j + k) / 8])
845  q->sb_samples[1][j + k][sb] =
846  q->tone_level[1][sb][(j + k) / 2] * -samples[k];
847  else
848  q->sb_samples[1][j + k][sb] =
849  q->tone_level[1][sb][(j + k) / 2] * samples[k];
850  }
851  }
852  } else {
853  for (k = 0; k < run; k++)
854  if ((j + k) < 128)
855  q->sb_samples[ch][j + k][sb] = q->tone_level[ch][sb][(j + k)/2] * samples[k];
856  }
857 
858  j += run;
859  } // j loop
860  } // channel loop
861  } // subband loop
862  return 0;
863 }
864 
865 /**
866  * Init the first element of a channel in quantized_coeffs with data
867  * from packet 10 (quantized_coeffs[ch][0]).
868  * This is similar to process_subpacket_9, but for a single channel
869  * and for element [0]
870  * same VLC tables as process_subpacket_9 are used.
871  *
872  * @param quantized_coeffs pointer to quantized_coeffs[ch][0]
873  * @param gb bitreader context
874  */
875 static int init_quantized_coeffs_elem0(int8_t *quantized_coeffs,
876  GetBitContext *gb)
877 {
878  int i, k, run, level, diff;
879 
880  if (get_bits_left(gb) < 16)
881  return -1;
882  level = qdm2_get_vlc(gb, &vlc_tab_level, 0, 2);
883 
884  quantized_coeffs[0] = level;
885 
886  for (i = 0; i < 7; ) {
887  if (get_bits_left(gb) < 16)
888  return -1;
889  run = qdm2_get_vlc(gb, &vlc_tab_run, 0, 1) + 1;
890 
891  if (i + run >= 8)
892  return -1;
893 
894  if (get_bits_left(gb) < 16)
895  return -1;
896  diff = qdm2_get_se_vlc(&vlc_tab_diff, gb, 2);
897 
898  for (k = 1; k <= run; k++)
899  quantized_coeffs[i + k] = (level + ((k * diff) / run));
900 
901  level += diff;
902  i += run;
903  }
904  return 0;
905 }
906 
907 /**
908  * Related to synthesis filter, process data from packet 10
909  * Init part of quantized_coeffs via function init_quantized_coeffs_elem0
910  * Init tone_level_idx_hi1, tone_level_idx_hi2, tone_level_idx_mid with
911  * data from packet 10
912  *
913  * @param q context
914  * @param gb bitreader context
915  */
917 {
918  int sb, j, k, n, ch;
919 
920  for (ch = 0; ch < q->nb_channels; ch++) {
922 
923  if (get_bits_left(gb) < 16) {
924  memset(q->quantized_coeffs[ch][0], 0, 8);
925  break;
926  }
927  }
928 
929  n = q->sub_sampling + 1;
930 
931  for (sb = 0; sb < n; sb++)
932  for (ch = 0; ch < q->nb_channels; ch++)
933  for (j = 0; j < 8; j++) {
934  if (get_bits_left(gb) < 1)
935  break;
936  if (get_bits1(gb)) {
937  for (k=0; k < 8; k++) {
938  if (get_bits_left(gb) < 16)
939  break;
940  q->tone_level_idx_hi1[ch][sb][j][k] = qdm2_get_vlc(gb, &vlc_tab_tone_level_idx_hi1, 0, 2);
941  }
942  } else {
943  for (k=0; k < 8; k++)
944  q->tone_level_idx_hi1[ch][sb][j][k] = 0;
945  }
946  }
947 
948  n = QDM2_SB_USED(q->sub_sampling) - 4;
949 
950  for (sb = 0; sb < n; sb++)
951  for (ch = 0; ch < q->nb_channels; ch++) {
952  if (get_bits_left(gb) < 16)
953  break;
955  if (sb > 19)
956  q->tone_level_idx_hi2[ch][sb] -= 16;
957  else
958  for (j = 0; j < 8; j++)
959  q->tone_level_idx_mid[ch][sb][j] = -16;
960  }
961 
962  n = QDM2_SB_USED(q->sub_sampling) - 5;
963 
964  for (sb = 0; sb < n; sb++)
965  for (ch = 0; ch < q->nb_channels; ch++)
966  for (j = 0; j < 8; j++) {
967  if (get_bits_left(gb) < 16)
968  break;
969  q->tone_level_idx_mid[ch][sb][j] = qdm2_get_vlc(gb, &vlc_tab_tone_level_idx_mid, 0, 2) - 32;
970  }
971 }
972 
973 /**
974  * Process subpacket 9, init quantized_coeffs with data from it
975  *
976  * @param q context
977  * @param node pointer to node with packet
978  */
980 {
981  GetBitContext gb;
982  int i, j, k, n, ch, run, level, diff;
983 
984  init_get_bits(&gb, node->packet->data, node->packet->size * 8);
985 
987 
988  for (i = 1; i < n; i++)
989  for (ch = 0; ch < q->nb_channels; ch++) {
990  level = qdm2_get_vlc(&gb, &vlc_tab_level, 0, 2);
991  q->quantized_coeffs[ch][i][0] = level;
992 
993  for (j = 0; j < (8 - 1); ) {
994  run = qdm2_get_vlc(&gb, &vlc_tab_run, 0, 1) + 1;
995  diff = qdm2_get_se_vlc(&vlc_tab_diff, &gb, 2);
996 
997  if (j + run >= 8)
998  return -1;
999 
1000  for (k = 1; k <= run; k++)
1001  q->quantized_coeffs[ch][i][j + k] = (level + ((k * diff) / run));
1002 
1003  level += diff;
1004  j += run;
1005  }
1006  }
1007 
1008  for (ch = 0; ch < q->nb_channels; ch++)
1009  for (i = 0; i < 8; i++)
1010  q->quantized_coeffs[ch][0][i] = 0;
1011 
1012  return 0;
1013 }
1014 
1015 /**
1016  * Process subpacket 10 if not null, else
1017  *
1018  * @param q context
1019  * @param node pointer to node with packet
1020  */
1022 {
1023  GetBitContext gb;
1024 
1025  if (node) {
1026  init_get_bits(&gb, node->packet->data, node->packet->size * 8);
1028  fill_tone_level_array(q, 1);
1029  } else {
1030  fill_tone_level_array(q, 0);
1031  }
1032 }
1033 
1034 /**
1035  * Process subpacket 11
1036  *
1037  * @param q context
1038  * @param node pointer to node with packet
1039  */
1041 {
1042  GetBitContext gb;
1043  int length = 0;
1044 
1045  if (node) {
1046  length = node->packet->size * 8;
1047  init_get_bits(&gb, node->packet->data, length);
1048  }
1049 
1050  if (length >= 32) {
1051  int c = get_bits(&gb, 13);
1052 
1053  if (c > 3)
1056  q->nb_channels, 8 * c,
1058  }
1059 
1060  synthfilt_build_sb_samples(q, &gb, length, 0, 8);
1061 }
1062 
1063 /**
1064  * Process subpacket 12
1065  *
1066  * @param q context
1067  * @param node pointer to node with packet
1068  */
1070 {
1071  GetBitContext gb;
1072  int length = 0;
1073 
1074  if (node) {
1075  length = node->packet->size * 8;
1076  init_get_bits(&gb, node->packet->data, length);
1077  }
1078 
1079  synthfilt_build_sb_samples(q, &gb, length, 8, QDM2_SB_USED(q->sub_sampling));
1080 }
1081 
1082 /**
1083  * Process new subpackets for synthesis filter
1084  *
1085  * @param q context
1086  * @param list list with synthesis filter packets (list D)
1087  */
1089 {
1090  QDM2SubPNode *nodes[4];
1091 
1093  if (nodes[0])
1094  process_subpacket_9(q, nodes[0]);
1095 
1096  nodes[1] = qdm2_search_subpacket_type_in_list(list, 10);
1097  if (nodes[1])
1098  process_subpacket_10(q, nodes[1]);
1099  else
1101 
1102  nodes[2] = qdm2_search_subpacket_type_in_list(list, 11);
1103  if (nodes[0] && nodes[1] && nodes[2])
1104  process_subpacket_11(q, nodes[2]);
1105  else
1107 
1108  nodes[3] = qdm2_search_subpacket_type_in_list(list, 12);
1109  if (nodes[0] && nodes[1] && nodes[3])
1110  process_subpacket_12(q, nodes[3]);
1111  else
1113 }
1114 
1115 /**
1116  * Decode superblock, fill packet lists.
1117  *
1118  * @param q context
1119  */
1121 {
1122  GetBitContext gb;
1123  QDM2SubPacket header, *packet;
1124  int i, packet_bytes, sub_packet_size, sub_packets_D;
1125  unsigned int next_index = 0;
1126 
1127  memset(q->tone_level_idx_hi1, 0, sizeof(q->tone_level_idx_hi1));
1128  memset(q->tone_level_idx_mid, 0, sizeof(q->tone_level_idx_mid));
1129  memset(q->tone_level_idx_hi2, 0, sizeof(q->tone_level_idx_hi2));
1130 
1131  q->sub_packets_B = 0;
1132  sub_packets_D = 0;
1133 
1134  average_quantized_coeffs(q); // average elements in quantized_coeffs[max_ch][10][8]
1135 
1138 
1139  if (header.type < 2 || header.type >= 8) {
1140  q->has_errors = 1;
1141  av_log(NULL, AV_LOG_ERROR, "bad superblock type\n");
1142  return;
1143  }
1144 
1145  q->superblocktype_2_3 = (header.type == 2 || header.type == 3);
1146  packet_bytes = (q->compressed_size - get_bits_count(&gb) / 8);
1147 
1148  init_get_bits(&gb, header.data, header.size * 8);
1149 
1150  if (header.type == 2 || header.type == 4 || header.type == 5) {
1151  int csum = 257 * get_bits(&gb, 8);
1152  csum += 2 * get_bits(&gb, 8);
1153 
1154  csum = qdm2_packet_checksum(q->compressed_data, q->checksum_size, csum);
1155 
1156  if (csum != 0) {
1157  q->has_errors = 1;
1158  av_log(NULL, AV_LOG_ERROR, "bad packet checksum\n");
1159  return;
1160  }
1161  }
1162 
1163  q->sub_packet_list_B[0].packet = NULL;
1164  q->sub_packet_list_D[0].packet = NULL;
1165 
1166  for (i = 0; i < 6; i++)
1167  if (--q->fft_level_exp[i] < 0)
1168  q->fft_level_exp[i] = 0;
1169 
1170  for (i = 0; packet_bytes > 0; i++) {
1171  int j;
1172 
1173  if (i >= FF_ARRAY_ELEMS(q->sub_packet_list_A)) {
1174  SAMPLES_NEEDED_2("too many packet bytes");
1175  return;
1176  }
1177 
1178  q->sub_packet_list_A[i].next = NULL;
1179 
1180  if (i > 0) {
1181  q->sub_packet_list_A[i - 1].next = &q->sub_packet_list_A[i];
1182 
1183  /* seek to next block */
1184  init_get_bits(&gb, header.data, header.size * 8);
1185  skip_bits(&gb, next_index * 8);
1186 
1187  if (next_index >= header.size)
1188  break;
1189  }
1190 
1191  /* decode subpacket */
1192  packet = &q->sub_packets[i];
1193  qdm2_decode_sub_packet_header(&gb, packet);
1194  next_index = packet->size + get_bits_count(&gb) / 8;
1195  sub_packet_size = ((packet->size > 0xff) ? 1 : 0) + packet->size + 2;
1196 
1197  if (packet->type == 0)
1198  break;
1199 
1200  if (sub_packet_size > packet_bytes) {
1201  if (packet->type != 10 && packet->type != 11 && packet->type != 12)
1202  break;
1203  packet->size += packet_bytes - sub_packet_size;
1204  }
1205 
1206  packet_bytes -= sub_packet_size;
1207 
1208  /* add subpacket to 'all subpackets' list */
1209  q->sub_packet_list_A[i].packet = packet;
1210 
1211  /* add subpacket to related list */
1212  if (packet->type == 8) {
1213  SAMPLES_NEEDED_2("packet type 8");
1214  return;
1215  } else if (packet->type >= 9 && packet->type <= 12) {
1216  /* packets for MPEG Audio like Synthesis Filter */
1217  QDM2_LIST_ADD(q->sub_packet_list_D, sub_packets_D, packet);
1218  } else if (packet->type == 13) {
1219  for (j = 0; j < 6; j++)
1220  q->fft_level_exp[j] = get_bits(&gb, 6);
1221  } else if (packet->type == 14) {
1222  for (j = 0; j < 6; j++)
1223  q->fft_level_exp[j] = qdm2_get_vlc(&gb, &fft_level_exp_vlc, 0, 2);
1224  } else if (packet->type == 15) {
1225  SAMPLES_NEEDED_2("packet type 15")
1226  return;
1227  } else if (packet->type >= 16 && packet->type < 48 &&
1228  !fft_subpackets[packet->type - 16]) {
1229  /* packets for FFT */
1231  }
1232  } // Packet bytes loop
1233 
1234  if (q->sub_packet_list_D[0].packet) {
1236  q->do_synth_filter = 1;
1237  } else if (q->do_synth_filter) {
1241  }
1242 }
1243 
1244 static void qdm2_fft_init_coefficient(QDM2Context *q, int sub_packet,
1245  int offset, int duration, int channel,
1246  int exp, int phase)
1247 {
1248  if (q->fft_coefs_min_index[duration] < 0)
1250 
1252  ((sub_packet >= 16) ? (sub_packet - 16) : sub_packet);
1255  q->fft_coefs[q->fft_coefs_index].exp = exp;
1256  q->fft_coefs[q->fft_coefs_index].phase = phase;
1257  q->fft_coefs_index++;
1258 }
1259 
1261  GetBitContext *gb, int b)
1262 {
1263  int channel, stereo, phase, exp;
1264  int local_int_4, local_int_8, stereo_phase, local_int_10;
1265  int local_int_14, stereo_exp, local_int_20, local_int_28;
1266  int n, offset;
1267 
1268  local_int_4 = 0;
1269  local_int_28 = 0;
1270  local_int_20 = 2;
1271  local_int_8 = (4 - duration);
1272  local_int_10 = 1 << (q->group_order - duration - 1);
1273  offset = 1;
1274 
1275  while (get_bits_left(gb)>0) {
1276  if (q->superblocktype_2_3) {
1277  while ((n = qdm2_get_vlc(gb, &vlc_tab_fft_tone_offset[local_int_8], 1, 2)) < 2) {
1278  if (get_bits_left(gb)<0) {
1279  if(local_int_4 < q->group_size)
1280  av_log(NULL, AV_LOG_ERROR, "overread in qdm2_fft_decode_tones()\n");
1281  return;
1282  }
1283  offset = 1;
1284  if (n == 0) {
1285  local_int_4 += local_int_10;
1286  local_int_28 += (1 << local_int_8);
1287  } else {
1288  local_int_4 += 8 * local_int_10;
1289  local_int_28 += (8 << local_int_8);
1290  }
1291  }
1292  offset += (n - 2);
1293  } else {
1294  if (local_int_10 <= 2) {
1295  av_log(NULL, AV_LOG_ERROR, "qdm2_fft_decode_tones() stuck\n");
1296  return;
1297  }
1298  offset += qdm2_get_vlc(gb, &vlc_tab_fft_tone_offset[local_int_8], 1, 2);
1299  while (offset >= (local_int_10 - 1)) {
1300  offset += (1 - (local_int_10 - 1));
1301  local_int_4 += local_int_10;
1302  local_int_28 += (1 << local_int_8);
1303  }
1304  }
1305 
1306  if (local_int_4 >= q->group_size)
1307  return;
1308 
1309  local_int_14 = (offset >> local_int_8);
1310  if (local_int_14 >= FF_ARRAY_ELEMS(fft_level_index_table))
1311  return;
1312 
1313  if (q->nb_channels > 1) {
1314  channel = get_bits1(gb);
1315  stereo = get_bits1(gb);
1316  } else {
1317  channel = 0;
1318  stereo = 0;
1319  }
1320 
1322  exp += q->fft_level_exp[fft_level_index_table[local_int_14]];
1323  exp = (exp < 0) ? 0 : exp;
1324 
1325  phase = get_bits(gb, 3);
1326  stereo_exp = 0;
1327  stereo_phase = 0;
1328 
1329  if (stereo) {
1330  stereo_exp = (exp - qdm2_get_vlc(gb, &fft_stereo_exp_vlc, 0, 1));
1331  stereo_phase = (phase - qdm2_get_vlc(gb, &fft_stereo_phase_vlc, 0, 1));
1332  if (stereo_phase < 0)
1333  stereo_phase += 8;
1334  }
1335 
1336  if (q->frequency_range > (local_int_14 + 1)) {
1337  int sub_packet = (local_int_20 + local_int_28);
1338 
1339  if (q->fft_coefs_index + stereo >= FF_ARRAY_ELEMS(q->fft_coefs))
1340  return;
1341 
1342  qdm2_fft_init_coefficient(q, sub_packet, offset, duration,
1343  channel, exp, phase);
1344  if (stereo)
1345  qdm2_fft_init_coefficient(q, sub_packet, offset, duration,
1346  1 - channel,
1347  stereo_exp, stereo_phase);
1348  }
1349  offset++;
1350  }
1351 }
1352 
1354 {
1355  int i, j, min, max, value, type, unknown_flag;
1356  GetBitContext gb;
1357 
1358  if (!q->sub_packet_list_B[0].packet)
1359  return;
1360 
1361  /* reset minimum indexes for FFT coefficients */
1362  q->fft_coefs_index = 0;
1363  for (i = 0; i < 5; i++)
1364  q->fft_coefs_min_index[i] = -1;
1365 
1366  /* process subpackets ordered by type, largest type first */
1367  for (i = 0, max = 256; i < q->sub_packets_B; i++) {
1368  QDM2SubPacket *packet = NULL;
1369 
1370  /* find subpacket with largest type less than max */
1371  for (j = 0, min = 0; j < q->sub_packets_B; j++) {
1373  if (value > min && value < max) {
1374  min = value;
1375  packet = q->sub_packet_list_B[j].packet;
1376  }
1377  }
1378 
1379  max = min;
1380 
1381  /* check for errors (?) */
1382  if (!packet)
1383  return;
1384 
1385  if (i == 0 &&
1386  (packet->type < 16 || packet->type >= 48 ||
1387  fft_subpackets[packet->type - 16]))
1388  return;
1389 
1390  /* decode FFT tones */
1391  init_get_bits(&gb, packet->data, packet->size * 8);
1392 
1393  if (packet->type >= 32 && packet->type < 48 && !fft_subpackets[packet->type - 16])
1394  unknown_flag = 1;
1395  else
1396  unknown_flag = 0;
1397 
1398  type = packet->type;
1399 
1400  if ((type >= 17 && type < 24) || (type >= 33 && type < 40)) {
1401  int duration = q->sub_sampling + 5 - (type & 15);
1402 
1403  if (duration >= 0 && duration < 4)
1404  qdm2_fft_decode_tones(q, duration, &gb, unknown_flag);
1405  } else if (type == 31) {
1406  for (j = 0; j < 4; j++)
1407  qdm2_fft_decode_tones(q, j, &gb, unknown_flag);
1408  } else if (type == 46) {
1409  for (j = 0; j < 6; j++)
1410  q->fft_level_exp[j] = get_bits(&gb, 6);
1411  for (j = 0; j < 4; j++)
1412  qdm2_fft_decode_tones(q, j, &gb, unknown_flag);
1413  }
1414  } // Loop on B packets
1415 
1416  /* calculate maximum indexes for FFT coefficients */
1417  for (i = 0, j = -1; i < 5; i++)
1418  if (q->fft_coefs_min_index[i] >= 0) {
1419  if (j >= 0)
1421  j = i;
1422  }
1423  if (j >= 0)
1425 }
1426 
1428 {
1429  float level, f[6];
1430  int i;
1431  QDM2Complex c;
1432  const double iscale = 2.0 * M_PI / 512.0;
1433 
1434  tone->phase += tone->phase_shift;
1435 
1436  /* calculate current level (maximum amplitude) of tone */
1437  level = fft_tone_envelope_table[tone->duration][tone->time_index] * tone->level;
1438  c.im = level * sin(tone->phase * iscale);
1439  c.re = level * cos(tone->phase * iscale);
1440 
1441  /* generate FFT coefficients for tone */
1442  if (tone->duration >= 3 || tone->cutoff >= 3) {
1443  tone->complex[0].im += c.im;
1444  tone->complex[0].re += c.re;
1445  tone->complex[1].im -= c.im;
1446  tone->complex[1].re -= c.re;
1447  } else {
1448  f[1] = -tone->table[4];
1449  f[0] = tone->table[3] - tone->table[0];
1450  f[2] = 1.0 - tone->table[2] - tone->table[3];
1451  f[3] = tone->table[1] + tone->table[4] - 1.0;
1452  f[4] = tone->table[0] - tone->table[1];
1453  f[5] = tone->table[2];
1454  for (i = 0; i < 2; i++) {
1455  tone->complex[fft_cutoff_index_table[tone->cutoff][i]].re +=
1456  c.re * f[i];
1457  tone->complex[fft_cutoff_index_table[tone->cutoff][i]].im +=
1458  c.im * ((tone->cutoff <= i) ? -f[i] : f[i]);
1459  }
1460  for (i = 0; i < 4; i++) {
1461  tone->complex[i].re += c.re * f[i + 2];
1462  tone->complex[i].im += c.im * f[i + 2];
1463  }
1464  }
1465 
1466  /* copy the tone if it has not yet died out */
1467  if (++tone->time_index < ((1 << (5 - tone->duration)) - 1)) {
1468  memcpy(&q->fft_tones[q->fft_tone_end], tone, sizeof(FFTTone));
1469  q->fft_tone_end = (q->fft_tone_end + 1) % 1000;
1470  }
1471 }
1472 
1473 static void qdm2_fft_tone_synthesizer(QDM2Context *q, int sub_packet)
1474 {
1475  int i, j, ch;
1476  const double iscale = 0.25 * M_PI;
1477 
1478  for (ch = 0; ch < q->channels; ch++) {
1479  memset(q->fft.complex[ch], 0, q->fft_size * sizeof(QDM2Complex));
1480  }
1481 
1482 
1483  /* apply FFT tones with duration 4 (1 FFT period) */
1484  if (q->fft_coefs_min_index[4] >= 0)
1485  for (i = q->fft_coefs_min_index[4]; i < q->fft_coefs_max_index[4]; i++) {
1486  float level;
1487  QDM2Complex c;
1488 
1489  if (q->fft_coefs[i].sub_packet != sub_packet)
1490  break;
1491 
1492  ch = (q->channels == 1) ? 0 : q->fft_coefs[i].channel;
1493  level = (q->fft_coefs[i].exp < 0) ? 0.0 : fft_tone_level_table[q->superblocktype_2_3 ? 0 : 1][q->fft_coefs[i].exp & 63];
1494 
1495  c.re = level * cos(q->fft_coefs[i].phase * iscale);
1496  c.im = level * sin(q->fft_coefs[i].phase * iscale);
1497  q->fft.complex[ch][q->fft_coefs[i].offset + 0].re += c.re;
1498  q->fft.complex[ch][q->fft_coefs[i].offset + 0].im += c.im;
1499  q->fft.complex[ch][q->fft_coefs[i].offset + 1].re -= c.re;
1500  q->fft.complex[ch][q->fft_coefs[i].offset + 1].im -= c.im;
1501  }
1502 
1503  /* generate existing FFT tones */
1504  for (i = q->fft_tone_end; i != q->fft_tone_start; ) {
1506  q->fft_tone_start = (q->fft_tone_start + 1) % 1000;
1507  }
1508 
1509  /* create and generate new FFT tones with duration 0 (long) to 3 (short) */
1510  for (i = 0; i < 4; i++)
1511  if (q->fft_coefs_min_index[i] >= 0) {
1512  for (j = q->fft_coefs_min_index[i]; j < q->fft_coefs_max_index[i]; j++) {
1513  int offset, four_i;
1514  FFTTone tone;
1515 
1516  if (q->fft_coefs[j].sub_packet != sub_packet)
1517  break;
1518 
1519  four_i = (4 - i);
1520  offset = q->fft_coefs[j].offset >> four_i;
1521  ch = (q->channels == 1) ? 0 : q->fft_coefs[j].channel;
1522 
1523  if (offset < q->frequency_range) {
1524  if (offset < 2)
1525  tone.cutoff = offset;
1526  else
1527  tone.cutoff = (offset >= 60) ? 3 : 2;
1528 
1529  tone.level = (q->fft_coefs[j].exp < 0) ? 0.0 : fft_tone_level_table[q->superblocktype_2_3 ? 0 : 1][q->fft_coefs[j].exp & 63];
1530  tone.complex = &q->fft.complex[ch][offset];
1531  tone.table = fft_tone_sample_table[i][q->fft_coefs[j].offset - (offset << four_i)];
1532  tone.phase = 64 * q->fft_coefs[j].phase - (offset << 8) - 128;
1533  tone.phase_shift = (2 * q->fft_coefs[j].offset + 1) << (7 - four_i);
1534  tone.duration = i;
1535  tone.time_index = 0;
1536 
1537  qdm2_fft_generate_tone(q, &tone);
1538  }
1539  }
1540  q->fft_coefs_min_index[i] = j;
1541  }
1542 }
1543 
1544 static void qdm2_calculate_fft(QDM2Context *q, int channel, int sub_packet)
1545 {
1546  const float gain = (q->channels == 1 && q->nb_channels == 2) ? 0.5f : 1.0f;
1547  float *out = q->output_buffer + channel;
1548  int i;
1549  q->fft.complex[channel][0].re *= 2.0f;
1550  q->fft.complex[channel][0].im = 0.0f;
1552  /* add samples to output buffer */
1553  for (i = 0; i < FFALIGN(q->fft_size, 8); i++) {
1554  out[0] += q->fft.complex[channel][i].re * gain;
1555  out[q->channels] += q->fft.complex[channel][i].im * gain;
1556  out += 2 * q->channels;
1557  }
1558 }
1559 
1560 /**
1561  * @param q context
1562  * @param index subpacket number
1563  */
1565 {
1566  int i, k, ch, sb_used, sub_sampling, dither_state = 0;
1567 
1568  /* copy sb_samples */
1569  sb_used = QDM2_SB_USED(q->sub_sampling);
1570 
1571  for (ch = 0; ch < q->channels; ch++)
1572  for (i = 0; i < 8; i++)
1573  for (k = sb_used; k < SBLIMIT; k++)
1574  q->sb_samples[ch][(8 * index) + i][k] = 0;
1575 
1576  for (ch = 0; ch < q->nb_channels; ch++) {
1577  float *samples_ptr = q->samples + ch;
1578 
1579  for (i = 0; i < 8; i++) {
1581  q->synth_buf[ch], &(q->synth_buf_offset[ch]),
1582  ff_mpa_synth_window_float, &dither_state,
1583  samples_ptr, q->nb_channels,
1584  q->sb_samples[ch][(8 * index) + i]);
1585  samples_ptr += 32 * q->nb_channels;
1586  }
1587  }
1588 
1589  /* add samples to output buffer */
1590  sub_sampling = (4 >> q->sub_sampling);
1591 
1592  for (ch = 0; ch < q->channels; ch++)
1593  for (i = 0; i < q->frame_size; i++)
1594  q->output_buffer[q->channels * i + ch] += (1 << 23) * q->samples[q->nb_channels * sub_sampling * i + ch];
1595 }
1596 
1597 /**
1598  * Init static data (does not depend on specific file)
1599  */
1600 static av_cold void qdm2_init_static_data(void) {
1601  qdm2_init_vlc();
1603  rnd_table_init();
1605 
1607 }
1608 
1609 /**
1610  * Init parameters from codec extradata
1611  */
1613 {
1614  static AVOnce init_static_once = AV_ONCE_INIT;
1615  QDM2Context *s = avctx->priv_data;
1616  int tmp_val, tmp, size;
1617  GetByteContext gb;
1618 
1619  /* extradata parsing
1620 
1621  Structure:
1622  wave {
1623  frma (QDM2)
1624  QDCA
1625  QDCP
1626  }
1627 
1628  32 size (including this field)
1629  32 tag (=frma)
1630  32 type (=QDM2 or QDMC)
1631 
1632  32 size (including this field, in bytes)
1633  32 tag (=QDCA) // maybe mandatory parameters
1634  32 unknown (=1)
1635  32 channels (=2)
1636  32 samplerate (=44100)
1637  32 bitrate (=96000)
1638  32 block size (=4096)
1639  32 frame size (=256) (for one channel)
1640  32 packet size (=1300)
1641 
1642  32 size (including this field, in bytes)
1643  32 tag (=QDCP) // maybe some tuneable parameters
1644  32 float1 (=1.0)
1645  32 zero ?
1646  32 float2 (=1.0)
1647  32 float3 (=1.0)
1648  32 unknown (27)
1649  32 unknown (8)
1650  32 zero ?
1651  */
1652 
1653  if (!avctx->extradata || (avctx->extradata_size < 48)) {
1654  av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n");
1655  return AVERROR_INVALIDDATA;
1656  }
1657 
1658  bytestream2_init(&gb, avctx->extradata, avctx->extradata_size);
1659 
1660  while (bytestream2_get_bytes_left(&gb) > 8) {
1661  if (bytestream2_peek_be64(&gb) == (((uint64_t)MKBETAG('f','r','m','a') << 32) |
1662  (uint64_t)MKBETAG('Q','D','M','2')))
1663  break;
1664  bytestream2_skip(&gb, 1);
1665  }
1666 
1667  if (bytestream2_get_bytes_left(&gb) < 12) {
1668  av_log(avctx, AV_LOG_ERROR, "not enough extradata (%i)\n",
1670  return AVERROR_INVALIDDATA;
1671  }
1672 
1673  bytestream2_skip(&gb, 8);
1674  size = bytestream2_get_be32(&gb);
1675 
1676  if (size > bytestream2_get_bytes_left(&gb)) {
1677  av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n",
1679  return AVERROR_INVALIDDATA;
1680  }
1681 
1682  av_log(avctx, AV_LOG_DEBUG, "size: %d\n", size);
1683  if (bytestream2_get_be32(&gb) != MKBETAG('Q','D','C','A')) {
1684  av_log(avctx, AV_LOG_ERROR, "invalid extradata, expecting QDCA\n");
1685  return AVERROR_INVALIDDATA;
1686  }
1687 
1688  bytestream2_skip(&gb, 4);
1689 
1690  avctx->channels = s->nb_channels = s->channels = bytestream2_get_be32(&gb);
1691  if (s->channels <= 0 || s->channels > MPA_MAX_CHANNELS) {
1692  av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");
1693  return AVERROR_INVALIDDATA;
1694  }
1695  avctx->channel_layout = avctx->channels == 2 ? AV_CH_LAYOUT_STEREO :
1697 
1698  avctx->sample_rate = bytestream2_get_be32(&gb);
1699  avctx->bit_rate = bytestream2_get_be32(&gb);
1700  s->group_size = bytestream2_get_be32(&gb);
1701  s->fft_size = bytestream2_get_be32(&gb);
1702  s->checksum_size = bytestream2_get_be32(&gb);
1703  if (s->checksum_size >= 1U << 28 || s->checksum_size <= 1) {
1704  av_log(avctx, AV_LOG_ERROR, "data block size invalid (%u)\n", s->checksum_size);
1705  return AVERROR_INVALIDDATA;
1706  }
1707 
1708  s->fft_order = av_log2(s->fft_size) + 1;
1709 
1710  // Fail on unknown fft order
1711  if ((s->fft_order < 7) || (s->fft_order > 9)) {
1712  avpriv_request_sample(avctx, "Unknown FFT order %d", s->fft_order);
1713  return AVERROR_PATCHWELCOME;
1714  }
1715 
1716  // something like max decodable tones
1717  s->group_order = av_log2(s->group_size) + 1;
1718  s->frame_size = s->group_size / 16; // 16 iterations per super block
1719 
1720  if (s->frame_size > QDM2_MAX_FRAME_SIZE)
1721  return AVERROR_INVALIDDATA;
1722 
1723  s->sub_sampling = s->fft_order - 7;
1724  s->frequency_range = 255 / (1 << (2 - s->sub_sampling));
1725 
1726  if (s->frame_size * 4 >> s->sub_sampling > MPA_FRAME_SIZE) {
1727  avpriv_request_sample(avctx, "large frames");
1728  return AVERROR_PATCHWELCOME;
1729  }
1730 
1731  switch ((s->sub_sampling * 2 + s->channels - 1)) {
1732  case 0: tmp = 40; break;
1733  case 1: tmp = 48; break;
1734  case 2: tmp = 56; break;
1735  case 3: tmp = 72; break;
1736  case 4: tmp = 80; break;
1737  case 5: tmp = 100;break;
1738  default: tmp=s->sub_sampling; break;
1739  }
1740  tmp_val = 0;
1741  if ((tmp * 1000) < avctx->bit_rate) tmp_val = 1;
1742  if ((tmp * 1440) < avctx->bit_rate) tmp_val = 2;
1743  if ((tmp * 1760) < avctx->bit_rate) tmp_val = 3;
1744  if ((tmp * 2240) < avctx->bit_rate) tmp_val = 4;
1745  s->cm_table_select = tmp_val;
1746 
1747  if (avctx->bit_rate <= 8000)
1748  s->coeff_per_sb_select = 0;
1749  else if (avctx->bit_rate < 16000)
1750  s->coeff_per_sb_select = 1;
1751  else
1752  s->coeff_per_sb_select = 2;
1753 
1754  if (s->fft_size != (1 << (s->fft_order - 1))) {
1755  av_log(avctx, AV_LOG_ERROR, "FFT size %d not power of 2.\n", s->fft_size);
1756  return AVERROR_INVALIDDATA;
1757  }
1758 
1759  ff_rdft_init(&s->rdft_ctx, s->fft_order, IDFT_C2R);
1760  ff_mpadsp_init(&s->mpadsp);
1761 
1762  avctx->sample_fmt = AV_SAMPLE_FMT_S16;
1763 
1764  ff_thread_once(&init_static_once, qdm2_init_static_data);
1765 
1766  return 0;
1767 }
1768 
1770 {
1771  QDM2Context *s = avctx->priv_data;
1772 
1773  ff_rdft_end(&s->rdft_ctx);
1774 
1775  return 0;
1776 }
1777 
1778 static int qdm2_decode(QDM2Context *q, const uint8_t *in, int16_t *out)
1779 {
1780  int ch, i;
1781  const int frame_size = (q->frame_size * q->channels);
1782 
1783  if((unsigned)frame_size > FF_ARRAY_ELEMS(q->output_buffer)/2)
1784  return -1;
1785 
1786  /* select input buffer */
1787  q->compressed_data = in;
1789 
1790  /* copy old block, clear new block of output samples */
1791  memmove(q->output_buffer, &q->output_buffer[frame_size], frame_size * sizeof(float));
1792  memset(&q->output_buffer[frame_size], 0, frame_size * sizeof(float));
1793 
1794  /* decode block of QDM2 compressed data */
1795  if (q->sub_packet == 0) {
1796  q->has_errors = 0; // zero it for a new super block
1797  av_log(NULL,AV_LOG_DEBUG,"Superblock follows\n");
1799  }
1800 
1801  /* parse subpackets */
1802  if (!q->has_errors) {
1803  if (q->sub_packet == 2)
1805 
1807  }
1808 
1809  /* sound synthesis stage 1 (FFT) */
1810  for (ch = 0; ch < q->channels; ch++) {
1811  qdm2_calculate_fft(q, ch, q->sub_packet);
1812 
1813  if (!q->has_errors && q->sub_packet_list_C[0].packet) {
1814  SAMPLES_NEEDED_2("has errors, and C list is not empty")
1815  return -1;
1816  }
1817  }
1818 
1819  /* sound synthesis stage 2 (MPEG audio like synthesis filter) */
1820  if (!q->has_errors && q->do_synth_filter)
1822 
1823  q->sub_packet = (q->sub_packet + 1) % 16;
1824 
1825  /* clip and convert output float[] to 16-bit signed samples */
1826  for (i = 0; i < frame_size; i++) {
1827  int value = (int)q->output_buffer[i];
1828 
1831  else if (value < -SOFTCLIP_THRESHOLD)
1833 
1834  out[i] = value;
1835  }
1836 
1837  return 0;
1838 }
1839 
1840 static int qdm2_decode_frame(AVCodecContext *avctx, void *data,
1841  int *got_frame_ptr, AVPacket *avpkt)
1842 {
1843  AVFrame *frame = data;
1844  const uint8_t *buf = avpkt->data;
1845  int buf_size = avpkt->size;
1846  QDM2Context *s = avctx->priv_data;
1847  int16_t *out;
1848  int i, ret;
1849 
1850  if(!buf)
1851  return 0;
1852  if(buf_size < s->checksum_size)
1853  return -1;
1854 
1855  /* get output buffer */
1856  frame->nb_samples = 16 * s->frame_size;
1857  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1858  return ret;
1859  out = (int16_t *)frame->data[0];
1860 
1861  for (i = 0; i < 16; i++) {
1862  if ((ret = qdm2_decode(s, buf, out)) < 0)
1863  return ret;
1864  out += s->channels * s->frame_size;
1865  }
1866 
1867  *got_frame_ptr = 1;
1868 
1869  return s->checksum_size;
1870 }
1871 
1873  .name = "qdm2",
1874  .long_name = NULL_IF_CONFIG_SMALL("QDesign Music Codec 2"),
1875  .type = AVMEDIA_TYPE_AUDIO,
1876  .id = AV_CODEC_ID_QDM2,
1877  .priv_data_size = sizeof(QDM2Context),
1879  .close = qdm2_decode_close,
1881  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1882  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
1883 };
SAMPLES_NEEDED_2
#define SAMPLES_NEEDED_2(why)
Definition: qdm2.c:75
fft_stereo_exp_vlc
static VLC fft_stereo_exp_vlc
Definition: qdm2_tablegen.h:103
AVCodec
AVCodec.
Definition: codec.h:197
QDM2Context::fft_tone_end
int fft_tone_end
Definition: qdm2.c:158
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
qdm2_decode_frame
static int qdm2_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: qdm2.c:1840
fft_level_index_table
static const int16_t fft_level_index_table[256]
Definition: qdm2data.h:168
level
uint8_t level
Definition: svq3.c:204
QDM2Context::mpadsp
MPADSPContext mpadsp
Synthesis filter.
Definition: qdm2.c:173
vlc_tab_type30
static VLC vlc_tab_type30
Definition: qdm2_tablegen.h:108
vlc_tab_type34
static VLC vlc_tab_type34
Definition: qdm2_tablegen.h:109
QDM2Context::quantized_coeffs
int8_t quantized_coeffs[MPA_MAX_CHANNELS][10][8]
Definition: qdm2.c:182
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:850
acc
int acc
Definition: yuv2rgb.c:554
ff_qdm2_decoder
const AVCodec ff_qdm2_decoder
Definition: qdm2.c:1872
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1039
mem_internal.h
fix_coding_method_array
static int fix_coding_method_array(int sb, int channels, sb_int8_array coding_method)
Called while processing data from subpackets 11 and 12.
Definition: qdm2.c:372
QDM2Context::frequency_range
int frequency_range
Definition: qdm2.c:142
out
FILE * out
Definition: movenc.c:54
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:988
FFTCoefficient
Definition: qdm2.c:115
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:85
GetByteContext
Definition: bytestream.h:33
QDM2Context::synth_buf_offset
int synth_buf_offset[MPA_MAX_CHANNELS]
Definition: qdm2.c:175
thread.h
QDM2Context::sub_packet
int sub_packet
Definition: qdm2.c:195
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:90
rdft.h
random_dequant_index
static uint8_t random_dequant_index[256][5]
Definition: qdm2_tablegen.h:43
QDM2Complex::im
float im
Definition: qdm2.c:101
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:220
ff_mpadsp_init
av_cold void ff_mpadsp_init(MPADSPContext *s)
Definition: mpegaudiodsp.c:81
qdm2_init_static_data
static av_cold void qdm2_init_static_data(void)
Init static data (does not depend on specific file)
Definition: qdm2.c:1600
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
index
fg index
Definition: ffmpeg_filter.c:168
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
MPADSPContext
Definition: mpegaudiodsp.h:27
QDM2Context::sub_packets_B
int sub_packets_B
number of packets on 'B' list
Definition: qdm2.c:151
coding_method_table
static const int8_t coding_method_table[5][30]
Definition: qdm2data.h:272
b
#define b
Definition: input.c:40
data
const char data[16]
Definition: mxf.c:143
QDM2Context::fft_tone_start
int fft_tone_start
Definition: qdm2.c:157
get_vlc2
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:798
QDM2Context::group_order
int group_order
Parameters built from header parameters, do not change during playback.
Definition: qdm2.c:139
max
#define max(a, b)
Definition: cuda_runtime.h:33
vlc_tab_tone_level_idx_hi1
static VLC vlc_tab_tone_level_idx_hi1
Definition: qdm2_tablegen.h:105
FFTTone::time_index
short time_index
Definition: qdm2.c:111
SOFTCLIP_THRESHOLD
#define SOFTCLIP_THRESHOLD
Definition: qdm2_tablegen.h:31
softclip_table
static uint16_t softclip_table[HARDCLIP_THRESHOLD - SOFTCLIP_THRESHOLD+1]
Definition: qdm2_tablegen.h:41
QDM2Context::synth_buf
float synth_buf[MPA_MAX_CHANNELS][512 *2]
Definition: qdm2.c:174
QDM2Context::sub_packet_list_A
QDM2SubPNode sub_packet_list_A[16]
list of all packets
Definition: qdm2.c:149
QDM2FFT
Definition: qdm2.c:123
QDM2Complex::re
float re
Definition: qdm2.c:100
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
qdm2_decode
static int qdm2_decode(QDM2Context *q, const uint8_t *in, int16_t *out)
Definition: qdm2.c:1778
process_subpacket_11
static void process_subpacket_11(QDM2Context *q, QDM2SubPNode *node)
Process subpacket 11.
Definition: qdm2.c:1040
QDM2Context::has_errors
int has_errors
packet has errors
Definition: qdm2.c:191
QDM2Context::checksum_size
int checksum_size
size of data block, used also for checksum
Definition: qdm2.c:136
QDM2Context::frame_size
int frame_size
size of data frame
Definition: qdm2.c:141
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:468
synthfilt_build_sb_samples
static int synthfilt_build_sb_samples(QDM2Context *q, GetBitContext *gb, int length, int sb_min, int sb_max)
Called by process_subpacket_11 to process more data from subpacket 11 with sb 0-8.
Definition: qdm2.c:659
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
QDM2FFT::complex
QDM2Complex complex[MPA_MAX_CHANNELS][256]
Definition: qdm2.c:124
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
init_noise_samples
static av_cold void init_noise_samples(void)
Definition: qdm2_tablegen.h:88
U
#define U(x)
Definition: vp56_arith.h:37
QDM2Context::output_buffer
float output_buffer[QDM2_MAX_FRAME_SIZE *MPA_MAX_CHANNELS *2]
Definition: qdm2.c:170
FFTCoefficient::channel
uint8_t channel
Definition: qdm2.c:117
build_sb_samples_from_noise
static void build_sb_samples_from_noise(QDM2Context *q, int sb)
Build subband samples with noise weighted by q->tone_level.
Definition: qdm2.c:345
GetBitContext
Definition: get_bits.h:62
tab
static const struct twinvq_data tab
Definition: twinvq_data.h:10345
process_synthesis_subpackets
static void process_synthesis_subpackets(QDM2Context *q, QDM2SubPNode *list)
Process new subpackets for synthesis filter.
Definition: qdm2.c:1088
IDFT_C2R
@ IDFT_C2R
Definition: avfft.h:73
ff_rdft_end
av_cold void ff_rdft_end(RDFTContext *s)
Definition: rdft.c:114
QDM2Context::sub_packet_list_C
QDM2SubPNode sub_packet_list_C[16]
packets with errors?
Definition: qdm2.c:152
QDM2SubPacket::data
const uint8_t * data
pointer to subpacket data (points to input data buffer, it's not a private copy)
Definition: qdm2.c:88
switchtable
static const int switchtable[23]
Definition: qdm2.c:199
QDM2Context::fft_coefs
FFTCoefficient fft_coefs[1000]
Definition: qdm2.c:159
fill_coding_method_array
static void fill_coding_method_array(sb_int8_array tone_level_idx, sb_int8_array tone_level_idx_temp, sb_int8_array coding_method, int nb_channels, int c, int superblocktype_2_3, int cm_table_select)
Related to synthesis filter Called by process_subpacket_11 c is built with data from subpacket 11 Mos...
Definition: qdm2.c:532
vlc_tab_level
static VLC vlc_tab_level
Definition: qdm2_tablegen.h:98
rnd_table_init
static av_cold void rnd_table_init(void)
Definition: qdm2_tablegen.h:57
qdm2_fft_init_coefficient
static void qdm2_fft_init_coefficient(QDM2Context *q, int sub_packet, int offset, int duration, int channel, int exp, int phase)
Definition: qdm2.c:1244
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
ff_mpa_synth_window_float
float ff_mpa_synth_window_float[]
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:91
vlc_tab_run
static VLC vlc_tab_run
Definition: qdm2_tablegen.h:100
process_subpacket_9
static int process_subpacket_9(QDM2Context *q, QDM2SubPNode *node)
Process subpacket 9, init quantized_coeffs with data from it.
Definition: qdm2.c:979
MPA_FRAME_SIZE
#define MPA_FRAME_SIZE
Definition: mpegaudio.h:37
QDM2SubPacket::size
unsigned int size
subpacket size
Definition: qdm2.c:87
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
qdm2_decode_super_block
static void qdm2_decode_super_block(QDM2Context *q)
Decode superblock, fill packet lists.
Definition: qdm2.c:1120
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
qdm2_fft_decode_tones
static void qdm2_fft_decode_tones(QDM2Context *q, int duration, GetBitContext *gb, int b)
Definition: qdm2.c:1260
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
fft_tone_level_table
static const float fft_tone_level_table[2][64]
Definition: qdm2data.h:368
QDM2Context::compressed_data
const uint8_t * compressed_data
I/O data.
Definition: qdm2.c:168
dequant_1bit
static const float dequant_1bit[2][3]
Definition: qdm2data.h:446
duration
int64_t duration
Definition: movenc.c:64
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:481
FFTCoefficient::phase
uint8_t phase
Definition: qdm2.c:120
FIX_NOISE_IDX
#define FIX_NOISE_IDX(noise_idx)
Definition: qdm2.c:66
s
#define s(width, name)
Definition: cbs_vp9.c:257
qdm2_tablegen.h
QDM2Context::rdft_ctx
RDFTContext rdft_ctx
Definition: qdm2.c:164
frame_size
int frame_size
Definition: mxfenc.c:2206
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
QDM2SubPNode::next
struct QDM2SubPNode * next
pointer to next packet in the list, NULL if leaf node
Definition: qdm2.c:96
HARDCLIP_THRESHOLD
#define HARDCLIP_THRESHOLD
Definition: qdm2_tablegen.h:32
QDM2SubPNode
A node in the subpacket list.
Definition: qdm2.c:94
QDM2_LIST_ADD
#define QDM2_LIST_ADD(list, size, packet)
Definition: qdm2.c:53
QDM2Context::do_synth_filter
int do_synth_filter
used to perform or skip synthesis filter
Definition: qdm2.c:193
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
coeff_per_sb_for_dequant
static const uint8_t coeff_per_sb_for_dequant[3][30]
Definition: qdm2data.h:230
channels
channels
Definition: aptx.h:33
get_bits.h
SAMPLES_NEEDED
#define SAMPLES_NEEDED
Definition: qdm2.c:72
init_quantized_coeffs_elem0
static int init_quantized_coeffs_elem0(int8_t *quantized_coeffs, GetBitContext *gb)
Init the first element of a channel in quantized_coeffs with data from packet 10 (quantized_coeffs[ch...
Definition: qdm2.c:875
FFTCoefficient::exp
int16_t exp
Definition: qdm2.c:119
FFTTone::level
float level
Definition: qdm2.c:105
f
#define f(width, name)
Definition: cbs_vp9.c:255
if
if(ret)
Definition: filter_design.txt:179
fft_tone_envelope_table
static const float fft_tone_envelope_table[4][31]
Definition: qdm2data.h:406
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:63
qdm2_search_subpacket_type_in_list
static QDM2SubPNode * qdm2_search_subpacket_type_in_list(QDM2SubPNode *list, int type)
Return node pointer to first packet of requested type in list.
Definition: qdm2.c:299
QDM2Context::tone_level
float tone_level[MPA_MAX_CHANNELS][30][64]
Mixed temporary data used in decoding.
Definition: qdm2.c:180
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
qdm2_get_vlc
static int qdm2_get_vlc(GetBitContext *gb, const VLC *vlc, int flag, int depth)
Definition: qdm2.c:203
NULL
#define NULL
Definition: coverity.c:32
QDM2SubPacket
Subpacket.
Definition: qdm2.c:85
QDM2Context::coding_method
int8_t coding_method[MPA_MAX_CHANNELS][30][64]
Definition: qdm2.c:181
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
FFTTone::complex
QDM2Complex * complex
Definition: qdm2.c:106
qdm2_decode_close
static av_cold int qdm2_decode_close(AVCodecContext *avctx)
Definition: qdm2.c:1769
qdm2_packet_checksum
static uint16_t qdm2_packet_checksum(const uint8_t *data, int length, int value)
QDM2 checksum.
Definition: qdm2.c:248
run
uint8_t run
Definition: svq3.c:203
last_coeff
static const uint8_t last_coeff[3]
Definition: qdm2data.h:187
fft_stereo_phase_vlc
static VLC fft_stereo_phase_vlc
Definition: qdm2_tablegen.h:104
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:429
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
list
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
Definition: filter_design.txt:25
qdm2_fft_tone_synthesizer
static void qdm2_fft_tone_synthesizer(QDM2Context *q, int sub_packet)
Definition: qdm2.c:1473
FFTSample
float FFTSample
Definition: avfft.h:35
QDM2Context::sb_samples
float sb_samples[MPA_MAX_CHANNELS][128][SBLIMIT]
Definition: qdm2.c:176
AV_CODEC_ID_QDM2
@ AV_CODEC_ID_QDM2
Definition: codec_id.h:441
QDM2Context::compressed_size
int compressed_size
Definition: qdm2.c:169
SBLIMIT
#define SBLIMIT
Definition: mpegaudio.h:44
exp
int8_t exp
Definition: eval.c:72
AVOnce
#define AVOnce
Definition: thread.h:172
FFTTone::cutoff
short cutoff
Definition: qdm2.c:112
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
process_subpacket_12
static void process_subpacket_12(QDM2Context *q, QDM2SubPNode *node)
Process subpacket 12.
Definition: qdm2.c:1069
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:104
QDM2Context::sub_packet_list_D
QDM2SubPNode sub_packet_list_D[16]
DCT packets.
Definition: qdm2.c:153
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1648
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:374
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:116
QDM2Context::tone_level_idx_base
int8_t tone_level_idx_base[MPA_MAX_CHANNELS][30][8]
Definition: qdm2.c:183
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:996
size
int size
Definition: twinvq_data.h:10344
qdm2_calculate_fft
static void qdm2_calculate_fft(QDM2Context *q, int channel, int sub_packet)
Definition: qdm2.c:1544
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: common.h:479
FFTTone::duration
int duration
Definition: qdm2.c:110
qdm2_decode_init
static av_cold int qdm2_decode_init(AVCodecContext *avctx)
Init parameters from codec extradata.
Definition: qdm2.c:1612
header
static const uint8_t header[24]
Definition: sdr2.c:67
QDM2Context::tone_level_idx
int8_t tone_level_idx[MPA_MAX_CHANNELS][30][64]
Definition: qdm2.c:187
QDM2_SB_USED
#define QDM2_SB_USED(sub_sampling)
Definition: qdm2.c:64
QDM2Context::sub_packets
QDM2SubPacket sub_packets[16]
Packets and packet lists.
Definition: qdm2.c:148
FFTCoefficient::offset
int16_t offset
Definition: qdm2.c:118
QDM2Context::fft_order
int fft_order
order of FFT (actually fftorder+1)
Definition: qdm2.c:140
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
random_dequant_type24
static uint8_t random_dequant_type24[128][3]
Definition: qdm2_tablegen.h:44
vlc_stage3_values
static const int vlc_stage3_values[60]
Definition: qdm2data.h:290
vlc_tab_tone_level_idx_mid
static VLC vlc_tab_tone_level_idx_mid
Definition: qdm2_tablegen.h:106
M_PI
#define M_PI
Definition: mathematics.h:52
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:989
ff_rdft_init
av_cold int ff_rdft_init(RDFTContext *s, int nbits, enum RDFTransformType trans)
Set up a real FFT.
Definition: rdft.c:88
flag
#define flag(name)
Definition: cbs_av1.c:553
fft_subpackets
static const uint8_t fft_subpackets[32]
Definition: qdm2data.h:440
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
vlc_tab_tone_level_idx_hi2
static VLC vlc_tab_tone_level_idx_hi2
Definition: qdm2_tablegen.h:107
QDM2Context::coeff_per_sb_select
int coeff_per_sb_select
selector for "num. of coeffs. per subband" tables. Can be 0, 1, 2
Definition: qdm2.c:144
i
int i
Definition: input.c:406
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:480
QDM2Context::fft_level_exp
int fft_level_exp[6]
Definition: qdm2.c:163
QDM2Context::cm_table_select
int cm_table_select
selector for "coding method" tables. Can be 0, 1 (from init: 0-4)
Definition: qdm2.c:145
RDFTContext
Definition: rdft.h:28
qdm2_decode_fft_packets
static void qdm2_decode_fft_packets(QDM2Context *q)
Definition: qdm2.c:1353
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
qdm2_decode_sub_packet_header
static void qdm2_decode_sub_packet_header(GetBitContext *gb, QDM2SubPacket *sub_packet)
Fill a QDM2SubPacket structure with packet type, size, and data pointer.
Definition: qdm2.c:264
qdm2_init_vlc
static av_cold void qdm2_init_vlc(void)
Definition: qdm2_tablegen.h:125
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
QDM2Context::sub_sampling
int sub_sampling
subsampling: 0=25%, 1=50%, 2=100% *‍/
Definition: qdm2.c:143
QDM2Context::nb_channels
int nb_channels
Parameters from codec header, do not change during playback.
Definition: qdm2.c:132
mpegaudio.h
tone_level_idx_offset_table
static const int8_t tone_level_idx_offset_table[30][4]
Definition: qdm2data.h:237
avcodec.h
fft_level_exp_alt_vlc
static VLC fft_level_exp_alt_vlc
Definition: qdm2_tablegen.h:101
QDM2Context::fft
QDM2FFT fft
Definition: qdm2.c:165
average_quantized_coeffs
static void average_quantized_coeffs(QDM2Context *q)
Replace 8 elements with their average value.
Definition: qdm2.c:316
VLC::bits
int bits
Definition: vlc.h:27
QDM2Context::tone_level_idx_hi1
int8_t tone_level_idx_hi1[MPA_MAX_CHANNELS][3][8][8]
Definition: qdm2.c:184
ret
ret
Definition: filter_design.txt:187
fill_tone_level_array
static void fill_tone_level_array(QDM2Context *q, int flag)
Related to synthesis filter Called by process_subpacket_10.
Definition: qdm2.c:443
FFTCoefficient::sub_packet
int16_t sub_packet
Definition: qdm2.c:116
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
FFTTone::phase
int phase
Definition: qdm2.c:108
init_tone_level_dequantization
static void init_tone_level_dequantization(QDM2Context *q, GetBitContext *gb)
Related to synthesis filter, process data from packet 10 Init part of quantized_coeffs via function i...
Definition: qdm2.c:916
ff_mpa_synth_init_float
void ff_mpa_synth_init_float(void)
fft_tone_sample_table
static const float fft_tone_sample_table[4][16][5]
Definition: qdm2data.h:298
type34_delta
static const float type34_delta[10]
Definition: qdm2data.h:456
coeff_per_sb_for_avg
static const uint8_t coeff_per_sb_for_avg[3][30]
Definition: qdm2data.h:191
QDM2Context::fft_size
int fft_size
size of FFT, in complex numbers
Definition: qdm2.c:135
AVCodecContext
main external API structure.
Definition: avcodec.h:379
fft_level_exp_vlc
static VLC fft_level_exp_vlc
Definition: qdm2_tablegen.h:102
qdm2_synthesis_filter
static void qdm2_synthesis_filter(QDM2Context *q, int index)
Definition: qdm2.c:1564
channel_layout.h
sb_int8_array
int8_t sb_int8_array[2][30][64]
Definition: qdm2.c:80
QDM2Context::noise_idx
int noise_idx
index for dithering noise table
Definition: qdm2.c:196
noise_samples
static float noise_samples[128]
Definition: qdm2_tablegen.h:45
VLC
Definition: vlc.h:26
QDM2Context::superblocktype_2_3
int superblocktype_2_3
select fft tables and some algorithm based on superblock type
Definition: qdm2.c:192
QDM2Context
QDM2 decoder context.
Definition: qdm2.c:130
QDM2Context::channels
int channels
number of channels
Definition: qdm2.c:133
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
QDM2Context::sub_packet_list_B
QDM2SubPNode sub_packet_list_B[16]
FFT packets B are on list.
Definition: qdm2.c:150
ff_mpa_synth_filter_float
void ff_mpa_synth_filter_float(MPADSPContext *s, float *synth_buf_ptr, int *synth_buf_offset, float *window, int *dither_state, float *samples, ptrdiff_t incr, float *sb_samples)
QDM2Context::tone_level_idx_hi2
int8_t tone_level_idx_hi2[MPA_MAX_CHANNELS][26]
Definition: qdm2.c:186
type30_dequant
static const float type30_dequant[8]
Definition: qdm2data.h:451
vlc_tab_diff
static VLC vlc_tab_diff
Definition: qdm2_tablegen.h:99
mpegaudiodsp.h
qdm2_get_se_vlc
static int qdm2_get_se_vlc(const VLC *vlc, GetBitContext *gb, int depth)
Definition: qdm2.c:232
fft_cutoff_index_table
static const int fft_cutoff_index_table[4][2]
Definition: qdm2data.h:164
QDM2Complex
Definition: qdm2.c:99
process_subpacket_10
static void process_subpacket_10(QDM2Context *q, QDM2SubPNode *node)
Process subpacket 10 if not null, else.
Definition: qdm2.c:1021
QDM2Context::fft_coefs_min_index
int fft_coefs_min_index[5]
Definition: qdm2.c:161
QDM2Context::fft_tones
FFTTone fft_tones[1000]
FFT and tones.
Definition: qdm2.c:156
FFTTone::table
const float * table
Definition: qdm2.c:107
QDM2Context::tone_level_idx_mid
int8_t tone_level_idx_mid[MPA_MAX_CHANNELS][26][8]
Definition: qdm2.c:185
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
qdm2_fft_generate_tone
static void qdm2_fft_generate_tone(QDM2Context *q, FFTTone *tone)
Definition: qdm2.c:1427
QDM2Context::fft_coefs_max_index
int fft_coefs_max_index[5]
Definition: qdm2.c:162
QDM2_MAX_FRAME_SIZE
#define QDM2_MAX_FRAME_SIZE
Definition: qdm2.c:78
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:406
FFTTone::phase_shift
int phase_shift
Definition: qdm2.c:109
vlc_tab_fft_tone_offset
static VLC vlc_tab_fft_tone_offset[5]
Definition: qdm2_tablegen.h:110
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
RDFTContext::rdft_calc
void(* rdft_calc)(struct RDFTContext *s, FFTSample *z)
Definition: rdft.h:38
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
MPA_MAX_CHANNELS
#define MPA_MAX_CHANNELS
Definition: mpegaudio.h:42
SB_DITHERING_NOISE
#define SB_DITHERING_NOISE(sb, noise_idx)
Definition: qdm2.c:70
dequant_table
static const uint8_t dequant_table[64]
Definition: 4xm.c:116
QDM2SubPacket::type
int type
subpacket type
Definition: qdm2.c:86
QDM2Context::tone_level_idx_temp
int8_t tone_level_idx_temp[MPA_MAX_CHANNELS][30][64]
Definition: qdm2.c:188
QDM2Context::group_size
int group_size
size of frame group (16 frames per group)
Definition: qdm2.c:134
FFTTone
Definition: qdm2.c:104
int
int
Definition: ffmpeg_filter.c:156
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
softclip_table_init
static av_cold void softclip_table_init(void)
Definition: qdm2_tablegen.h:47
channel
channel
Definition: ebur128.h:39
QDM2SubPNode::packet
QDM2SubPacket * packet
packet
Definition: qdm2.c:95
QDM2Context::samples
float samples[MPA_MAX_CHANNELS *MPA_FRAME_SIZE]
Definition: qdm2.c:177
min
float min
Definition: vorbis_enc_data.h:429
nb_channels
int nb_channels
Definition: channel_layout.c:81
QDM2Context::fft_coefs_index
int fft_coefs_index
Definition: qdm2.c:160