falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
74465 Commits
32 Branches
290MB
Tree: 1907e19d0c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1907e19d0c'
${ noResults }
FFmpeg/libavcodec/qdm2.c

1893 lines
63KB
Raw Blame History 

  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. 

  38. #define BITSTREAM_READER_LE

  39. #include "libavutil/channel_layout.h"

  40. #include "avcodec.h"

  41. #include "get_bits.h"

  42. #include "internal.h"

  43. #include "rdft.h"

  44. #include "mpegaudiodsp.h"

  45. #include "mpegaudio.h"

  46. 

  47. #include "qdm2_tablegen.h"

  48. 

  49. #define QDM2_LIST_ADD(list, size, packet) \

  50. do { \

  51.       if (size > 0) { \

  52.     list[size - 1].next = &list[size]; \

  53.       } \

  54.       list[size].packet = packet; \

  55.       list[size].next = NULL; \

  56.       size++; \

  57. } while(0)

  58. 

  59. // Result is 8, 16 or 30

  60. #define QDM2_SB_USED(sub_sampling) (((sub_sampling) >= 2) ? 30 : 8 << (sub_sampling))

  61. 

  62. #define FIX_NOISE_IDX(noise_idx) \

  63.   if ((noise_idx) >= 3840) \

  64.     (noise_idx) -= 3840; \

  65. 

  66. #define SB_DITHERING_NOISE(sb,noise_idx) (noise_table[(noise_idx)++] * sb_noise_attenuation[(sb)])

  67. 

  68. #define SAMPLES_NEEDED \

  69.      av_log (NULL,AV_LOG_INFO,"This file triggers some untested code. Please contact the developers.\n");

  70. 

  71. #define SAMPLES_NEEDED_2(why) \

  72.      av_log (NULL,AV_LOG_INFO,"This file triggers some missing code. Please contact the developers.\nPosition: %s\n",why);

  73. 

  74. #define QDM2_MAX_FRAME_SIZE 512

  75. 

  76. typedef int8_t sb_int8_array[2][30][64];

  77. 

  78. /**

  79.  * Subpacket

  80.  */

  81. typedef struct QDM2SubPacket {

  82.     int type;            ///< subpacket type

  83.     unsigned int size;   ///< subpacket size

  84.     const uint8_t *data; ///< pointer to subpacket data (points to input data buffer, it's not a private copy)

  85. } QDM2SubPacket;

  86. 

  87. /**

  88.  * A node in the subpacket list

  89.  */

  90. typedef struct QDM2SubPNode {

  91.     QDM2SubPacket *packet;      ///< packet

  92.     struct QDM2SubPNode *next; ///< pointer to next packet in the list, NULL if leaf node

  93. } QDM2SubPNode;

  94. 

  95. typedef struct QDM2Complex {

  96.     float re;

  97.     float im;

  98. } QDM2Complex;

  99. 

  100. typedef struct FFTTone {

  101.     float level;

  102.     QDM2Complex *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, QDM2Complex, complex)[MPA_MAX_CHANNELS][256];

  121. } QDM2FFT;

  122. 

  123. /**

  124.  * QDM2 decoder context

  125.  */

  126. typedef struct QDM2Context {

  127.     /// Parameters from codec header, do not change during playback

  128.     int nb_channels;         ///< number of channels

  129.     int channels;            ///< number of channels

  130.     int group_size;          ///< size of frame group (16 frames per group)

  131.     int fft_size;            ///< size of FFT, in complex numbers

  132.     int checksum_size;       ///< size of data block, used also for checksum

  133. 

  134.     /// Parameters built from header parameters, do not change during playback

  135.     int group_order;         ///< order of frame group

  136.     int fft_order;           ///< order of FFT (actually fftorder+1)

  137.     int frame_size;          ///< size of data frame

  138.     int frequency_range;

  139.     int sub_sampling;        ///< subsampling: 0=25%, 1=50%, 2=100% */

  140.     int coeff_per_sb_select; ///< selector for "num. of coeffs. per subband" tables. Can be 0, 1, 2

  141.     int cm_table_select;     ///< selector for "coding method" tables. Can be 0, 1 (from init: 0-4)

  142. 

  143.     /// Packets and packet lists

  144.     QDM2SubPacket sub_packets[16];      ///< the packets themselves

  145.     QDM2SubPNode sub_packet_list_A[16]; ///< list of all packets

  146.     QDM2SubPNode sub_packet_list_B[16]; ///< FFT packets B are on list

  147.     int sub_packets_B;                  ///< number of packets on 'B' list

  148.     QDM2SubPNode sub_packet_list_C[16]; ///< packets with errors?

  149.     QDM2SubPNode sub_packet_list_D[16]; ///< DCT packets

  150. 

  151.     /// FFT and tones

  152.     FFTTone fft_tones[1000];

  153.     int fft_tone_start;

  154.     int fft_tone_end;

  155.     FFTCoefficient fft_coefs[1000];

  156.     int fft_coefs_index;

  157.     int fft_coefs_min_index[5];

  158.     int fft_coefs_max_index[5];

  159.     int fft_level_exp[6];

  160.     RDFTContext rdft_ctx;

  161.     QDM2FFT fft;

  162. 

  163.     /// I/O data

  164.     const uint8_t *compressed_data;

  165.     int compressed_size;

  166.     float output_buffer[QDM2_MAX_FRAME_SIZE * MPA_MAX_CHANNELS * 2];

  167. 

  168.     /// Synthesis filter

  169.     MPADSPContext mpadsp;

  170.     DECLARE_ALIGNED(32, float, synth_buf)[MPA_MAX_CHANNELS][512*2];

  171.     int synth_buf_offset[MPA_MAX_CHANNELS];

  172.     DECLARE_ALIGNED(32, float, sb_samples)[MPA_MAX_CHANNELS][128][SBLIMIT];

  173.     DECLARE_ALIGNED(32, float, samples)[MPA_MAX_CHANNELS * MPA_FRAME_SIZE];

  174. 

  175.     /// Mixed temporary data used in decoding

  176.     float tone_level[MPA_MAX_CHANNELS][30][64];

  177.     int8_t coding_method[MPA_MAX_CHANNELS][30][64];

  178.     int8_t quantized_coeffs[MPA_MAX_CHANNELS][10][8];

  179.     int8_t tone_level_idx_base[MPA_MAX_CHANNELS][30][8];

  180.     int8_t tone_level_idx_hi1[MPA_MAX_CHANNELS][3][8][8];

  181.     int8_t tone_level_idx_mid[MPA_MAX_CHANNELS][26][8];

  182.     int8_t tone_level_idx_hi2[MPA_MAX_CHANNELS][26];

  183.     int8_t tone_level_idx[MPA_MAX_CHANNELS][30][64];

  184.     int8_t tone_level_idx_temp[MPA_MAX_CHANNELS][30][64];

  185. 

  186.     // Flags

  187.     int has_errors;         ///< packet has errors

  188.     int superblocktype_2_3; ///< select fft tables and some algorithm based on superblock type

  189.     int do_synth_filter;    ///< used to perform or skip synthesis filter

  190. 

  191.     int sub_packet;

  192.     int noise_idx; ///< index for dithering noise table

  193. } QDM2Context;

  194. 

  195. static const int switchtable[23] = {

  196.     0, 5, 1, 5, 5, 5, 5, 5, 2, 5, 5, 5, 5, 5, 5, 5, 3, 5, 5, 5, 5, 5, 4

  197. };

  198. 

  199. static int qdm2_get_vlc(GetBitContext *gb, const VLC *vlc, int flag, int depth)

  200. {

  201.     int value;

  202. 

  203.     value = get_vlc2(gb, vlc->table, vlc->bits, depth);

  204. 

  205.     /* stage-2, 3 bits exponent escape sequence */

  206.     if (value-- == 0)

  207.         value = get_bits(gb, get_bits(gb, 3) + 1);

  208. 

  209.     /* stage-3, optional */

  210.     if (flag) {

  211.         int tmp;

  212. 

  213.         if (value >= 60) {

  214.             av_log(NULL, AV_LOG_ERROR, "value %d in qdm2_get_vlc too large\n", value);

  215.             return 0;

  216.         }

  217. 

  218.         tmp= vlc_stage3_values[value];

  219. 

  220.         if ((value & ~3) > 0)

  221.             tmp += get_bits(gb, (value >> 2));

  222.         value = tmp;

  223.     }

  224. 

  225.     return value;

  226. }

  227. 

  228. static int qdm2_get_se_vlc(const VLC *vlc, GetBitContext *gb, int depth)

  229. {

  230.     int value = qdm2_get_vlc(gb, vlc, 0, depth);

  231. 

  232.     return (value & 1) ? ((value + 1) >> 1) : -(value >> 1);

  233. }

  234. 

  235. /**

  236.  * QDM2 checksum

  237.  *

  238.  * @param data      pointer to data to be checksum'ed

  239.  * @param length    data length

  240.  * @param value     checksum value

  241.  *

  242.  * @return          0 if checksum is OK

  243.  */

  244. static uint16_t qdm2_packet_checksum(const uint8_t *data, int length, int value)

  245. {

  246.     int i;

  247. 

  248.     for (i = 0; i < length; i++)

  249.         value -= data[i];

  250. 

  251.     return (uint16_t)(value & 0xffff);

  252. }

  253. 

  254. /**

  255.  * Fill a QDM2SubPacket structure with packet type, size, and data pointer.

  256.  *

  257.  * @param gb            bitreader context

  258.  * @param sub_packet    packet under analysis

  259.  */

  260. static void qdm2_decode_sub_packet_header(GetBitContext *gb,

  261.                                           QDM2SubPacket *sub_packet)

  262. {

  263.     sub_packet->type = get_bits(gb, 8);

  264. 

  265.     if (sub_packet->type == 0) {

  266.         sub_packet->size = 0;

  267.         sub_packet->data = NULL;

  268.     } else {

  269.         sub_packet->size = get_bits(gb, 8);

  270. 

  271.         if (sub_packet->type & 0x80) {

  272.             sub_packet->size <<= 8;

  273.             sub_packet->size  |= get_bits(gb, 8);

  274.             sub_packet->type  &= 0x7f;

  275.         }

  276. 

  277.         if (sub_packet->type == 0x7f)

  278.             sub_packet->type |= (get_bits(gb, 8) << 8);

  279. 

  280.         // FIXME: this depends on bitreader-internal data

  281.         sub_packet->data = &gb->buffer[get_bits_count(gb) / 8];

  282.     }

  283. 

  284.     av_log(NULL, AV_LOG_DEBUG, "Subpacket: type=%d size=%d start_offs=%x\n",

  285.            sub_packet->type, sub_packet->size, get_bits_count(gb) / 8);

  286. }

  287. 

  288. /**

  289.  * Return node pointer to first packet of requested type in list.

  290.  *

  291.  * @param list    list of subpackets to be scanned

  292.  * @param type    type of searched subpacket

  293.  * @return        node pointer for subpacket if found, else NULL

  294.  */

  295. static QDM2SubPNode *qdm2_search_subpacket_type_in_list(QDM2SubPNode *list,

  296.                                                         int type)

  297. {

  298.     while (list && list->packet) {

  299.         if (list->packet->type == type)

  300.             return list;

  301.         list = list->next;

  302.     }

  303.     return NULL;

  304. }

  305. 

  306. /**

  307.  * Replace 8 elements with their average value.

  308.  * Called by qdm2_decode_superblock before starting subblock decoding.

  309.  *

  310.  * @param q       context

  311.  */

  312. static void average_quantized_coeffs(QDM2Context *q)

  313. {

  314.     int i, j, n, ch, sum;

  315. 

  316.     n = coeff_per_sb_for_avg[q->coeff_per_sb_select][QDM2_SB_USED(q->sub_sampling) - 1] + 1;

  317. 

  318.     for (ch = 0; ch < q->nb_channels; ch++)

  319.         for (i = 0; i < n; i++) {

  320.             sum = 0;

  321. 

  322.             for (j = 0; j < 8; j++)

  323.                 sum += q->quantized_coeffs[ch][i][j];

  324. 

  325.             sum /= 8;

  326.             if (sum > 0)

  327.                 sum--;

  328. 

  329.             for (j = 0; j < 8; j++)

  330.                 q->quantized_coeffs[ch][i][j] = sum;

  331.         }

  332. }

  333. 

  334. /**

  335.  * Build subband samples with noise weighted by q->tone_level.

  336.  * Called by synthfilt_build_sb_samples.

  337.  *

  338.  * @param q     context

  339.  * @param sb    subband index

  340.  */

  341. static void build_sb_samples_from_noise(QDM2Context *q, int sb)

  342. {

  343.     int ch, j;

  344. 

  345.     FIX_NOISE_IDX(q->noise_idx);

  346. 

  347.     if (!q->nb_channels)

  348.         return;

  349. 

  350.     for (ch = 0; ch < q->nb_channels; ch++) {

  351.         for (j = 0; j < 64; j++) {

  352.             q->sb_samples[ch][j * 2][sb] =

  353.                 SB_DITHERING_NOISE(sb, q->noise_idx) * q->tone_level[ch][sb][j];

  354.             q->sb_samples[ch][j * 2 + 1][sb] =

  355.                 SB_DITHERING_NOISE(sb, q->noise_idx) * q->tone_level[ch][sb][j];

  356.         }

  357.     }

  358. }

  359. 

  360. /**

  361.  * Called while processing data from subpackets 11 and 12.

  362.  * Used after making changes to coding_method array.

  363.  *

  364.  * @param sb               subband index

  365.  * @param channels         number of channels

  366.  * @param coding_method    q->coding_method[0][0][0]

  367.  */

  368. static int fix_coding_method_array(int sb, int channels,

  369.                                    sb_int8_array coding_method)

  370. {

  371.     int j, k;

  372.     int ch;

  373.     int run, case_val;

  374. 

  375.     for (ch = 0; ch < channels; ch++) {

  376.         for (j = 0; j < 64; ) {

  377.             if (coding_method[ch][sb][j] < 8)

  378.                 return -1;

  379.             if ((coding_method[ch][sb][j] - 8) > 22) {

  380.                 run      = 1;

  381.                 case_val = 8;

  382.             } else {

  383.                 switch (switchtable[coding_method[ch][sb][j] - 8]) {

  384.                 case 0: run  = 10;

  385.                     case_val = 10;

  386.                     break;

  387.                 case 1: run  = 1;

  388.                     case_val = 16;

  389.                     break;

  390.                 case 2: run  = 5;

  391.                     case_val = 24;

  392.                     break;

  393.                 case 3: run  = 3;

  394.                     case_val = 30;

  395.                     break;

  396.                 case 4: run  = 1;

  397.                     case_val = 30;

  398.                     break;

  399.                 case 5: run  = 1;

  400.                     case_val = 8;

  401.                     break;

  402.                 default: run = 1;

  403.                     case_val = 8;

  404.                     break;

  405.                 }

  406.             }

  407.             for (k = 0; k < run; k++) {

  408.                 if (j + k < 128) {

  409.                     if (coding_method[ch][sb + (j + k) / 64][(j + k) % 64] > coding_method[ch][sb][j]) {

  410.                         if (k > 0) {

  411.                             SAMPLES_NEEDED

  412.                             //not debugged, almost never used

  413.                             memset(&coding_method[ch][sb][j + k], case_val,

  414.                                    k *sizeof(int8_t));

  415.                             memset(&coding_method[ch][sb][j + k], case_val,

  416.                                    3 * sizeof(int8_t));

  417.                         }

  418.                     }

  419.                 }

  420.             }

  421.             j += run;

  422.         }

  423.     }

  424.     return 0;

  425. }

  426. 

  427. /**

  428.  * Related to synthesis filter

  429.  * Called by process_subpacket_10

  430.  *

  431.  * @param q       context

  432.  * @param flag    1 if called after getting data from subpacket 10, 0 if no subpacket 10

  433.  */

  434. static void fill_tone_level_array(QDM2Context *q, int flag)

  435. {

  436.     int i, sb, ch, sb_used;

  437.     int tmp, tab;

  438. 

  439.     for (ch = 0; ch < q->nb_channels; ch++)

  440.         for (sb = 0; sb < 30; sb++)

  441.             for (i = 0; i < 8; i++) {

  442.                 if ((tab=coeff_per_sb_for_dequant[q->coeff_per_sb_select][sb]) < (last_coeff[q->coeff_per_sb_select] - 1))

  443.                     tmp = q->quantized_coeffs[ch][tab + 1][i] * dequant_table[q->coeff_per_sb_select][tab + 1][sb]+

  444.                           q->quantized_coeffs[ch][tab][i] * dequant_table[q->coeff_per_sb_select][tab][sb];

  445.                 else

  446.                     tmp = q->quantized_coeffs[ch][tab][i] * dequant_table[q->coeff_per_sb_select][tab][sb];

  447.                 if(tmp < 0)

  448.                     tmp += 0xff;

  449.                 q->tone_level_idx_base[ch][sb][i] = (tmp / 256) & 0xff;

  450.             }

  451. 

  452.     sb_used = QDM2_SB_USED(q->sub_sampling);

  453. 

  454.     if ((q->superblocktype_2_3 != 0) && !flag) {

  455.         for (sb = 0; sb < sb_used; sb++)

  456.             for (ch = 0; ch < q->nb_channels; ch++)

  457.                 for (i = 0; i < 64; i++) {

  458.                     q->tone_level_idx[ch][sb][i] = q->tone_level_idx_base[ch][sb][i / 8];

  459.                     if (q->tone_level_idx[ch][sb][i] < 0)

  460.                         q->tone_level[ch][sb][i] = 0;

  461.                     else

  462.                         q->tone_level[ch][sb][i] = fft_tone_level_table[0][q->tone_level_idx[ch][sb][i] & 0x3f];

  463.                 }

  464.     } else {

  465.         tab = q->superblocktype_2_3 ? 0 : 1;

  466.         for (sb = 0; sb < sb_used; sb++) {

  467.             if ((sb >= 4) && (sb <= 23)) {

  468.                 for (ch = 0; ch < q->nb_channels; ch++)

  469.                     for (i = 0; i < 64; i++) {

  470.                         tmp = q->tone_level_idx_base[ch][sb][i / 8] -

  471.                               q->tone_level_idx_hi1[ch][sb / 8][i / 8][i % 8] -

  472.                               q->tone_level_idx_mid[ch][sb - 4][i / 8] -

  473.                               q->tone_level_idx_hi2[ch][sb - 4];

  474.                         q->tone_level_idx[ch][sb][i] = tmp & 0xff;

  475.                         if ((tmp < 0) || (!q->superblocktype_2_3 && !tmp))

  476.                             q->tone_level[ch][sb][i] = 0;

  477.                         else

  478.                             q->tone_level[ch][sb][i] = fft_tone_level_table[tab][tmp & 0x3f];

  479.                 }

  480.             } else {

  481.                 if (sb > 4) {

  482.                     for (ch = 0; ch < q->nb_channels; ch++)

  483.                         for (i = 0; i < 64; i++) {

  484.                             tmp = q->tone_level_idx_base[ch][sb][i / 8] -

  485.                                   q->tone_level_idx_hi1[ch][2][i / 8][i % 8] -

  486.                                   q->tone_level_idx_hi2[ch][sb - 4];

  487.                             q->tone_level_idx[ch][sb][i] = tmp & 0xff;

  488.                             if ((tmp < 0) || (!q->superblocktype_2_3 && !tmp))

  489.                                 q->tone_level[ch][sb][i] = 0;

  490.                             else

  491.                                 q->tone_level[ch][sb][i] = fft_tone_level_table[tab][tmp & 0x3f];

  492.                     }

  493.                 } else {

  494.                     for (ch = 0; ch < q->nb_channels; ch++)

  495.                         for (i = 0; i < 64; i++) {

  496.                             tmp = q->tone_level_idx[ch][sb][i] = q->tone_level_idx_base[ch][sb][i / 8];

  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.                 }

  503.             }

  504.         }

  505.     }

  506. }

  507. 

  508. /**

  509.  * Related to synthesis filter

  510.  * Called by process_subpacket_11

  511.  * c is built with data from subpacket 11

  512.  * Most of this function is used only if superblock_type_2_3 == 0,

  513.  * never seen it in samples.

  514.  *

  515.  * @param tone_level_idx

  516.  * @param tone_level_idx_temp

  517.  * @param coding_method        q->coding_method[0][0][0]

  518.  * @param nb_channels          number of channels

  519.  * @param c                    coming from subpacket 11, passed as 8*c

  520.  * @param superblocktype_2_3   flag based on superblock packet type

  521.  * @param cm_table_select      q->cm_table_select

  522.  */

  523. static void fill_coding_method_array(sb_int8_array tone_level_idx,

  524.                                      sb_int8_array tone_level_idx_temp,

  525.                                      sb_int8_array coding_method,

  526.                                      int nb_channels,

  527.                                      int c, int superblocktype_2_3,

  528.                                      int cm_table_select)

  529. {

  530.     int ch, sb, j;

  531.     int tmp, acc, esp_40, comp;

  532.     int add1, add2, add3, add4;

  533.     int64_t multres;

  534. 

  535.     if (!superblocktype_2_3) {

  536.         /* This case is untested, no samples available */

  537.         avpriv_request_sample(NULL, "!superblocktype_2_3");

  538.         return;

  539.         for (ch = 0; ch < nb_channels; ch++)

  540.             for (sb = 0; sb < 30; sb++) {

  541.                 for (j = 1; j < 63; j++) {  // The loop only iterates to 63 so the code doesn't overflow the buffer

  542.                     add1 = tone_level_idx[ch][sb][j] - 10;

  543.                     if (add1 < 0)

  544.                         add1 = 0;

  545.                     add2 = add3 = add4 = 0;

  546.                     if (sb > 1) {

  547.                         add2 = tone_level_idx[ch][sb - 2][j] + tone_level_idx_offset_table[sb][0] - 6;

  548.                         if (add2 < 0)

  549.                             add2 = 0;

  550.                     }

  551.                     if (sb > 0) {

  552.                         add3 = tone_level_idx[ch][sb - 1][j] + tone_level_idx_offset_table[sb][1] - 6;

  553.                         if (add3 < 0)

  554.                             add3 = 0;

  555.                     }

  556.                     if (sb < 29) {

  557.                         add4 = tone_level_idx[ch][sb + 1][j] + tone_level_idx_offset_table[sb][3] - 6;

  558.                         if (add4 < 0)

  559.                             add4 = 0;

  560.                     }

  561.                     tmp = tone_level_idx[ch][sb][j + 1] * 2 - add4 - add3 - add2 - add1;

  562.                     if (tmp < 0)

  563.                         tmp = 0;

  564.                     tone_level_idx_temp[ch][sb][j + 1] = tmp & 0xff;

  565.                 }

  566.                 tone_level_idx_temp[ch][sb][0] = tone_level_idx_temp[ch][sb][1];

  567.             }

  568.             acc = 0;

  569.             for (ch = 0; ch < nb_channels; ch++)

  570.                 for (sb = 0; sb < 30; sb++)

  571.                     for (j = 0; j < 64; j++)

  572.                         acc += tone_level_idx_temp[ch][sb][j];

  573. 

  574.             multres = 0x66666667LL * (acc * 10);

  575.             esp_40 = (multres >> 32) / 8 + ((multres & 0xffffffff) >> 31);

  576.             for (ch = 0;  ch < nb_channels; ch++)

  577.                 for (sb = 0; sb < 30; sb++)

  578.                     for (j = 0; j < 64; j++) {

  579.                         comp = tone_level_idx_temp[ch][sb][j]* esp_40 * 10;

  580.                         if (comp < 0)

  581.                             comp += 0xff;

  582.                         comp /= 256; // signed shift

  583.                         switch(sb) {

  584.                             case 0:

  585.                                 if (comp < 30)

  586.                                     comp = 30;

  587.                                 comp += 15;

  588.                                 break;

  589.                             case 1:

  590.                                 if (comp < 24)

  591.                                     comp = 24;

  592.                                 comp += 10;

  593.                                 break;

  594.                             case 2:

  595.                             case 3:

  596.                             case 4:

  597.                                 if (comp < 16)

  598.                                     comp = 16;

  599.                         }

  600.                         if (comp <= 5)

  601.                             tmp = 0;

  602.                         else if (comp <= 10)

  603.                             tmp = 10;

  604.                         else if (comp <= 16)

  605.                             tmp = 16;

  606.                         else if (comp <= 24)

  607.                             tmp = -1;

  608.                         else

  609.                             tmp = 0;

  610.                         coding_method[ch][sb][j] = ((tmp & 0xfffa) + 30 )& 0xff;

  611.                     }

  612.             for (sb = 0; sb < 30; sb++)

  613.                 fix_coding_method_array(sb, nb_channels, coding_method);

  614.             for (ch = 0; ch < nb_channels; ch++)

  615.                 for (sb = 0; sb < 30; sb++)

  616.                     for (j = 0; j < 64; j++)

  617.                         if (sb >= 10) {

  618.                             if (coding_method[ch][sb][j] < 10)

  619.                                 coding_method[ch][sb][j] = 10;

  620.                         } else {

  621.                             if (sb >= 2) {

  622.                                 if (coding_method[ch][sb][j] < 16)

  623.                                     coding_method[ch][sb][j] = 16;

  624.                             } else {

  625.                                 if (coding_method[ch][sb][j] < 30)

  626.                                     coding_method[ch][sb][j] = 30;

  627.                             }

  628.                         }

  629.     } else { // superblocktype_2_3 != 0

  630.         for (ch = 0; ch < nb_channels; ch++)

  631.             for (sb = 0; sb < 30; sb++)

  632.                 for (j = 0; j < 64; j++)

  633.                     coding_method[ch][sb][j] = coding_method_table[cm_table_select][sb];

  634.     }

  635. }

  636. 

  637. /**

  638.  *

  639.  * Called by process_subpacket_11 to process more data from subpacket 11

  640.  * with sb 0-8.

  641.  * Called by process_subpacket_12 to process data from subpacket 12 with

  642.  * sb 8-sb_used.

  643.  *

  644.  * @param q         context

  645.  * @param gb        bitreader context

  646.  * @param length    packet length in bits

  647.  * @param sb_min    lower subband processed (sb_min included)

  648.  * @param sb_max    higher subband processed (sb_max excluded)

  649.  */

  650. static int synthfilt_build_sb_samples(QDM2Context *q, GetBitContext *gb,

  651.                                        int length, int sb_min, int sb_max)

  652. {

  653.     int sb, j, k, n, ch, run, channels;

  654.     int joined_stereo, zero_encoding;

  655.     int type34_first;

  656.     float type34_div = 0;

  657.     float type34_predictor;

  658.     float samples[10];

  659.     int sign_bits[16] = {0};

  660. 

  661.     if (length == 0) {

  662.         // If no data use noise

  663.         for (sb=sb_min; sb < sb_max; sb++)

  664.             build_sb_samples_from_noise(q, sb);

  665. 

  666.         return 0;

  667.     }

  668. 

  669.     for (sb = sb_min; sb < sb_max; sb++) {

  670.         channels = q->nb_channels;

  671. 

  672.         if (q->nb_channels <= 1 || sb < 12)

  673.             joined_stereo = 0;

  674.         else if (sb >= 24)

  675.             joined_stereo = 1;

  676.         else

  677.             joined_stereo = (get_bits_left(gb) >= 1) ? get_bits1(gb) : 0;

  678. 

  679.         if (joined_stereo) {

  680.             if (get_bits_left(gb) >= 16)

  681.                 for (j = 0; j < 16; j++)

  682.                     sign_bits[j] = get_bits1(gb);

  683. 

  684.             for (j = 0; j < 64; j++)

  685.                 if (q->coding_method[1][sb][j] > q->coding_method[0][sb][j])

  686.                     q->coding_method[0][sb][j] = q->coding_method[1][sb][j];

  687. 

  688.             if (fix_coding_method_array(sb, q->nb_channels,

  689.                                             q->coding_method)) {

  690.                 av_log(NULL, AV_LOG_ERROR, "coding method invalid\n");

  691.                 build_sb_samples_from_noise(q, sb);

  692.                 continue;

  693.             }

  694.             channels = 1;

  695.         }

  696. 

  697.         for (ch = 0; ch < channels; ch++) {

  698.             FIX_NOISE_IDX(q->noise_idx);

  699.             zero_encoding = (get_bits_left(gb) >= 1) ? get_bits1(gb) : 0;

  700.             type34_predictor = 0.0;

  701.             type34_first = 1;

  702. 

  703.             for (j = 0; j < 128; ) {

  704.                 switch (q->coding_method[ch][sb][j / 2]) {

  705.                     case 8:

  706.                         if (get_bits_left(gb) >= 10) {

  707.                             if (zero_encoding) {

  708.                                 for (k = 0; k < 5; k++) {

  709.                                     if ((j + 2 * k) >= 128)

  710.                                         break;

  711.                                     samples[2 * k] = get_bits1(gb) ? dequant_1bit[joined_stereo][2 * get_bits1(gb)] : 0;

  712.                                 }

  713.                             } else {

  714.                                 n = get_bits(gb, 8);

  715.                                 if (n >= 243) {

  716.                                     av_log(NULL, AV_LOG_ERROR, "Invalid 8bit codeword\n");

  717.                                     return AVERROR_INVALIDDATA;

  718.                                 }

  719. 

  720.                                 for (k = 0; k < 5; k++)

  721.                                     samples[2 * k] = dequant_1bit[joined_stereo][random_dequant_index[n][k]];

  722.                             }

  723.                             for (k = 0; k < 5; k++)

  724.                                 samples[2 * k + 1] = SB_DITHERING_NOISE(sb,q->noise_idx);

  725.                         } else {

  726.                             for (k = 0; k < 10; k++)

  727.                                 samples[k] = SB_DITHERING_NOISE(sb,q->noise_idx);

  728.                         }

  729.                         run = 10;

  730.                         break;

  731. 

  732.                     case 10:

  733.                         if (get_bits_left(gb) >= 1) {

  734.                             float f = 0.81;

  735. 

  736.                             if (get_bits1(gb))

  737.                                 f = -f;

  738.                             f -= noise_samples[((sb + 1) * (j +5 * ch + 1)) & 127] * 9.0 / 40.0;

  739.                             samples[0] = f;

  740.                         } else {

  741.                             samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx);

  742.                         }

  743.                         run = 1;

  744.                         break;

  745. 

  746.                     case 16:

  747.                         if (get_bits_left(gb) >= 10) {

  748.                             if (zero_encoding) {

  749.                                 for (k = 0; k < 5; k++) {

  750.                                     if ((j + k) >= 128)

  751.                                         break;

  752.                                     samples[k] = (get_bits1(gb) == 0) ? 0 : dequant_1bit[joined_stereo][2 * get_bits1(gb)];

  753.                                 }

  754.                             } else {

  755.                                 n = get_bits (gb, 8);

  756.                                 if (n >= 243) {

  757.                                     av_log(NULL, AV_LOG_ERROR, "Invalid 8bit codeword\n");

  758.                                     return AVERROR_INVALIDDATA;

  759.                                 }

  760. 

  761.                                 for (k = 0; k < 5; k++)

  762.                                     samples[k] = dequant_1bit[joined_stereo][random_dequant_index[n][k]];

  763.                             }

  764.                         } else {

  765.                             for (k = 0; k < 5; k++)

  766.                                 samples[k] = SB_DITHERING_NOISE(sb,q->noise_idx);

  767.                         }

  768.                         run = 5;

  769.                         break;

  770. 

  771.                     case 24:

  772.                         if (get_bits_left(gb) >= 7) {

  773.                             n = get_bits(gb, 7);

  774.                             if (n >= 125) {

  775.                                 av_log(NULL, AV_LOG_ERROR, "Invalid 7bit codeword\n");

  776.                                 return AVERROR_INVALIDDATA;

  777.                             }

  778. 

  779.                             for (k = 0; k < 3; k++)

  780.                                 samples[k] = (random_dequant_type24[n][k] - 2.0) * 0.5;

  781.                         } else {

  782.                             for (k = 0; k < 3; k++)

  783.                                 samples[k] = SB_DITHERING_NOISE(sb,q->noise_idx);

  784.                         }

  785.                         run = 3;

  786.                         break;

  787. 

  788.                     case 30:

  789.                         if (get_bits_left(gb) >= 4) {

  790.                             unsigned index = qdm2_get_vlc(gb, &vlc_tab_type30, 0, 1);

  791.                             if (index >= FF_ARRAY_ELEMS(type30_dequant)) {

  792.                                 av_log(NULL, AV_LOG_ERROR, "index %d out of type30_dequant array\n", index);

  793.                                 return AVERROR_INVALIDDATA;

  794.                             }

  795.                             samples[0] = type30_dequant[index];

  796.                         } else

  797.                             samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx);

  798. 

  799.                         run = 1;

  800.                         break;

  801. 

  802.                     case 34:

  803.                         if (get_bits_left(gb) >= 7) {

  804.                             if (type34_first) {

  805.                                 type34_div = (float)(1 << get_bits(gb, 2));

  806.                                 samples[0] = ((float)get_bits(gb, 5) - 16.0) / 15.0;

  807.                                 type34_predictor = samples[0];

  808.                                 type34_first = 0;

  809.                             } else {

  810.                                 unsigned index = qdm2_get_vlc(gb, &vlc_tab_type34, 0, 1);

  811.                                 if (index >= FF_ARRAY_ELEMS(type34_delta)) {

  812.                                     av_log(NULL, AV_LOG_ERROR, "index %d out of type34_delta array\n", index);

  813.                                     return AVERROR_INVALIDDATA;

  814.                                 }

  815.                                 samples[0] = type34_delta[index] / type34_div + type34_predictor;

  816.                                 type34_predictor = samples[0];

  817.                             }

  818.                         } else {

  819.                             samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx);

  820.                         }

  821.                         run = 1;

  822.                         break;

  823. 

  824.                     default:

  825.                         samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx);

  826.                         run = 1;

  827.                         break;

  828.                 }

  829. 

  830.                 if (joined_stereo) {

  831.                     for (k = 0; k < run && j + k < 128; k++) {

  832.                         q->sb_samples[0][j + k][sb] =

  833.                             q->tone_level[0][sb][(j + k) / 2] * samples[k];

  834.                         if (q->nb_channels == 2) {

  835.                             if (sign_bits[(j + k) / 8])

  836.                                 q->sb_samples[1][j + k][sb] =

  837.                                     q->tone_level[1][sb][(j + k) / 2] * -samples[k];

  838.                             else

  839.                                 q->sb_samples[1][j + k][sb] =

  840.                                     q->tone_level[1][sb][(j + k) / 2] * samples[k];

  841.                         }

  842.                     }

  843.                 } else {

  844.                     for (k = 0; k < run; k++)

  845.                         if ((j + k) < 128)

  846.                             q->sb_samples[ch][j + k][sb] = q->tone_level[ch][sb][(j + k)/2] * samples[k];

  847.                 }

  848. 

  849.                 j += run;

  850.             } // j loop

  851.         } // channel loop

  852.     } // subband loop

  853.     return 0;

  854. }

  855. 

  856. /**

  857.  * Init the first element of a channel in quantized_coeffs with data

  858.  * from packet 10 (quantized_coeffs[ch][0]).

  859.  * This is similar to process_subpacket_9, but for a single channel

  860.  * and for element [0]

  861.  * same VLC tables as process_subpacket_9 are used.

  862.  *

  863.  * @param quantized_coeffs    pointer to quantized_coeffs[ch][0]

  864.  * @param gb        bitreader context

  865.  */

  866. static int init_quantized_coeffs_elem0(int8_t *quantized_coeffs,

  867.                                         GetBitContext *gb)

  868. {

  869.     int i, k, run, level, diff;

  870. 

  871.     if (get_bits_left(gb) < 16)

  872.         return -1;

  873.     level = qdm2_get_vlc(gb, &vlc_tab_level, 0, 2);

  874. 

  875.     quantized_coeffs[0] = level;

  876. 

  877.     for (i = 0; i < 7; ) {

  878.         if (get_bits_left(gb) < 16)

  879.             return -1;

  880.         run = qdm2_get_vlc(gb, &vlc_tab_run, 0, 1) + 1;

  881. 

  882.         if (i + run >= 8)

  883.             return -1;

  884. 

  885.         if (get_bits_left(gb) < 16)

  886.             return -1;

  887.         diff = qdm2_get_se_vlc(&vlc_tab_diff, gb, 2);

  888. 

  889.         for (k = 1; k <= run; k++)

  890.             quantized_coeffs[i + k] = (level + ((k * diff) / run));

  891. 

  892.         level += diff;

  893.         i += run;

  894.     }

  895.     return 0;

  896. }

  897. 

  898. /**

  899.  * Related to synthesis filter, process data from packet 10

  900.  * Init part of quantized_coeffs via function init_quantized_coeffs_elem0

  901.  * Init tone_level_idx_hi1, tone_level_idx_hi2, tone_level_idx_mid with

  902.  * data from packet 10

  903.  *

  904.  * @param q         context

  905.  * @param gb        bitreader context

  906.  */

  907. static void init_tone_level_dequantization(QDM2Context *q, GetBitContext *gb)

  908. {

  909.     int sb, j, k, n, ch;

  910. 

  911.     for (ch = 0; ch < q->nb_channels; ch++) {

  912.         init_quantized_coeffs_elem0(q->quantized_coeffs[ch][0], gb);

  913. 

  914.         if (get_bits_left(gb) < 16) {

  915.             memset(q->quantized_coeffs[ch][0], 0, 8);

  916.             break;

  917.         }

  918.     }

  919. 

  920.     n = q->sub_sampling + 1;

  921. 

  922.     for (sb = 0; sb < n; sb++)

  923.         for (ch = 0; ch < q->nb_channels; ch++)

  924.             for (j = 0; j < 8; j++) {

  925.                 if (get_bits_left(gb) < 1)

  926.                     break;

  927.                 if (get_bits1(gb)) {

  928.                     for (k=0; k < 8; k++) {

  929.                         if (get_bits_left(gb) < 16)

  930.                             break;

  931.                         q->tone_level_idx_hi1[ch][sb][j][k] = qdm2_get_vlc(gb, &vlc_tab_tone_level_idx_hi1, 0, 2);

  932.                     }

  933.                 } else {

  934.                     for (k=0; k < 8; k++)

  935.                         q->tone_level_idx_hi1[ch][sb][j][k] = 0;

  936.                 }

  937.             }

  938. 

  939.     n = QDM2_SB_USED(q->sub_sampling) - 4;

  940. 

  941.     for (sb = 0; sb < n; sb++)

  942.         for (ch = 0; ch < q->nb_channels; ch++) {

  943.             if (get_bits_left(gb) < 16)

  944.                 break;

  945.             q->tone_level_idx_hi2[ch][sb] = qdm2_get_vlc(gb, &vlc_tab_tone_level_idx_hi2, 0, 2);

  946.             if (sb > 19)

  947.                 q->tone_level_idx_hi2[ch][sb] -= 16;

  948.             else

  949.                 for (j = 0; j < 8; j++)

  950.                     q->tone_level_idx_mid[ch][sb][j] = -16;

  951.         }

  952. 

  953.     n = QDM2_SB_USED(q->sub_sampling) - 5;

  954. 

  955.     for (sb = 0; sb < n; sb++)

  956.         for (ch = 0; ch < q->nb_channels; ch++)

  957.             for (j = 0; j < 8; j++) {

  958.                 if (get_bits_left(gb) < 16)

  959.                     break;

  960.                 q->tone_level_idx_mid[ch][sb][j] = qdm2_get_vlc(gb, &vlc_tab_tone_level_idx_mid, 0, 2) - 32;

  961.             }

  962. }

  963. 

  964. /**

  965.  * Process subpacket 9, init quantized_coeffs with data from it

  966.  *

  967.  * @param q       context

  968.  * @param node    pointer to node with packet

  969.  */

  970. static int process_subpacket_9(QDM2Context *q, QDM2SubPNode *node)

  971. {

  972.     GetBitContext gb;

  973.     int i, j, k, n, ch, run, level, diff;

  974. 

  975.     init_get_bits(&gb, node->packet->data, node->packet->size * 8);

  976. 

  977.     n = coeff_per_sb_for_avg[q->coeff_per_sb_select][QDM2_SB_USED(q->sub_sampling) - 1] + 1;

  978. 

  979.     for (i = 1; i < n; i++)

  980.         for (ch = 0; ch < q->nb_channels; ch++) {

  981.             level = qdm2_get_vlc(&gb, &vlc_tab_level, 0, 2);

  982.             q->quantized_coeffs[ch][i][0] = level;

  983. 

  984.             for (j = 0; j < (8 - 1); ) {

  985.                 run  = qdm2_get_vlc(&gb, &vlc_tab_run, 0, 1) + 1;

  986.                 diff = qdm2_get_se_vlc(&vlc_tab_diff, &gb, 2);

  987. 

  988.                 if (j + run >= 8)

  989.                     return -1;

  990. 

  991.                 for (k = 1; k <= run; k++)

  992.                     q->quantized_coeffs[ch][i][j + k] = (level + ((k * diff) / run));

  993. 

  994.                 level += diff;

  995.                 j     += run;

  996.             }

  997.         }

  998. 

  999.     for (ch = 0; ch < q->nb_channels; ch++)

  1000.         for (i = 0; i < 8; i++)

  1001.             q->quantized_coeffs[ch][0][i] = 0;

  1002. 

  1003.     return 0;

  1004. }

  1005. 

  1006. /**

  1007.  * Process subpacket 10 if not null, else

  1008.  *

  1009.  * @param q         context

  1010.  * @param node      pointer to node with packet

  1011.  */

  1012. static void process_subpacket_10(QDM2Context *q, QDM2SubPNode *node)

  1013. {

  1014.     GetBitContext gb;

  1015. 

  1016.     if (node) {

  1017.         init_get_bits(&gb, node->packet->data, node->packet->size * 8);

  1018.         init_tone_level_dequantization(q, &gb);

  1019.         fill_tone_level_array(q, 1);

  1020.     } else {

  1021.         fill_tone_level_array(q, 0);

  1022.     }

  1023. }

  1024. 

  1025. /**

  1026.  * Process subpacket 11

  1027.  *

  1028.  * @param q         context

  1029.  * @param node      pointer to node with packet

  1030.  */

  1031. static void process_subpacket_11(QDM2Context *q, QDM2SubPNode *node)

  1032. {

  1033.     GetBitContext gb;

  1034.     int length = 0;

  1035. 

  1036.     if (node) {

  1037.         length = node->packet->size * 8;

  1038.         init_get_bits(&gb, node->packet->data, length);

  1039.     }

  1040. 

  1041.     if (length >= 32) {

  1042.         int c = get_bits(&gb, 13);

  1043. 

  1044.         if (c > 3)

  1045.             fill_coding_method_array(q->tone_level_idx,

  1046.                                      q->tone_level_idx_temp, q->coding_method,

  1047.                                      q->nb_channels, 8 * c,

  1048.                                      q->superblocktype_2_3, q->cm_table_select);

  1049.     }

  1050. 

  1051.     synthfilt_build_sb_samples(q, &gb, length, 0, 8);

  1052. }

  1053. 

  1054. /**

  1055.  * Process subpacket 12

  1056.  *

  1057.  * @param q         context

  1058.  * @param node      pointer to node with packet

  1059.  */

  1060. static void process_subpacket_12(QDM2Context *q, QDM2SubPNode *node)

  1061. {

  1062.     GetBitContext gb;

  1063.     int length = 0;

  1064. 

  1065.     if (node) {

  1066.         length = node->packet->size * 8;

  1067.         init_get_bits(&gb, node->packet->data, length);

  1068.     }

  1069. 

  1070.     synthfilt_build_sb_samples(q, &gb, length, 8, QDM2_SB_USED(q->sub_sampling));

  1071. }

  1072. 

  1073. /**

  1074.  * Process new subpackets for synthesis filter

  1075.  *

  1076.  * @param q       context

  1077.  * @param list    list with synthesis filter packets (list D)

  1078.  */

  1079. static void process_synthesis_subpackets(QDM2Context *q, QDM2SubPNode *list)

  1080. {

  1081.     QDM2SubPNode *nodes[4];

  1082. 

  1083.     nodes[0] = qdm2_search_subpacket_type_in_list(list, 9);

  1084.     if (nodes[0])

  1085.         process_subpacket_9(q, nodes[0]);

  1086. 

  1087.     nodes[1] = qdm2_search_subpacket_type_in_list(list, 10);

  1088.     if (nodes[1])

  1089.         process_subpacket_10(q, nodes[1]);

  1090.     else

  1091.         process_subpacket_10(q, NULL);

  1092. 

  1093.     nodes[2] = qdm2_search_subpacket_type_in_list(list, 11);

  1094.     if (nodes[0] && nodes[1] && nodes[2])

  1095.         process_subpacket_11(q, nodes[2]);

  1096.     else

  1097.         process_subpacket_11(q, NULL);

  1098. 

  1099.     nodes[3] = qdm2_search_subpacket_type_in_list(list, 12);

  1100.     if (nodes[0] && nodes[1] && nodes[3])

  1101.         process_subpacket_12(q, nodes[3]);

  1102.     else

  1103.         process_subpacket_12(q, NULL);

  1104. }

  1105. 

  1106. /**

  1107.  * Decode superblock, fill packet lists.

  1108.  *

  1109.  * @param q    context

  1110.  */

  1111. static void qdm2_decode_super_block(QDM2Context *q)

  1112. {

  1113.     GetBitContext gb;

  1114.     QDM2SubPacket header, *packet;

  1115.     int i, packet_bytes, sub_packet_size, sub_packets_D;

  1116.     unsigned int next_index = 0;

  1117. 

  1118.     memset(q->tone_level_idx_hi1, 0, sizeof(q->tone_level_idx_hi1));

  1119.     memset(q->tone_level_idx_mid, 0, sizeof(q->tone_level_idx_mid));

  1120.     memset(q->tone_level_idx_hi2, 0, sizeof(q->tone_level_idx_hi2));

  1121. 

  1122.     q->sub_packets_B = 0;

  1123.     sub_packets_D    = 0;

  1124. 

  1125.     average_quantized_coeffs(q); // average elements in quantized_coeffs[max_ch][10][8]

  1126. 

  1127.     init_get_bits(&gb, q->compressed_data, q->compressed_size * 8);

  1128.     qdm2_decode_sub_packet_header(&gb, &header);

  1129. 

  1130.     if (header.type < 2 || header.type >= 8) {

  1131.         q->has_errors = 1;

  1132.         av_log(NULL, AV_LOG_ERROR, "bad superblock type\n");

  1133.         return;

  1134.     }

  1135. 

  1136.     q->superblocktype_2_3 = (header.type == 2 || header.type == 3);

  1137.     packet_bytes          = (q->compressed_size - get_bits_count(&gb) / 8);

  1138. 

  1139.     init_get_bits(&gb, header.data, header.size * 8);

  1140. 

  1141.     if (header.type == 2 || header.type == 4 || header.type == 5) {

  1142.         int csum = 257 * get_bits(&gb, 8);

  1143.         csum += 2 * get_bits(&gb, 8);

  1144. 

  1145.         csum = qdm2_packet_checksum(q->compressed_data, q->checksum_size, csum);

  1146. 

  1147.         if (csum != 0) {

  1148.             q->has_errors = 1;

  1149.             av_log(NULL, AV_LOG_ERROR, "bad packet checksum\n");

  1150.             return;

  1151.         }

  1152.     }

  1153. 

  1154.     q->sub_packet_list_B[0].packet = NULL;

  1155.     q->sub_packet_list_D[0].packet = NULL;

  1156. 

  1157.     for (i = 0; i < 6; i++)

  1158.         if (--q->fft_level_exp[i] < 0)

  1159.             q->fft_level_exp[i] = 0;

  1160. 

  1161.     for (i = 0; packet_bytes > 0; i++) {

  1162.         int j;

  1163. 

  1164.         if (i >= FF_ARRAY_ELEMS(q->sub_packet_list_A)) {

  1165.             SAMPLES_NEEDED_2("too many packet bytes");

  1166.             return;

  1167.         }

  1168. 

  1169.         q->sub_packet_list_A[i].next = NULL;

  1170. 

  1171.         if (i > 0) {

  1172.             q->sub_packet_list_A[i - 1].next = &q->sub_packet_list_A[i];

  1173. 

  1174.             /* seek to next block */

  1175.             init_get_bits(&gb, header.data, header.size * 8);

  1176.             skip_bits(&gb, next_index * 8);

  1177. 

  1178.             if (next_index >= header.size)

  1179.                 break;

  1180.         }

  1181. 

  1182.         /* decode subpacket */

  1183.         packet = &q->sub_packets[i];

  1184.         qdm2_decode_sub_packet_header(&gb, packet);

  1185.         next_index      = packet->size + get_bits_count(&gb) / 8;

  1186.         sub_packet_size = ((packet->size > 0xff) ? 1 : 0) + packet->size + 2;

  1187. 

  1188.         if (packet->type == 0)

  1189.             break;

  1190. 

  1191.         if (sub_packet_size > packet_bytes) {

  1192.             if (packet->type != 10 && packet->type != 11 && packet->type != 12)

  1193.                 break;

  1194.             packet->size += packet_bytes - sub_packet_size;

  1195.         }

  1196. 

  1197.         packet_bytes -= sub_packet_size;

  1198. 

  1199.         /* add subpacket to 'all subpackets' list */

  1200.         q->sub_packet_list_A[i].packet = packet;

  1201. 

  1202.         /* add subpacket to related list */

  1203.         if (packet->type == 8) {

  1204.             SAMPLES_NEEDED_2("packet type 8");

  1205.             return;

  1206.         } else if (packet->type >= 9 && packet->type <= 12) {

  1207.             /* packets for MPEG Audio like Synthesis Filter */

  1208.             QDM2_LIST_ADD(q->sub_packet_list_D, sub_packets_D, packet);

  1209.         } else if (packet->type == 13) {

  1210.             for (j = 0; j < 6; j++)

  1211.                 q->fft_level_exp[j] = get_bits(&gb, 6);

  1212.         } else if (packet->type == 14) {

  1213.             for (j = 0; j < 6; j++)

  1214.                 q->fft_level_exp[j] = qdm2_get_vlc(&gb, &fft_level_exp_vlc, 0, 2);

  1215.         } else if (packet->type == 15) {

  1216.             SAMPLES_NEEDED_2("packet type 15")

  1217.             return;

  1218.         } else if (packet->type >= 16 && packet->type < 48 &&

  1219.                    !fft_subpackets[packet->type - 16]) {

  1220.             /* packets for FFT */

  1221.             QDM2_LIST_ADD(q->sub_packet_list_B, q->sub_packets_B, packet);

  1222.         }

  1223.     } // Packet bytes loop

  1224. 

  1225.     if (q->sub_packet_list_D[0].packet) {

  1226.         process_synthesis_subpackets(q, q->sub_packet_list_D);

  1227.         q->do_synth_filter = 1;

  1228.     } else if (q->do_synth_filter) {

  1229.         process_subpacket_10(q, NULL);

  1230.         process_subpacket_11(q, NULL);

  1231.         process_subpacket_12(q, NULL);

  1232.     }

  1233. }

  1234. 

  1235. static void qdm2_fft_init_coefficient(QDM2Context *q, int sub_packet,

  1236.                                       int offset, int duration, int channel,

  1237.                                       int exp, int phase)

  1238. {

  1239.     if (q->fft_coefs_min_index[duration] < 0)

  1240.         q->fft_coefs_min_index[duration] = q->fft_coefs_index;

  1241. 

  1242.     q->fft_coefs[q->fft_coefs_index].sub_packet =

  1243.         ((sub_packet >= 16) ? (sub_packet - 16) : sub_packet);

  1244.     q->fft_coefs[q->fft_coefs_index].channel = channel;

  1245.     q->fft_coefs[q->fft_coefs_index].offset  = offset;

  1246.     q->fft_coefs[q->fft_coefs_index].exp     = exp;

  1247.     q->fft_coefs[q->fft_coefs_index].phase   = phase;

  1248.     q->fft_coefs_index++;

  1249. }

  1250. 

  1251. static void qdm2_fft_decode_tones(QDM2Context *q, int duration,

  1252.                                   GetBitContext *gb, int b)

  1253. {

  1254.     int channel, stereo, phase, exp;

  1255.     int local_int_4, local_int_8, stereo_phase, local_int_10;

  1256.     int local_int_14, stereo_exp, local_int_20, local_int_28;

  1257.     int n, offset;

  1258. 

  1259.     local_int_4  = 0;

  1260.     local_int_28 = 0;

  1261.     local_int_20 = 2;

  1262.     local_int_8  = (4 - duration);

  1263.     local_int_10 = 1 << (q->group_order - duration - 1);

  1264.     offset       = 1;

  1265. 

  1266.     while (get_bits_left(gb)>0) {

  1267.         if (q->superblocktype_2_3) {

  1268.             while ((n = qdm2_get_vlc(gb, &vlc_tab_fft_tone_offset[local_int_8], 1, 2)) < 2) {

  1269.                 if (get_bits_left(gb)<0) {

  1270.                     if(local_int_4 < q->group_size)

  1271.                         av_log(NULL, AV_LOG_ERROR, "overread in qdm2_fft_decode_tones()\n");

  1272.                     return;

  1273.                 }

  1274.                 offset = 1;

  1275.                 if (n == 0) {

  1276.                     local_int_4  += local_int_10;

  1277.                     local_int_28 += (1 << local_int_8);

  1278.                 } else {

  1279.                     local_int_4  += 8 * local_int_10;

  1280.                     local_int_28 += (8 << local_int_8);

  1281.                 }

  1282.             }

  1283.             offset += (n - 2);

  1284.         } else {

  1285.             offset += qdm2_get_vlc(gb, &vlc_tab_fft_tone_offset[local_int_8], 1, 2);

  1286.             while (offset >= (local_int_10 - 1)) {

  1287.                 offset       += (1 - (local_int_10 - 1));

  1288.                 local_int_4  += local_int_10;

  1289.                 local_int_28 += (1 << local_int_8);

  1290.             }

  1291.         }

  1292. 

  1293.         if (local_int_4 >= q->group_size)

  1294.             return;

  1295. 

  1296.         local_int_14 = (offset >> local_int_8);

  1297.         if (local_int_14 >= FF_ARRAY_ELEMS(fft_level_index_table))

  1298.             return;

  1299. 

  1300.         if (q->nb_channels > 1) {

  1301.             channel = get_bits1(gb);

  1302.             stereo  = get_bits1(gb);

  1303.         } else {

  1304.             channel = 0;

  1305.             stereo  = 0;

  1306.         }

  1307. 

  1308.         exp  = qdm2_get_vlc(gb, (b ? &fft_level_exp_vlc : &fft_level_exp_alt_vlc), 0, 2);

  1309.         exp += q->fft_level_exp[fft_level_index_table[local_int_14]];

  1310.         exp  = (exp < 0) ? 0 : exp;

  1311. 

  1312.         phase        = get_bits(gb, 3);

  1313.         stereo_exp   = 0;

  1314.         stereo_phase = 0;

  1315. 

  1316.         if (stereo) {

  1317.             stereo_exp   = (exp - qdm2_get_vlc(gb, &fft_stereo_exp_vlc, 0, 1));

  1318.             stereo_phase = (phase - qdm2_get_vlc(gb, &fft_stereo_phase_vlc, 0, 1));

  1319.             if (stereo_phase < 0)

  1320.                 stereo_phase += 8;

  1321.         }

  1322. 

  1323.         if (q->frequency_range > (local_int_14 + 1)) {

  1324.             int sub_packet = (local_int_20 + local_int_28);

  1325. 

  1326.             qdm2_fft_init_coefficient(q, sub_packet, offset, duration,

  1327.                                       channel, exp, phase);

  1328.             if (stereo)

  1329.                 qdm2_fft_init_coefficient(q, sub_packet, offset, duration,

  1330.                                           1 - channel,

  1331.                                           stereo_exp, stereo_phase);

  1332.         }

  1333.         offset++;

  1334.     }

  1335. }

  1336. 

  1337. static void qdm2_decode_fft_packets(QDM2Context *q)

  1338. {

  1339.     int i, j, min, max, value, type, unknown_flag;

  1340.     GetBitContext gb;

  1341. 

  1342.     if (!q->sub_packet_list_B[0].packet)

  1343.         return;

  1344. 

  1345.     /* reset minimum indexes for FFT coefficients */

  1346.     q->fft_coefs_index = 0;

  1347.     for (i = 0; i < 5; i++)

  1348.         q->fft_coefs_min_index[i] = -1;

  1349. 

  1350.     /* process subpackets ordered by type, largest type first */

  1351.     for (i = 0, max = 256; i < q->sub_packets_B; i++) {

  1352.         QDM2SubPacket *packet = NULL;

  1353. 

  1354.         /* find subpacket with largest type less than max */

  1355.         for (j = 0, min = 0; j < q->sub_packets_B; j++) {

  1356.             value = q->sub_packet_list_B[j].packet->type;

  1357.             if (value > min && value < max) {

  1358.                 min    = value;

  1359.                 packet = q->sub_packet_list_B[j].packet;

  1360.             }

  1361.         }

  1362. 

  1363.         max = min;

  1364. 

  1365.         /* check for errors (?) */

  1366.         if (!packet)

  1367.             return;

  1368. 

  1369.         if (i == 0 &&

  1370.             (packet->type < 16 || packet->type >= 48 ||

  1371.              fft_subpackets[packet->type - 16]))

  1372.             return;

  1373. 

  1374.         /* decode FFT tones */

  1375.         init_get_bits(&gb, packet->data, packet->size * 8);

  1376. 

  1377.         if (packet->type >= 32 && packet->type < 48 && !fft_subpackets[packet->type - 16])

  1378.             unknown_flag = 1;

  1379.         else

  1380.             unknown_flag = 0;

  1381. 

  1382.         type = packet->type;

  1383. 

  1384.         if ((type >= 17 && type < 24) || (type >= 33 && type < 40)) {

  1385.             int duration = q->sub_sampling + 5 - (type & 15);

  1386. 

  1387.             if (duration >= 0 && duration < 4)

  1388.                 qdm2_fft_decode_tones(q, duration, &gb, unknown_flag);

  1389.         } else if (type == 31) {

  1390.             for (j = 0; j < 4; j++)

  1391.                 qdm2_fft_decode_tones(q, j, &gb, unknown_flag);

  1392.         } else if (type == 46) {

  1393.             for (j = 0; j < 6; j++)

  1394.                 q->fft_level_exp[j] = get_bits(&gb, 6);

  1395.             for (j = 0; j < 4; j++)

  1396.                 qdm2_fft_decode_tones(q, j, &gb, unknown_flag);

  1397.         }

  1398.     } // Loop on B packets

  1399. 

  1400.     /* calculate maximum indexes for FFT coefficients */

  1401.     for (i = 0, j = -1; i < 5; i++)

  1402.         if (q->fft_coefs_min_index[i] >= 0) {

  1403.             if (j >= 0)

  1404.                 q->fft_coefs_max_index[j] = q->fft_coefs_min_index[i];

  1405.             j = i;

  1406.         }

  1407.     if (j >= 0)

  1408.         q->fft_coefs_max_index[j] = q->fft_coefs_index;

  1409. }

  1410. 

  1411. static void qdm2_fft_generate_tone(QDM2Context *q, FFTTone *tone)

  1412. {

  1413.     float level, f[6];

  1414.     int i;

  1415.     QDM2Complex c;

  1416.     const double iscale = 2.0 * M_PI / 512.0;

  1417. 

  1418.     tone->phase += tone->phase_shift;

  1419. 

  1420.     /* calculate current level (maximum amplitude) of tone */

  1421.     level = fft_tone_envelope_table[tone->duration][tone->time_index] * tone->level;

  1422.     c.im  = level * sin(tone->phase * iscale);

  1423.     c.re  = level * cos(tone->phase * iscale);

  1424. 

  1425.     /* generate FFT coefficients for tone */

  1426.     if (tone->duration >= 3 || tone->cutoff >= 3) {

  1427.         tone->complex[0].im += c.im;

  1428.         tone->complex[0].re += c.re;

  1429.         tone->complex[1].im -= c.im;

  1430.         tone->complex[1].re -= c.re;

  1431.     } else {

  1432.         f[1] = -tone->table[4];

  1433.         f[0] = tone->table[3] - tone->table[0];

  1434.         f[2] = 1.0 - tone->table[2] - tone->table[3];

  1435.         f[3] = tone->table[1] + tone->table[4] - 1.0;

  1436.         f[4] = tone->table[0] - tone->table[1];

  1437.         f[5] = tone->table[2];

  1438.         for (i = 0; i < 2; i++) {

  1439.             tone->complex[fft_cutoff_index_table[tone->cutoff][i]].re +=

  1440.                 c.re * f[i];

  1441.             tone->complex[fft_cutoff_index_table[tone->cutoff][i]].im +=

  1442.                 c.im * ((tone->cutoff <= i) ? -f[i] : f[i]);

  1443.         }

  1444.         for (i = 0; i < 4; i++) {

  1445.             tone->complex[i].re += c.re * f[i + 2];

  1446.             tone->complex[i].im += c.im * f[i + 2];

  1447.         }

  1448.     }

  1449. 

  1450.     /* copy the tone if it has not yet died out */

  1451.     if (++tone->time_index < ((1 << (5 - tone->duration)) - 1)) {

  1452.         memcpy(&q->fft_tones[q->fft_tone_end], tone, sizeof(FFTTone));

  1453.         q->fft_tone_end = (q->fft_tone_end + 1) % 1000;

  1454.     }

  1455. }

  1456. 

  1457. static void qdm2_fft_tone_synthesizer(QDM2Context *q, int sub_packet)

  1458. {

  1459.     int i, j, ch;

  1460.     const double iscale = 0.25 * M_PI;

  1461. 

  1462.     for (ch = 0; ch < q->channels; ch++) {

  1463.         memset(q->fft.complex[ch], 0, q->fft_size * sizeof(QDM2Complex));

  1464.     }

  1465. 

  1466. 

  1467.     /* apply FFT tones with duration 4 (1 FFT period) */

  1468.     if (q->fft_coefs_min_index[4] >= 0)

  1469.         for (i = q->fft_coefs_min_index[4]; i < q->fft_coefs_max_index[4]; i++) {

  1470.             float level;

  1471.             QDM2Complex c;

  1472. 

  1473.             if (q->fft_coefs[i].sub_packet != sub_packet)

  1474.                 break;

  1475. 

  1476.             ch = (q->channels == 1) ? 0 : q->fft_coefs[i].channel;

  1477.             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];

  1478. 

  1479.             c.re = level * cos(q->fft_coefs[i].phase * iscale);

  1480.             c.im = level * sin(q->fft_coefs[i].phase * iscale);

  1481.             q->fft.complex[ch][q->fft_coefs[i].offset + 0].re += c.re;

  1482.             q->fft.complex[ch][q->fft_coefs[i].offset + 0].im += c.im;

  1483.             q->fft.complex[ch][q->fft_coefs[i].offset + 1].re -= c.re;

  1484.             q->fft.complex[ch][q->fft_coefs[i].offset + 1].im -= c.im;

  1485.         }

  1486. 

  1487.     /* generate existing FFT tones */

  1488.     for (i = q->fft_tone_end; i != q->fft_tone_start; ) {

  1489.         qdm2_fft_generate_tone(q, &q->fft_tones[q->fft_tone_start]);

  1490.         q->fft_tone_start = (q->fft_tone_start + 1) % 1000;

  1491.     }

  1492. 

  1493.     /* create and generate new FFT tones with duration 0 (long) to 3 (short) */

  1494.     for (i = 0; i < 4; i++)

  1495.         if (q->fft_coefs_min_index[i] >= 0) {

  1496.             for (j = q->fft_coefs_min_index[i]; j < q->fft_coefs_max_index[i]; j++) {

  1497.                 int offset, four_i;

  1498.                 FFTTone tone;

  1499. 

  1500.                 if (q->fft_coefs[j].sub_packet != sub_packet)

  1501.                     break;

  1502. 

  1503.                 four_i = (4 - i);

  1504.                 offset = q->fft_coefs[j].offset >> four_i;

  1505.                 ch = (q->channels == 1) ? 0 : q->fft_coefs[j].channel;

  1506. 

  1507.                 if (offset < q->frequency_range) {

  1508.                     if (offset < 2)

  1509.                         tone.cutoff = offset;

  1510.                     else

  1511.                         tone.cutoff = (offset >= 60) ? 3 : 2;

  1512. 

  1513.                     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];

  1514.                     tone.complex = &q->fft.complex[ch][offset];

  1515.                     tone.table = fft_tone_sample_table[i][q->fft_coefs[j].offset - (offset << four_i)];

  1516.                     tone.phase = 64 * q->fft_coefs[j].phase - (offset << 8) - 128;

  1517.                     tone.phase_shift = (2 * q->fft_coefs[j].offset + 1) << (7 - four_i);

  1518.                     tone.duration = i;

  1519.                     tone.time_index = 0;

  1520. 

  1521.                     qdm2_fft_generate_tone(q, &tone);

  1522.                 }

  1523.             }

  1524.             q->fft_coefs_min_index[i] = j;

  1525.         }

  1526. }

  1527. 

  1528. static void qdm2_calculate_fft(QDM2Context *q, int channel, int sub_packet)

  1529. {

  1530.     const float gain = (q->channels == 1 && q->nb_channels == 2) ? 0.5f : 1.0f;

  1531.     float *out       = q->output_buffer + channel;

  1532.     int i;

  1533.     q->fft.complex[channel][0].re *= 2.0f;

  1534.     q->fft.complex[channel][0].im  = 0.0f;

  1535.     q->rdft_ctx.rdft_calc(&q->rdft_ctx, (FFTSample *)q->fft.complex[channel]);

  1536.     /* add samples to output buffer */

  1537.     for (i = 0; i < FFALIGN(q->fft_size, 8); i++) {

  1538.         out[0]           += q->fft.complex[channel][i].re * gain;

  1539.         out[q->channels] += q->fft.complex[channel][i].im * gain;

  1540.         out              += 2 * q->channels;

  1541.     }

  1542. }

  1543. 

  1544. /**

  1545.  * @param q        context

  1546.  * @param index    subpacket number

  1547.  */

  1548. static void qdm2_synthesis_filter(QDM2Context *q, int index)

  1549. {

  1550.     int i, k, ch, sb_used, sub_sampling, dither_state = 0;

  1551. 

  1552.     /* copy sb_samples */

  1553.     sb_used = QDM2_SB_USED(q->sub_sampling);

  1554. 

  1555.     for (ch = 0; ch < q->channels; ch++)

  1556.         for (i = 0; i < 8; i++)

  1557.             for (k = sb_used; k < SBLIMIT; k++)

  1558.                 q->sb_samples[ch][(8 * index) + i][k] = 0;

  1559. 

  1560.     for (ch = 0; ch < q->nb_channels; ch++) {

  1561.         float *samples_ptr = q->samples + ch;

  1562. 

  1563.         for (i = 0; i < 8; i++) {

  1564.             ff_mpa_synth_filter_float(&q->mpadsp,

  1565.                                       q->synth_buf[ch], &(q->synth_buf_offset[ch]),

  1566.                                       ff_mpa_synth_window_float, &dither_state,

  1567.                                       samples_ptr, q->nb_channels,

  1568.                                       q->sb_samples[ch][(8 * index) + i]);

  1569.             samples_ptr += 32 * q->nb_channels;

  1570.         }

  1571.     }

  1572. 

  1573.     /* add samples to output buffer */

  1574.     sub_sampling = (4 >> q->sub_sampling);

  1575. 

  1576.     for (ch = 0; ch < q->channels; ch++)

  1577.         for (i = 0; i < q->frame_size; i++)

  1578.             q->output_buffer[q->channels * i + ch] += (1 << 23) * q->samples[q->nb_channels * sub_sampling * i + ch];

  1579. }

  1580. 

  1581. /**

  1582.  * Init static data (does not depend on specific file)

  1583.  *

  1584.  * @param q    context

  1585.  */

  1586. static av_cold void qdm2_init_static_data(void) {

  1587.     static int done;

  1588. 

  1589.     if(done)

  1590.         return;

  1591. 

  1592.     qdm2_init_vlc();

  1593.     ff_mpa_synth_init_float(ff_mpa_synth_window_float);

  1594.     softclip_table_init();

  1595.     rnd_table_init();

  1596.     init_noise_samples();

  1597. 

  1598.     done = 1;

  1599. }

  1600. 

  1601. /**

  1602.  * Init parameters from codec extradata

  1603.  */

  1604. static av_cold int qdm2_decode_init(AVCodecContext *avctx)

  1605. {

  1606.     QDM2Context *s = avctx->priv_data;

  1607.     uint8_t *extradata;

  1608.     int extradata_size;

  1609.     int tmp_val, tmp, size;

  1610. 

  1611.     qdm2_init_static_data();

  1612. 

  1613.     /* extradata parsing

  1614. 

  1615.     Structure:

  1616.     wave {

  1617.         frma (QDM2)

  1618.         QDCA

  1619.         QDCP

  1620.     }

  1621. 

  1622.     32  size (including this field)

  1623.     32  tag (=frma)

  1624.     32  type (=QDM2 or QDMC)

  1625. 

  1626.     32  size (including this field, in bytes)

  1627.     32  tag (=QDCA) // maybe mandatory parameters

  1628.     32  unknown (=1)

  1629.     32  channels (=2)

  1630.     32  samplerate (=44100)

  1631.     32  bitrate (=96000)

  1632.     32  block size (=4096)

  1633.     32  frame size (=256) (for one channel)

  1634.     32  packet size (=1300)

  1635. 

  1636.     32  size (including this field, in bytes)

  1637.     32  tag (=QDCP) // maybe some tuneable parameters

  1638.     32  float1 (=1.0)

  1639.     32  zero ?

  1640.     32  float2 (=1.0)

  1641.     32  float3 (=1.0)

  1642.     32  unknown (27)

  1643.     32  unknown (8)

  1644.     32  zero ?

  1645.     */

  1646. 

  1647.     if (!avctx->extradata || (avctx->extradata_size < 48)) {

  1648.         av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n");

  1649.         return AVERROR_INVALIDDATA;

  1650.     }

  1651. 

  1652.     extradata      = avctx->extradata;

  1653.     extradata_size = avctx->extradata_size;

  1654. 

  1655.     while (extradata_size > 7) {

  1656.         if (!memcmp(extradata, "frmaQDM", 7))

  1657.             break;

  1658.         extradata++;

  1659.         extradata_size--;

  1660.     }

  1661. 

  1662.     if (extradata_size < 12) {

  1663.         av_log(avctx, AV_LOG_ERROR, "not enough extradata (%i)\n",

  1664.                extradata_size);

  1665.         return AVERROR_INVALIDDATA;

  1666.     }

  1667. 

  1668.     if (memcmp(extradata, "frmaQDM", 7)) {

  1669.         av_log(avctx, AV_LOG_ERROR, "invalid headers, QDM? not found\n");

  1670.         return AVERROR_INVALIDDATA;

  1671.     }

  1672. 

  1673.     if (extradata[7] == 'C') {

  1674. //        s->is_qdmc = 1;

  1675.         avpriv_report_missing_feature(avctx, "QDMC version 1");

  1676.         return AVERROR_PATCHWELCOME;

  1677.     }

  1678. 

  1679.     extradata += 8;

  1680.     extradata_size -= 8;

  1681. 

  1682.     size = AV_RB32(extradata);

  1683. 

  1684.     if(size > extradata_size){

  1685.         av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n",

  1686.                extradata_size, size);

  1687.         return AVERROR_INVALIDDATA;

  1688.     }

  1689. 

  1690.     extradata += 4;

  1691.     av_log(avctx, AV_LOG_DEBUG, "size: %d\n", size);

  1692.     if (AV_RB32(extradata) != MKBETAG('Q','D','C','A')) {

  1693.         av_log(avctx, AV_LOG_ERROR, "invalid extradata, expecting QDCA\n");

  1694.         return AVERROR_INVALIDDATA;

  1695.     }

  1696. 

  1697.     extradata += 8;

  1698. 

  1699.     avctx->channels = s->nb_channels = s->channels = AV_RB32(extradata);

  1700.     extradata += 4;

  1701.     if (s->channels <= 0 || s->channels > MPA_MAX_CHANNELS) {

  1702.         av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");

  1703.         return AVERROR_INVALIDDATA;

  1704.     }

  1705.     avctx->channel_layout = avctx->channels == 2 ? AV_CH_LAYOUT_STEREO :

  1706.                                                    AV_CH_LAYOUT_MONO;

  1707. 

  1708.     avctx->sample_rate = AV_RB32(extradata);

  1709.     extradata += 4;

  1710. 

  1711.     avctx->bit_rate = AV_RB32(extradata);

  1712.     extradata += 4;

  1713. 

  1714.     s->group_size = AV_RB32(extradata);

  1715.     extradata += 4;

  1716. 

  1717.     s->fft_size = AV_RB32(extradata);

  1718.     extradata += 4;

  1719. 

  1720.     s->checksum_size = AV_RB32(extradata);

  1721.     if (s->checksum_size >= 1U << 28) {

  1722.         av_log(avctx, AV_LOG_ERROR, "data block size too large (%u)\n", s->checksum_size);

  1723.         return AVERROR_INVALIDDATA;

  1724.     }

  1725. 

  1726.     s->fft_order = av_log2(s->fft_size) + 1;

  1727. 

  1728.     // something like max decodable tones

  1729.     s->group_order = av_log2(s->group_size) + 1;

  1730.     s->frame_size = s->group_size / 16; // 16 iterations per super block

  1731. 

  1732.     if (s->frame_size > QDM2_MAX_FRAME_SIZE)

  1733.         return AVERROR_INVALIDDATA;

  1734. 

  1735.     s->sub_sampling = s->fft_order - 7;

  1736.     s->frequency_range = 255 / (1 << (2 - s->sub_sampling));

  1737. 

  1738.     switch ((s->sub_sampling * 2 + s->channels - 1)) {

  1739.         case 0: tmp = 40; break;

  1740.         case 1: tmp = 48; break;

  1741.         case 2: tmp = 56; break;

  1742.         case 3: tmp = 72; break;

  1743.         case 4: tmp = 80; break;

  1744.         case 5: tmp = 100;break;

  1745.         default: tmp=s->sub_sampling; break;

  1746.     }

  1747.     tmp_val = 0;

  1748.     if ((tmp * 1000) < avctx->bit_rate)  tmp_val = 1;

  1749.     if ((tmp * 1440) < avctx->bit_rate)  tmp_val = 2;

  1750.     if ((tmp * 1760) < avctx->bit_rate)  tmp_val = 3;

  1751.     if ((tmp * 2240) < avctx->bit_rate)  tmp_val = 4;

  1752.     s->cm_table_select = tmp_val;

  1753. 

  1754.     if (avctx->bit_rate <= 8000)

  1755.         s->coeff_per_sb_select = 0;

  1756.     else if (avctx->bit_rate < 16000)

  1757.         s->coeff_per_sb_select = 1;

  1758.     else

  1759.         s->coeff_per_sb_select = 2;

  1760. 

  1761.     // Fail on unknown fft order

  1762.     if ((s->fft_order < 7) || (s->fft_order > 9)) {

  1763.         avpriv_request_sample(avctx, "Unknown FFT order %d", s->fft_order);

  1764.         return AVERROR_PATCHWELCOME;

  1765.     }

  1766.     if (s->fft_size != (1 << (s->fft_order - 1))) {

  1767.         av_log(avctx, AV_LOG_ERROR, "FFT size %d not power of 2.\n", s->fft_size);

  1768.         return AVERROR_INVALIDDATA;

  1769.     }

  1770. 

  1771.     ff_rdft_init(&s->rdft_ctx, s->fft_order, IDFT_C2R);

  1772.     ff_mpadsp_init(&s->mpadsp);

  1773. 

  1774.     avctx->sample_fmt = AV_SAMPLE_FMT_S16;

  1775. 

  1776.     return 0;

  1777. }

  1778. 

  1779. static av_cold int qdm2_decode_close(AVCodecContext *avctx)

  1780. {

  1781.     QDM2Context *s = avctx->priv_data;

  1782. 

  1783.     ff_rdft_end(&s->rdft_ctx);

  1784. 

  1785.     return 0;

  1786. }

  1787. 

  1788. static int qdm2_decode(QDM2Context *q, const uint8_t *in, int16_t *out)

  1789. {

  1790.     int ch, i;

  1791.     const int frame_size = (q->frame_size * q->channels);

  1792. 

  1793.     if((unsigned)frame_size > FF_ARRAY_ELEMS(q->output_buffer)/2)

  1794.         return -1;

  1795. 

  1796.     /* select input buffer */

  1797.     q->compressed_data = in;

  1798.     q->compressed_size = q->checksum_size;

  1799. 

  1800.     /* copy old block, clear new block of output samples */

  1801.     memmove(q->output_buffer, &q->output_buffer[frame_size], frame_size * sizeof(float));

  1802.     memset(&q->output_buffer[frame_size], 0, frame_size * sizeof(float));

  1803. 

  1804.     /* decode block of QDM2 compressed data */

  1805.     if (q->sub_packet == 0) {

  1806.         q->has_errors = 0; // zero it for a new super block

  1807.         av_log(NULL,AV_LOG_DEBUG,"Superblock follows\n");

  1808.         qdm2_decode_super_block(q);

  1809.     }

  1810. 

  1811.     /* parse subpackets */

  1812.     if (!q->has_errors) {

  1813.         if (q->sub_packet == 2)

  1814.             qdm2_decode_fft_packets(q);

  1815. 

  1816.         qdm2_fft_tone_synthesizer(q, q->sub_packet);

  1817.     }

  1818. 

  1819.     /* sound synthesis stage 1 (FFT) */

  1820.     for (ch = 0; ch < q->channels; ch++) {

  1821.         qdm2_calculate_fft(q, ch, q->sub_packet);

  1822. 

  1823.         if (!q->has_errors && q->sub_packet_list_C[0].packet) {

  1824.             SAMPLES_NEEDED_2("has errors, and C list is not empty")

  1825.             return -1;

  1826.         }

  1827.     }

  1828. 

  1829.     /* sound synthesis stage 2 (MPEG audio like synthesis filter) */

  1830.     if (!q->has_errors && q->do_synth_filter)

  1831.         qdm2_synthesis_filter(q, q->sub_packet);

  1832. 

  1833.     q->sub_packet = (q->sub_packet + 1) % 16;

  1834. 

  1835.     /* clip and convert output float[] to 16bit signed samples */

  1836.     for (i = 0; i < frame_size; i++) {

  1837.         int value = (int)q->output_buffer[i];

  1838. 

  1839.         if (value > SOFTCLIP_THRESHOLD)

  1840.             value = (value >  HARDCLIP_THRESHOLD) ?  32767 :  softclip_table[ value - SOFTCLIP_THRESHOLD];

  1841.         else if (value < -SOFTCLIP_THRESHOLD)

  1842.             value = (value < -HARDCLIP_THRESHOLD) ? -32767 : -softclip_table[-value - SOFTCLIP_THRESHOLD];

  1843. 

  1844.         out[i] = value;

  1845.     }

  1846. 

  1847.     return 0;

  1848. }

  1849. 

  1850. static int qdm2_decode_frame(AVCodecContext *avctx, void *data,

  1851.                              int *got_frame_ptr, AVPacket *avpkt)

  1852. {

  1853.     AVFrame *frame     = data;

  1854.     const uint8_t *buf = avpkt->data;

  1855.     int buf_size = avpkt->size;

  1856.     QDM2Context *s = avctx->priv_data;

  1857.     int16_t *out;

  1858.     int i, ret;

  1859. 

  1860.     if(!buf)

  1861.         return 0;

  1862.     if(buf_size < s->checksum_size)

  1863.         return -1;

  1864. 

  1865.     /* get output buffer */

  1866.     frame->nb_samples = 16 * s->frame_size;

  1867.     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

  1868.         return ret;

  1869.     out = (int16_t *)frame->data[0];

  1870. 

  1871.     for (i = 0; i < 16; i++) {

  1872.         if ((ret = qdm2_decode(s, buf, out)) < 0)

  1873.             return ret;

  1874.         out += s->channels * s->frame_size;

  1875.     }

  1876. 

  1877.     *got_frame_ptr = 1;

  1878. 

  1879.     return s->checksum_size;

  1880. }

  1881. 

  1882. AVCodec ff_qdm2_decoder = {

  1883.     .name             = "qdm2",

  1884.     .long_name        = NULL_IF_CONFIG_SMALL("QDesign Music Codec 2"),

  1885.     .type             = AVMEDIA_TYPE_AUDIO,

  1886.     .id               = AV_CODEC_ID_QDM2,

  1887.     .priv_data_size   = sizeof(QDM2Context),

  1888.     .init             = qdm2_decode_init,

  1889.     .close            = qdm2_decode_close,

  1890.     .decode           = qdm2_decode_frame,

  1891.     .capabilities     = AV_CODEC_CAP_DR1,

  1892. };