FFmpeg: libavcodec/qdm2.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /