Subversion Repositories Kolibri OS

/*

 * QDM2 compatible decoder

 * Copyright (c) 2003 Ewald Snel

 * Copyright (c) 2005 Benjamin Larsson

 * Copyright (c) 2005 Alex Beregszaszi

 * Copyright (c) 2005 Roberto Togni

 *

 * This file is part of FFmpeg.

 *

 * FFmpeg is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * FFmpeg is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with FFmpeg; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 */

/**

 * @file

 * QDM2 decoder

 * @author Ewald Snel, Benjamin Larsson, Alex Beregszaszi, Roberto Togni

 *

 * The decoder is not perfect yet, there are still some distortions

 * especially on files encoded with 16 or 8 subbands.

 */

#include 

#include 

#include 

#define BITSTREAM_READER_LE

#include "libavutil/channel_layout.h"

#include "avcodec.h"

#include "get_bits.h"

#include "internal.h"

#include "rdft.h"

#include "mpegaudiodsp.h"

#include "mpegaudio.h"

#include "qdm2data.h"

#include "qdm2_tablegen.h"

#undef NDEBUG

#include 

#define QDM2_LIST_ADD(list, size, packet) \

do { \

      if (size > 0) { \

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

      } \

      list[size].packet = packet; \

      list[size].next = NULL; \

      size++; \

} while(0)

// Result is 8, 16 or 30

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

#define FIX_NOISE_IDX(noise_idx) \

  if ((noise_idx) >= 3840) \

    (noise_idx) -= 3840; \

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

#define SAMPLES_NEEDED \

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

#define SAMPLES_NEEDED_2(why) \

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

#define QDM2_MAX_FRAME_SIZE 512

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

/**

 * Subpacket

 */

typedef struct {

    int type;            ///< subpacket type

    unsigned int size;   ///< subpacket size

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

} QDM2SubPacket;

/**

 * A node in the subpacket list

 */

typedef struct QDM2SubPNode {

    QDM2SubPacket *packet;      ///< packet

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

} QDM2SubPNode;

typedef struct {

    float re;

    float im;

} QDM2Complex;

typedef struct {

    float level;

    QDM2Complex *complex;

    const float *table;

    int   phase;

    int   phase_shift;

    int   duration;

    short time_index;

    short cutoff;

} FFTTone;

typedef struct {

    int16_t sub_packet;

    uint8_t channel;

    int16_t offset;

    int16_t exp;

    uint8_t phase;

} FFTCoefficient;

typedef struct {

    DECLARE_ALIGNED(32, QDM2Complex, complex)[MPA_MAX_CHANNELS][256];

} QDM2FFT;

/**

 * QDM2 decoder context

 */

typedef struct {

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

    int nb_channels;         ///< number of channels

    int channels;            ///< number of channels

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

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

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

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

    int group_order;         ///< order of frame group

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

    int frame_size;          ///< size of data frame

    int frequency_range;

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

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

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

    /// Packets and packet lists

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

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

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

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

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

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

    /// FFT and tones

    FFTTone fft_tones[1000];

    int fft_tone_start;

    int fft_tone_end;

    FFTCoefficient fft_coefs[1000];

    int fft_coefs_index;

    int fft_coefs_min_index[5];

    int fft_coefs_max_index[5];

    int fft_level_exp[6];

    RDFTContext rdft_ctx;

    QDM2FFT fft;

    /// I/O data

    const uint8_t *compressed_data;

    int compressed_size;

    float output_buffer[QDM2_MAX_FRAME_SIZE * MPA_MAX_CHANNELS * 2];

    /// Synthesis filter

    MPADSPContext mpadsp;

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

    int synth_buf_offset[MPA_MAX_CHANNELS];

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

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

    /// Mixed temporary data used in decoding

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

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

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

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

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

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

    int8_t tone_level_idx_hi2[MPA_MAX_CHANNELS][26];

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

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

    // Flags

    int has_errors;         ///< packet has errors

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

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

    int sub_packet;

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

} QDM2Context;

static VLC vlc_tab_level;

static VLC vlc_tab_diff;

static VLC vlc_tab_run;

static VLC fft_level_exp_alt_vlc;

static VLC fft_level_exp_vlc;

static VLC fft_stereo_exp_vlc;

static VLC fft_stereo_phase_vlc;

static VLC vlc_tab_tone_level_idx_hi1;

static VLC vlc_tab_tone_level_idx_mid;

static VLC vlc_tab_tone_level_idx_hi2;

static VLC vlc_tab_type30;

static VLC vlc_tab_type34;

static VLC vlc_tab_fft_tone_offset[5];

static const uint16_t qdm2_vlc_offs[] = {

    0,260,566,598,894,1166,1230,1294,1678,1950,2214,2278,2310,2570,2834,3124,3448,3838,

};

static const int switchtable[23] = {

    0, 5, 1, 5, 5, 5, 5, 5, 2, 5, 5, 5, 5, 5, 5, 5, 3, 5, 5, 5, 5, 5, 4

};

static av_cold void qdm2_init_vlc(void)

{

    static VLC_TYPE qdm2_table[3838][2];

    vlc_tab_level.table           = &qdm2_table[qdm2_vlc_offs[0]];

    vlc_tab_level.table_allocated = qdm2_vlc_offs[1] - qdm2_vlc_offs[0];

    init_vlc(&vlc_tab_level, 8, 24,

             vlc_tab_level_huffbits, 1, 1,

             vlc_tab_level_huffcodes, 2, 2,

             INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

    vlc_tab_diff.table           = &qdm2_table[qdm2_vlc_offs[1]];

    vlc_tab_diff.table_allocated = qdm2_vlc_offs[2] - qdm2_vlc_offs[1];

    init_vlc(&vlc_tab_diff, 8, 37,

             vlc_tab_diff_huffbits, 1, 1,

             vlc_tab_diff_huffcodes, 2, 2,

             INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

    vlc_tab_run.table           = &qdm2_table[qdm2_vlc_offs[2]];

    vlc_tab_run.table_allocated = qdm2_vlc_offs[3] - qdm2_vlc_offs[2];

    init_vlc(&vlc_tab_run, 5, 6,

             vlc_tab_run_huffbits, 1, 1,

             vlc_tab_run_huffcodes, 1, 1,

             INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

    fft_level_exp_alt_vlc.table           = &qdm2_table[qdm2_vlc_offs[3]];

    fft_level_exp_alt_vlc.table_allocated = qdm2_vlc_offs[4] -

                                            qdm2_vlc_offs[3];

    init_vlc(&fft_level_exp_alt_vlc, 8, 28,

             fft_level_exp_alt_huffbits, 1, 1,

             fft_level_exp_alt_huffcodes, 2, 2,

             INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

    fft_level_exp_vlc.table           = &qdm2_table[qdm2_vlc_offs[4]];

    fft_level_exp_vlc.table_allocated = qdm2_vlc_offs[5] - qdm2_vlc_offs[4];

    init_vlc(&fft_level_exp_vlc, 8, 20,

             fft_level_exp_huffbits, 1, 1,

             fft_level_exp_huffcodes, 2, 2,

             INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

    fft_stereo_exp_vlc.table           = &qdm2_table[qdm2_vlc_offs[5]];

    fft_stereo_exp_vlc.table_allocated = qdm2_vlc_offs[6] -

                                         qdm2_vlc_offs[5];

    init_vlc(&fft_stereo_exp_vlc, 6, 7,

             fft_stereo_exp_huffbits, 1, 1,

             fft_stereo_exp_huffcodes, 1, 1,

             INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

    fft_stereo_phase_vlc.table           = &qdm2_table[qdm2_vlc_offs[6]];

    fft_stereo_phase_vlc.table_allocated = qdm2_vlc_offs[7] -

                                           qdm2_vlc_offs[6];

    init_vlc(&fft_stereo_phase_vlc, 6, 9,

             fft_stereo_phase_huffbits, 1, 1,

             fft_stereo_phase_huffcodes, 1, 1,

             INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

    vlc_tab_tone_level_idx_hi1.table =

        &qdm2_table[qdm2_vlc_offs[7]];

    vlc_tab_tone_level_idx_hi1.table_allocated = qdm2_vlc_offs[8] -

                                                 qdm2_vlc_offs[7];

    init_vlc(&vlc_tab_tone_level_idx_hi1, 8, 20,

             vlc_tab_tone_level_idx_hi1_huffbits, 1, 1,

             vlc_tab_tone_level_idx_hi1_huffcodes, 2, 2,

             INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

    vlc_tab_tone_level_idx_mid.table =

        &qdm2_table[qdm2_vlc_offs[8]];

    vlc_tab_tone_level_idx_mid.table_allocated = qdm2_vlc_offs[9] -

                                                 qdm2_vlc_offs[8];

    init_vlc(&vlc_tab_tone_level_idx_mid, 8, 24,

             vlc_tab_tone_level_idx_mid_huffbits, 1, 1,

             vlc_tab_tone_level_idx_mid_huffcodes, 2, 2,

             INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

    vlc_tab_tone_level_idx_hi2.table =

        &qdm2_table[qdm2_vlc_offs[9]];

    vlc_tab_tone_level_idx_hi2.table_allocated = qdm2_vlc_offs[10] -

                                                 qdm2_vlc_offs[9];

    init_vlc(&vlc_tab_tone_level_idx_hi2, 8, 24,

             vlc_tab_tone_level_idx_hi2_huffbits, 1, 1,

             vlc_tab_tone_level_idx_hi2_huffcodes, 2, 2,

             INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

    vlc_tab_type30.table           = &qdm2_table[qdm2_vlc_offs[10]];

    vlc_tab_type30.table_allocated = qdm2_vlc_offs[11] - qdm2_vlc_offs[10];

    init_vlc(&vlc_tab_type30, 6, 9,

             vlc_tab_type30_huffbits, 1, 1,

             vlc_tab_type30_huffcodes, 1, 1,

             INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

    vlc_tab_type34.table           = &qdm2_table[qdm2_vlc_offs[11]];

    vlc_tab_type34.table_allocated = qdm2_vlc_offs[12] - qdm2_vlc_offs[11];

    init_vlc(&vlc_tab_type34, 5, 10,

             vlc_tab_type34_huffbits, 1, 1,

             vlc_tab_type34_huffcodes, 1, 1,

             INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

    vlc_tab_fft_tone_offset[0].table =

        &qdm2_table[qdm2_vlc_offs[12]];

    vlc_tab_fft_tone_offset[0].table_allocated = qdm2_vlc_offs[13] -

                                                 qdm2_vlc_offs[12];

    init_vlc(&vlc_tab_fft_tone_offset[0], 8, 23,

             vlc_tab_fft_tone_offset_0_huffbits, 1, 1,

             vlc_tab_fft_tone_offset_0_huffcodes, 2, 2,

             INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

    vlc_tab_fft_tone_offset[1].table =

        &qdm2_table[qdm2_vlc_offs[13]];

    vlc_tab_fft_tone_offset[1].table_allocated = qdm2_vlc_offs[14] -

                                                 qdm2_vlc_offs[13];

    init_vlc(&vlc_tab_fft_tone_offset[1], 8, 28,

             vlc_tab_fft_tone_offset_1_huffbits, 1, 1,

             vlc_tab_fft_tone_offset_1_huffcodes, 2, 2,

             INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

    vlc_tab_fft_tone_offset[2].table =

        &qdm2_table[qdm2_vlc_offs[14]];

    vlc_tab_fft_tone_offset[2].table_allocated = qdm2_vlc_offs[15] -

                                                 qdm2_vlc_offs[14];

    init_vlc(&vlc_tab_fft_tone_offset[2], 8, 32,

             vlc_tab_fft_tone_offset_2_huffbits, 1, 1,

             vlc_tab_fft_tone_offset_2_huffcodes, 2, 2,

             INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

    vlc_tab_fft_tone_offset[3].table =

        &qdm2_table[qdm2_vlc_offs[15]];

    vlc_tab_fft_tone_offset[3].table_allocated = qdm2_vlc_offs[16] -

                                                 qdm2_vlc_offs[15];

    init_vlc(&vlc_tab_fft_tone_offset[3], 8, 35,

             vlc_tab_fft_tone_offset_3_huffbits, 1, 1,

             vlc_tab_fft_tone_offset_3_huffcodes, 2, 2,

             INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

    vlc_tab_fft_tone_offset[4].table =

        &qdm2_table[qdm2_vlc_offs[16]];

    vlc_tab_fft_tone_offset[4].table_allocated = qdm2_vlc_offs[17] -

                                                 qdm2_vlc_offs[16];

    init_vlc(&vlc_tab_fft_tone_offset[4], 8, 38,

             vlc_tab_fft_tone_offset_4_huffbits, 1, 1,

             vlc_tab_fft_tone_offset_4_huffcodes, 2, 2,

             INIT_VLC_USE_NEW_STATIC | INIT_VLC_LE);

}

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

{

    int value;

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

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

    if (value-- == 0)

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

    /* stage-3, optional */

    if (flag) {

        int tmp;

        if (value >= 60) {

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

            return 0;

        }

        tmp= vlc_stage3_values[value];

        if ((value & ~3) > 0)

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

        value = tmp;

    }

    return value;

}

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

{

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

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

}

/**

 * QDM2 checksum

 *

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

 * @param length    data length

 * @param value     checksum value

 *

 * @return          0 if checksum is OK

 */

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

{

    int i;

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

        value -= data[i];

    return (uint16_t)(value & 0xffff);

}

/**

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

 *

 * @param gb            bitreader context

 * @param sub_packet    packet under analysis

 */

static void qdm2_decode_sub_packet_header(GetBitContext *gb,

                                          QDM2SubPacket *sub_packet)

{

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

    if (sub_packet->type == 0) {

        sub_packet->size = 0;

        sub_packet->data = NULL;

    } else {

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

        if (sub_packet->type & 0x80) {

            sub_packet->size <<= 8;

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

            sub_packet->type  &= 0x7f;

        }

        if (sub_packet->type == 0x7f)

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

        // FIXME: this depends on bitreader-internal data

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

    }

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

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

}

/**

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

 *

 * @param list    list of subpackets to be scanned

 * @param type    type of searched subpacket

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

 */

static QDM2SubPNode *qdm2_search_subpacket_type_in_list(QDM2SubPNode *list,

                                                        int type)

{

    while (list != NULL && list->packet != NULL) {

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

            return list;

        list = list->next;

    }

    return NULL;

}

/**

 * Replace 8 elements with their average value.

 * Called by qdm2_decode_superblock before starting subblock decoding.

 *

 * @param q       context

 */

static void average_quantized_coeffs(QDM2Context *q)

{

    int i, j, n, ch, sum;

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

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

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

            sum = 0;

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

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

            sum /= 8;

            if (sum > 0)

                sum--;

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

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

        }

}

/**

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

 * Called by synthfilt_build_sb_samples.

 *

 * @param q     context

 * @param sb    subband index

 */

static void build_sb_samples_from_noise(QDM2Context *q, int sb)

{

    int ch, j;

    FIX_NOISE_IDX(q->noise_idx);

    if (!q->nb_channels)

        return;

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

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

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

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

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

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

        }

    }

}

/**

 * Called while processing data from subpackets 11 and 12.

 * Used after making changes to coding_method array.

 *

 * @param sb               subband index

 * @param channels         number of channels

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

 */

static int fix_coding_method_array(int sb, int channels,

                                   sb_int8_array coding_method)

{

    int j, k;

    int ch;

    int run, case_val;

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

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

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

                return -1;

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

                run      = 1;

                case_val = 8;

            } else {

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

                case 0: run  = 10;

                    case_val = 10;

                    break;

                case 1: run  = 1;

                    case_val = 16;

                    break;

                case 2: run  = 5;

                    case_val = 24;

                    break;

                case 3: run  = 3;

                    case_val = 30;

                    break;

                case 4: run  = 1;

                    case_val = 30;

                    break;

                case 5: run  = 1;

                    case_val = 8;

                    break;

                default: run = 1;

                    case_val = 8;

                    break;

                }

            }

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

                if (j + k < 128) {

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

                        if (k > 0) {

                            SAMPLES_NEEDED

                            //not debugged, almost never used

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

                                   k *sizeof(int8_t));

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

                                   3 * sizeof(int8_t));

                        }

                    }

                }

            }

            j += run;

        }

    }

    return 0;

}

/**

 * Related to synthesis filter

 * Called by process_subpacket_10

 *

 * @param q       context

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

 */

static void fill_tone_level_array(QDM2Context *q, int flag)

{

    int i, sb, ch, sb_used;

    int tmp, tab;

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

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

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

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

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

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

                else

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

                if(tmp < 0)

                    tmp += 0xff;

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

            }

    sb_used = QDM2_SB_USED(q->sub_sampling);

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

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

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

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

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

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

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

                    else

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

                }

    } else {

        tab = q->superblocktype_2_3 ? 0 : 1;

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

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

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

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

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

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

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

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

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

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

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

                        else

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

                }

            } else {

                if (sb > 4) {

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

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

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

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

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

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

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

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

                            else

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

                    }

                } else {

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

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

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

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

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

                            else

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

                        }

                }

            }

        }

    }

}

/**

 * Related to synthesis filter

 * Called by process_subpacket_11

 * c is built with data from subpacket 11

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

 * never seen it in samples.

 *

 * @param tone_level_idx

 * @param tone_level_idx_temp

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

 * @param nb_channels          number of channels

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

 * @param superblocktype_2_3   flag based on superblock packet type

 * @param cm_table_select      q->cm_table_select

 */

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)

{

    int ch, sb, j;

    int tmp, acc, esp_40, comp;

    int add1, add2, add3, add4;

    int64_t multres;

    if (!superblocktype_2_3) {

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

        avpriv_request_sample(NULL, "!superblocktype_2_3");

        return;

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

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

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

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

                    if (add1 < 0)

                        add1 = 0;

                    add2 = add3 = add4 = 0;

                    if (sb > 1) {

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

                        if (add2 < 0)

                            add2 = 0;

                    }

                    if (sb > 0) {

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

                        if (add3 < 0)

                            add3 = 0;

                    }

                    if (sb < 29) {

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

                        if (add4 < 0)

                            add4 = 0;

                    }

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

                    if (tmp < 0)

                        tmp = 0;

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

                }

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

            }

            acc = 0;

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

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

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

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

            multres = 0x66666667LL * (acc * 10);

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

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

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

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

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

                        if (comp < 0)

                            comp += 0xff;

                        comp /= 256; // signed shift

                        switch(sb) {

                            case 0:

                                if (comp < 30)

                                    comp = 30;

                                comp += 15;

                                break;

                            case 1:

                                if (comp < 24)

                                    comp = 24;

                                comp += 10;

                                break;

                            case 2:

                            case 3:

                            case 4:

                                if (comp < 16)

                                    comp = 16;

                        }

                        if (comp <= 5)

                            tmp = 0;

                        else if (comp <= 10)

                            tmp = 10;

                        else if (comp <= 16)

                            tmp = 16;

                        else if (comp <= 24)

                            tmp = -1;

                        else

                            tmp = 0;

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

                    }

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

                fix_coding_method_array(sb, nb_channels, coding_method);

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

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

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

                        if (sb >= 10) {

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

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

                        } else {

                            if (sb >= 2) {

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

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

                            } else {

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

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

                            }

                        }

    } else { // superblocktype_2_3 != 0

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

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

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

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

    }

}

/**

 *

 * Called by process_subpacket_11 to process more data from subpacket 11

 * with sb 0-8.

 * Called by process_subpacket_12 to process data from subpacket 12 with

 * sb 8-sb_used.

 *

 * @param q         context

 * @param gb        bitreader context

 * @param length    packet length in bits

 * @param sb_min    lower subband processed (sb_min included)

 * @param sb_max    higher subband processed (sb_max excluded)

 */

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

                                       int length, int sb_min, int sb_max)

{

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

    int joined_stereo, zero_encoding;

    int type34_first;

    float type34_div = 0;

    float type34_predictor;

    float samples[10];

    int sign_bits[16] = {0};

    if (length == 0) {

        // If no data use noise

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

            build_sb_samples_from_noise(q, sb);

        return 0;

    }

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

        channels = q->nb_channels;

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

            joined_stereo = 0;

        else if (sb >= 24)

            joined_stereo = 1;

        else

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

        if (joined_stereo) {

            if (get_bits_left(gb) >= 16)

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

                    sign_bits[j] = get_bits1(gb);

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

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

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

            if (fix_coding_method_array(sb, q->nb_channels,

                                            q->coding_method)) {

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

                build_sb_samples_from_noise(q, sb);

                continue;

            }

            channels = 1;

        }

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

            FIX_NOISE_IDX(q->noise_idx);

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

            type34_predictor = 0.0;

            type34_first = 1;

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

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

                    case 8:

                        if (get_bits_left(gb) >= 10) {

                            if (zero_encoding) {

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

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

                                        break;

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

                                }

                            } else {

                                n = get_bits(gb, 8);

                                if (n >= 243) {

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

                                    return AVERROR_INVALIDDATA;

                                }

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

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

                            }

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

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

                        } else {

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

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

                        }

                        run = 10;

                        break;

                    case 10:

                        if (get_bits_left(gb) >= 1) {

                            float f = 0.81;

                            if (get_bits1(gb))

                                f = -f;

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

                            samples[0] = f;

                        } else {

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

                        }

                        run = 1;

                        break;

                    case 16:

                        if (get_bits_left(gb) >= 10) {

                            if (zero_encoding) {

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

                                    if ((j + k) >= 128)

                                        break;

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

                                }

                            } else {

                                n = get_bits (gb, 8);

                                if (n >= 243) {

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

                                    return AVERROR_INVALIDDATA;

                                }

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

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

                            }

                        } else {

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

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

                        }

                        run = 5;

                        break;

                    case 24:

                        if (get_bits_left(gb) >= 7) {

                            n = get_bits(gb, 7);

                            if (n >= 125) {

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

                                return AVERROR_INVALIDDATA;

                            }

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

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

                        } else {

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

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

                        }

                        run = 3;

                        break;

                    case 30:

                        if (get_bits_left(gb) >= 4) {

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

                            if (index >= FF_ARRAY_ELEMS(type30_dequant)) {

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

                                return AVERROR_INVALIDDATA;

                            }

                            samples[0] = type30_dequant[index];

                        } else

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

                        run = 1;

                        break;

                    case 34:

                        if (get_bits_left(gb) >= 7) {

                            if (type34_first) {

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

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

                                type34_predictor = samples[0];

                                type34_first = 0;

                            } else {

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

                                if (index >= FF_ARRAY_ELEMS(type34_delta)) {

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

                                    return AVERROR_INVALIDDATA;

                                }

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

                                type34_predictor = samples[0];

                            }

                        } else {

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

                        }

                        run = 1;

                        break;

                    default:

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

                        run = 1;

                        break;

                }

                if (joined_stereo) {

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

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

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

                        if (q->nb_channels == 2) {

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

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

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

                            else

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

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

                        }

                    }

                } else {

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

                        if ((j + k) < 128)

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

                }

                j += run;

            } // j loop

        } // channel loop

    } // subband loop

    return 0;

}

