/*** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding** Copyright (C) 2003-2005 M. Bakker, Nero AG, http://www.nero.com**** This program is free software; you can redistribute it and/or modify** it under the terms of the GNU General Public License as published by** the Free Software Foundation; either version 2 of the License, or** (at your option) any later version.**** This program 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 General Public License for more details.**** You should have received a copy of the GNU General Public License** along with this program; if not, write to the Free Software** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.**** Any non-GPL usage of this software or parts of this software is strictly** forbidden.**** The "appropriate copyright message" mentioned in section 2c of the GPLv2** must read: "Code from FAAD2 is copyright (c) Nero AG, www.nero.com"**** Commercial non-GPL licensing of this software is possible.** For more info contact Nero AG through Mpeg4AAClicense@nero.com.**** $Id: specrec.c,v 1.63 2010/06/04 20:47:56 menno Exp $**/ /*  Spectral reconstruction:   - grouping/sectioning   - inverse quantization   - applying scalefactors*/ #include "common.h"#include "structs.h" #ifndef __plan9__#include <stdlib.h>#endif#include "specrec.h"#include "filtbank.h"#include "syntax.h"#include "iq_table.h"#include "ms.h"#include "is.h"#include "pns.h"#include "tns.h"#include "drc.h"#include "lt_predict.h"#include "ic_predict.h"#ifdef SSR_DEC#include "ssr.h"#include "ssr_fb.h"#endif  /* static function declarations */static uint8_t quant_to_spec(NeAACDecStruct *hDecoder,                             ic_stream *ics, int16_t *quant_data,                             real_t *spec_data, uint16_t frame_len);  #ifdef LD_DECALIGN static const uint8_t num_swb_512_window[] ={    0, 0, 0, 36, 36, 37, 31, 31, 0, 0, 0, 0};ALIGN static const uint8_t num_swb_480_window[] ={    0, 0, 0, 35, 35, 37, 30, 30, 0, 0, 0, 0};#endif ALIGN static const uint8_t num_swb_960_window[] ={    40, 40, 45, 49, 49, 49, 46, 46, 42, 42, 42, 40}; ALIGN static const uint8_t num_swb_1024_window[] ={    41, 41, 47, 49, 49, 51, 47, 47, 43, 43, 43, 40}; ALIGN static const uint8_t num_swb_128_window[] ={    12, 12, 12, 14, 14, 14, 15, 15, 15, 15, 15, 15}; ALIGN static const uint16_t swb_offset_1024_96[] ={    0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56,    64, 72, 80, 88, 96, 108, 120, 132, 144, 156, 172, 188, 212, 240,    276, 320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024}; ALIGN static const uint16_t swb_offset_128_96[] ={    0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128}; ALIGN static const uint16_t swb_offset_1024_64[] ={    0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56,    64, 72, 80, 88, 100, 112, 124, 140, 156, 172, 192, 216, 240, 268,    304, 344, 384, 424, 464, 504, 544, 584, 624, 664, 704, 744, 784, 824,    864, 904, 944, 984, 1024}; ALIGN static const uint16_t swb_offset_128_64[] ={    0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128}; ALIGN static const uint16_t swb_offset_1024_48[] ={    0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 48, 56, 64, 72,    80, 88, 96, 108, 120, 132, 144, 160, 176, 196, 216, 240, 264, 292,    320, 352, 384, 416, 448, 480, 512, 544, 576, 608, 640, 672, 704, 736,    768, 800, 832, 864, 896, 928, 1024}; #ifdef LD_DECALIGN static const uint16_t swb_offset_512_48[] ={    0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 68, 76, 84,    92, 100, 112, 124, 136, 148, 164, 184, 208, 236, 268, 300, 332, 364, 396,    428, 460, 512}; ALIGN static const uint16_t swb_offset_480_48[] ={    0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72 ,80 ,88,    96, 108, 120, 132, 144, 156, 172, 188, 212, 240, 272, 304, 336, 368, 400,    432, 480};#endif ALIGN static const uint16_t swb_offset_128_48[] ={    0, 4, 8, 12, 16, 20, 28, 36, 44, 56, 68, 80, 96, 112, 128}; ALIGN static const uint16_t swb_offset_1024_32[] ={    0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 48, 56, 64, 72,    80, 88, 96, 108, 120, 132, 144, 160, 176, 196, 216, 240, 264, 292,    320, 352, 384, 416, 448, 480, 512, 544, 576, 608, 640, 672, 704, 736,    768, 800, 832, 864, 896, 928, 960, 992, 1024}; #ifdef LD_DECALIGN static const uint16_t swb_offset_512_32[] ={    0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72, 80,    88, 96, 108, 120, 132, 144, 160, 176, 192, 212, 236, 260, 288, 320, 352,    384, 416, 448, 480, 512}; ALIGN static const uint16_t swb_offset_480_32[] ={    0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 72, 80,    88, 96, 104, 112, 124, 136, 148, 164, 180, 200, 224, 256, 288, 320, 352,    384, 416, 448, 480};#endif ALIGN static const uint16_t swb_offset_1024_24[] ={    0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 52, 60, 68,    76, 84, 92, 100, 108, 116, 124, 136, 148, 160, 172, 188, 204, 220,    240, 260, 284, 308, 336, 364, 396, 432, 468, 508, 552, 600, 652, 704,    768, 832, 896, 960, 1024}; #ifdef LD_DECALIGN static const uint16_t swb_offset_512_24[] ={    0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 52, 60, 68,    80, 92, 104, 120, 140, 164, 192, 224, 256, 288, 320, 352, 384, 416,    448, 480, 512}; ALIGN static const uint16_t swb_offset_480_24[] ={    0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 52, 60, 68, 80, 92, 104, 120,    140, 164, 192, 224, 256, 288, 320, 352, 384, 416, 448, 480};#endif ALIGN static const uint16_t swb_offset_128_24[] ={    0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 64, 76, 92, 108, 128}; ALIGN static const uint16_t swb_offset_1024_16[] ={    0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 100, 112, 124,    136, 148, 160, 172, 184, 196, 212, 228, 244, 260, 280, 300, 320, 344,    368, 396, 424, 456, 492, 532, 572, 616, 664, 716, 772, 832, 896, 960, 1024}; ALIGN static const uint16_t swb_offset_128_16[] ={    0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 60, 72, 88, 108, 128}; ALIGN static const uint16_t swb_offset_1024_8[] ={    0, 12, 24, 36, 48, 60, 72, 84, 96, 108, 120, 132, 144, 156, 172,    188, 204, 220, 236, 252, 268, 288, 308, 328, 348, 372, 396, 420, 448,    476, 508, 544, 580, 620, 664, 712, 764, 820, 880, 944, 1024}; ALIGN static const uint16_t swb_offset_128_8[] ={    0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 60, 72, 88, 108, 128}; ALIGN static const uint16_t *swb_offset_1024_window[] ={    swb_offset_1024_96,      /* 96000 */    swb_offset_1024_96,      /* 88200 */    swb_offset_1024_64,      /* 64000 */    swb_offset_1024_48,      /* 48000 */    swb_offset_1024_48,      /* 44100 */    swb_offset_1024_32,      /* 32000 */    swb_offset_1024_24,      /* 24000 */    swb_offset_1024_24,      /* 22050 */    swb_offset_1024_16,      /* 16000 */    swb_offset_1024_16,      /* 12000 */    swb_offset_1024_16,      /* 11025 */    swb_offset_1024_8        /* 8000  */}; #ifdef LD_DECALIGN static const uint16_t *swb_offset_512_window[] ={    0,                       /* 96000 */    0,                       /* 88200 */    0,                       /* 64000 */    swb_offset_512_48,       /* 48000 */    swb_offset_512_48,       /* 44100 */    swb_offset_512_32,       /* 32000 */    swb_offset_512_24,       /* 24000 */    swb_offset_512_24,       /* 22050 */    0,                       /* 16000 */    0,                       /* 12000 */    0,                       /* 11025 */    0                        /* 8000  */}; ALIGN static const uint16_t *swb_offset_480_window[] ={    0,                       /* 96000 */    0,                       /* 88200 */    0,                       /* 64000 */    swb_offset_480_48,       /* 48000 */    swb_offset_480_48,       /* 44100 */    swb_offset_480_32,       /* 32000 */    swb_offset_480_24,       /* 24000 */    swb_offset_480_24,       /* 22050 */    0,                       /* 16000 */    0,                       /* 12000 */    0,                       /* 11025 */    0                        /* 8000  */};#endif ALIGN static const  uint16_t *swb_offset_128_window[] ={    swb_offset_128_96,       /* 96000 */    swb_offset_128_96,       /* 88200 */    swb_offset_128_64,       /* 64000 */    swb_offset_128_48,       /* 48000 */    swb_offset_128_48,       /* 44100 */    swb_offset_128_48,       /* 32000 */    swb_offset_128_24,       /* 24000 */    swb_offset_128_24,       /* 22050 */    swb_offset_128_16,       /* 16000 */    swb_offset_128_16,       /* 12000 */    swb_offset_128_16,       /* 11025 */    swb_offset_128_8         /* 8000  */}; #define bit_set(A, B) ((A) & (1<<(B))) /* 4.5.2.3.4 *//*  - determine the number of windows in a window_sequence named num_windows  - determine the number of window_groups named num_window_groups  - determine the number of windows in each group named window_group_length[g]  - determine the total number of scalefactor window bands named num_swb for    the actual window type  - determine swb_offset[swb], the offset of the first coefficient in    scalefactor window band named swb of the window actually used  - determine sect_sfb_offset[g][section],the offset of the first coefficient    in section named section. This offset depends on window_sequence and    scale_factor_grouping and is needed to decode the spectral_data().*/uint8_t window_grouping_info(NeAACDecStruct *hDecoder, ic_stream *ics){    uint8_t i, g;     uint8_t sf_index = hDecoder->sf_index;     if (sf_index >= 12)        return 32;     switch (ics->window_sequence) {    case ONLY_LONG_SEQUENCE:    case LONG_START_SEQUENCE:    case LONG_STOP_SEQUENCE:        ics->num_windows = 1;        ics->num_window_groups = 1;        ics->window_group_length[ics->num_window_groups-1] = 1;#ifdef LD_DEC        if (hDecoder->object_type == LD)        {            if (hDecoder->frameLength == 512)                ics->num_swb = num_swb_512_window[sf_index];            else /* if (hDecoder->frameLength == 480) */                ics->num_swb = num_swb_480_window[sf_index];        } else {#endif            if (hDecoder->frameLength == 1024)                ics->num_swb = num_swb_1024_window[sf_index];            else /* if (hDecoder->frameLength == 960) */                ics->num_swb = num_swb_960_window[sf_index];#ifdef LD_DEC        }#endif         if (ics->max_sfb > ics->num_swb)        {            return 32;        }         /* preparation of sect_sfb_offset for long blocks */        /* also copy the last value! */#ifdef LD_DEC        if (hDecoder->object_type == LD)        {            if (hDecoder->frameLength == 512)            {                for (i = 0; i < ics->num_swb; i++)                {                    ics->sect_sfb_offset[0][i] = swb_offset_512_window[sf_index][i];                    ics->swb_offset[i] = swb_offset_512_window[sf_index][i];                }            } else /* if (hDecoder->frameLength == 480) */ {                for (i = 0; i < ics->num_swb; i++)                {                    ics->sect_sfb_offset[0][i] = swb_offset_480_window[sf_index][i];                    ics->swb_offset[i] = swb_offset_480_window[sf_index][i];                }            }            ics->sect_sfb_offset[0][ics->num_swb] = hDecoder->frameLength;            ics->swb_offset[ics->num_swb] = hDecoder->frameLength;            ics->swb_offset_max = hDecoder->frameLength;        } else {#endif            for (i = 0; i < ics->num_swb; i++)            {                ics->sect_sfb_offset[0][i] = swb_offset_1024_window[sf_index][i];                ics->swb_offset[i] = swb_offset_1024_window[sf_index][i];            }            ics->sect_sfb_offset[0][ics->num_swb] = hDecoder->frameLength;            ics->swb_offset[ics->num_swb] = hDecoder->frameLength;            ics->swb_offset_max = hDecoder->frameLength;#ifdef LD_DEC        }#endif        return 0;    case EIGHT_SHORT_SEQUENCE:        ics->num_windows = 8;        ics->num_window_groups = 1;        ics->window_group_length[ics->num_window_groups-1] = 1;        ics->num_swb = num_swb_128_window[sf_index];         if (ics->max_sfb > ics->num_swb)        {            return 32;        }         for (i = 0; i < ics->num_swb; i++)            ics->swb_offset[i] = swb_offset_128_window[sf_index][i];        ics->swb_offset[ics->num_swb] = hDecoder->frameLength/8;        ics->swb_offset_max = hDecoder->frameLength/8;         for (i = 0; i < ics->num_windows-1; i++) {            if (bit_set(ics->scale_factor_grouping, 6-i) == 0)            {                ics->num_window_groups += 1;                ics->window_group_length[ics->num_window_groups-1] = 1;            } else {                ics->window_group_length[ics->num_window_groups-1] += 1;            }        }         /* preparation of sect_sfb_offset for short blocks */        for (g = 0; g < ics->num_window_groups; g++)        {            uint16_t width;            uint8_t sect_sfb = 0;            uint16_t offset = 0;             for (i = 0; i < ics->num_swb; i++)            {                if (i+1 == ics->num_swb)                {                    width = (hDecoder->frameLength/8) - swb_offset_128_window[sf_index][i];                } else {                    width = swb_offset_128_window[sf_index][i+1] -                        swb_offset_128_window[sf_index][i];                }                width *= ics->window_group_length[g];                ics->sect_sfb_offset[g][sect_sfb++] = offset;                offset += width;            }            ics->sect_sfb_offset[g][sect_sfb] = offset;        }        return 0;    default:        return 32;    }} /* iquant() * output = sign(input)*abs(input)^(4/3) */static INLINE real_t iquant(int16_t q, const real_t *tab, uint8_t *error){#ifdef FIXED_POINT/* For FIXED_POINT the iq_table is prescaled by 3 bits (iq_table[]/8) *//* BIG_IQ_TABLE allows you to use the full 8192 value table, if this is not * defined a 1026 value table and interpolation will be used */#ifndef BIG_IQ_TABLE    static const real_t errcorr[] = {        REAL_CONST(0), REAL_CONST(1.0/8.0), REAL_CONST(2.0/8.0), REAL_CONST(3.0/8.0),        REAL_CONST(4.0/8.0),  REAL_CONST(5.0/8.0), REAL_CONST(6.0/8.0), REAL_CONST(7.0/8.0),        REAL_CONST(0)    };    real_t x1, x2;#endif    int16_t sgn = 1;     if (q < 0)    {        q = -q;        sgn = -1;    }     if (q < IQ_TABLE_SIZE)    {//#define IQUANT_PRINT#ifdef IQUANT_PRINT        //printf("0x%.8X\n", sgn * tab[q]);        printf("%d\n", sgn * tab[q]);#endif        return sgn * tab[q];    } #ifndef BIG_IQ_TABLE    if (q >= 8192)    {        *error = 17;        return 0;    }     /* linear interpolation */    x1 = tab[q>>3];    x2 = tab[(q>>3) + 1];    return sgn * 16 * (MUL_R(errcorr[q&7],(x2-x1)) + x1);#else    *error = 17;    return 0;#endif #else    if (q < 0)    {        /* tab contains a value for all possible q [0,8192] */        if (-q < IQ_TABLE_SIZE)            return -tab[-q];         *error = 17;        return 0;    } else {        /* tab contains a value for all possible q [0,8192] */        if (q < IQ_TABLE_SIZE)            return tab[q];         *error = 17;        return 0;    }#endif}

Lines 1–500 of 1367. Load more