/**

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

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

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

 * and for element [0]

 * same VLC tables as process_subpacket_9 are used.

 *

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

 * @param gb        bitreader context

 */

static int init_quantized_coeffs_elem0(int8_t *quantized_coeffs,

                                        GetBitContext *gb)

{

    int i, k, run, level, diff;

    if (get_bits_left(gb) < 16)

        return -1;

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

    quantized_coeffs[0] = level;

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

        if (get_bits_left(gb) < 16)

            return -1;

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

        if (i + run >= 8)

            return -1;

        if (get_bits_left(gb) < 16)

            return -1;

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

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

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

        level += diff;

        i += run;

    }

    return 0;

}

/**

 * Related to synthesis filter, process data from packet 10

 * Init part of quantized_coeffs via function init_quantized_coeffs_elem0

 * Init tone_level_idx_hi1, tone_level_idx_hi2, tone_level_idx_mid with

 * data from packet 10

 *

 * @param q         context

 * @param gb        bitreader context

 */

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

{

    int sb, j, k, n, ch;

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

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

        if (get_bits_left(gb) < 16) {

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

            break;

        }

    }

    n = q->sub_sampling + 1;

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

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

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

                if (get_bits_left(gb) < 1)

                    break;

                if (get_bits1(gb)) {

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

                        if (get_bits_left(gb) < 16)

                            break;

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

                    }

                } else {

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

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

                }

            }

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

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

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

            if (get_bits_left(gb) < 16)

                break;

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

            if (sb > 19)

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

            else

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

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

        }

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

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

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

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

                if (get_bits_left(gb) < 16)

                    break;

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

            }

}