开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
specrec.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：45k
源码类别：

Windows CE

开发平台：

C/C++

specrec.c：源码内容
  1. /* ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding ** Copyright (C) 2003-2004 M. Bakker, Ahead Software 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. ** ** Commercial non-GPL licensing of this software is possible. ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com. ** ** $Id: specrec.c,v 1.56 2004/09/08 09:43:11 gcp Exp $ **/ /*   Spectral reconstruction:    - grouping/sectioning    - inverse quantization    - applying scalefactors */ #include "common.h" #include "structs.h" #include <string.h> #include <stdlib.h> #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(NeAACDecHandle hDecoder,                              ic_stream *ics, int16_t *quant_data,                              uint16_t frame_len); #ifdef LD_DEC ALIGN 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_DEC ALIGN 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_DEC ALIGN 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_DEC ALIGN 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 *const 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_DEC ALIGN static const uint16_t *const 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 *const 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 *const 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(NeAACDecHandle hDecoder, ic_stream *ics) {     uint8_t i;
  2. ic_group *g;     uint8_t sf_index = hDecoder->sf_index;     switch (ics->window_sequence) {     case ONLY_LONG_SEQUENCE:     case LONG_START_SEQUENCE:     case LONG_STOP_SEQUENCE:         ics->num_windows = 1;         ics->group_end = ics->group+1;         ics->group[0].window_group_length = 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         /* 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;         } else { #endif             for (i = 0; i < ics->num_swb; i++)             {                 ics->group[0].sfb[i].sect_sfb_offset = swb_offset_1024_window[sf_index][i];                 ics->swb_offset[i] = swb_offset_1024_window[sf_index][i];             }             ics->group[0].sfb[ics->num_swb].sect_sfb_offset = hDecoder->frameLength;             ics->swb_offset[ics->num_swb] = hDecoder->frameLength; #ifdef LD_DEC         } #endif         return 0;     case EIGHT_SHORT_SEQUENCE:         ics->num_windows = 8;         ics->group_end = ics->group+1;
  3.         ics->group[0].window_group_length = 1;         ics->num_swb = num_swb_128_window[sf_index];         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;         for (i = 0; i < ics->num_windows-1; i++) {             if (bit_set(ics->scale_factor_grouping, 6-i) == 0)             {                 ics->group_end->window_group_length = 1;                 ++ics->group_end;
  4.             } else {                 ics->group_end[-1].window_group_length += 1;             }         }         /* preparation of sect_sfb_offset for short blocks */         for (g = ics->group; g != ics->group_end; 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 *= g->window_group_length;                 g->sfb[sect_sfb++].sect_sfb_offset = offset;                 offset += width;             }             g->sfb[sect_sfb].sect_sfb_offset = offset;         }         return 0;     default:         return 1;     } } /* 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%.8Xn", sgn * tab[q]);         printf("%dn", 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 } #ifndef FIXED_POINT ALIGN static const real_t pow2sf_tab[] = {     2.9802322387695313E-008, 5.9604644775390625E-008, 1.1920928955078125E-007,     2.384185791015625E-007, 4.76837158203125E-007, 9.5367431640625E-007,     1.9073486328125E-006, 3.814697265625E-006, 7.62939453125E-006,     1.52587890625E-005, 3.0517578125E-005, 6.103515625E-005,     0.0001220703125, 0.000244140625, 0.00048828125,     0.0009765625, 0.001953125, 0.00390625,     0.0078125, 0.015625, 0.03125,     0.0625, 0.125, 0.25,     0.5, 1.0, 2.0,     4.0, 8.0, 16.0, 32.0,     64.0, 128.0, 256.0,     512.0, 1024.0, 2048.0,     4096.0, 8192.0, 16384.0,     32768.0, 65536.0, 131072.0,     262144.0, 524288.0, 1048576.0,     2097152.0, 4194304.0, 8388608.0,     16777216.0, 33554432.0, 67108864.0,     134217728.0, 268435456.0, 536870912.0,     1073741824.0, 2147483648.0, 4294967296.0,     8589934592.0, 17179869184.0, 34359738368.0,     68719476736.0, 137438953472.0, 274877906944.0 }; #endif /* quant_to_spec: perform dequantisation and scaling  * and in case of short block it also does the deinterleaving  */ /*   For ONLY_LONG_SEQUENCE windows (num_window_groups = 1,   window_group_length[0] = 1) the spectral data is in ascending spectral   order.   For the EIGHT_SHORT_SEQUENCE window, the spectral order depends on the   grouping in the following manner:   - Groups are ordered sequentially   - Within a group, a scalefactor band consists of the spectral data of all     grouped SHORT_WINDOWs for the associated scalefactor window band. To     clarify via example, the length of a group is in the range of one to eight     SHORT_WINDOWs.   - If there are eight groups each with length one (num_window_groups = 8,     window_group_length[0..7] = 1), the result is a sequence of eight spectra,     each in ascending spectral order.   - If there is only one group with length eight (num_window_groups = 1,     window_group_length[0] = 8), the result is that spectral data of all eight     SHORT_WINDOWs is interleaved by scalefactor window bands.   - Within a scalefactor window band, the coefficients are in ascending     spectral order. */ static uint8_t quant_to_spec(NeAACDecHandle hDecoder,                              ic_stream *ics, int16_t *quant_data,                              uint16_t frame_len) {     ALIGN static const real_t pow2_table[] =     {         COEF_CONST(1.0),         COEF_CONST(1.1892071150027210667174999705605), /* 2^0.25 */         COEF_CONST(1.4142135623730950488016887242097), /* 2^0.5 */         COEF_CONST(1.6817928305074290860622509524664) /* 2^0.75 */     };     const real_t *tab = iq_table;
  5. real_t *spec_data = ics->buffer;     uint8_t sfb, win;     uint16_t width, bin, k, gindex, wa, wb;     uint8_t error = 0; /* Init error flag */ #ifndef FIXED_POINT     real_t scf; #endif
  6. ic_group *g;     k = 0;     gindex = 0;     for (g = ics->group; g != ics->group_end; g++)     {         uint16_t j = 0;         uint16_t gincrease = 0;         uint16_t win_inc = ics->swb_offset[ics->num_swb];         for (sfb = 0; sfb < ics->num_swb; sfb++)         {             int32_t exp, frac;             width = ics->swb_offset[sfb+1] - ics->swb_offset[sfb];             /* this could be scalefactor for IS or PNS, those can be negative or bigger then 255 */             /* just ignore them */             if (g->sfb[sfb].scale_factors < 0 || g->sfb[sfb].scale_factors > 255)             {                 exp = 0;                 frac = 0;             } else {                 /* ics->scale_factors[g][sfb] must be between 0 and 255 */                 exp = (g->sfb[sfb].scale_factors /* - 100 */) >> 2;                 /* frac must always be > 0 */                 frac = (g->sfb[sfb].scale_factors /* - 100 */) & 3;             } #ifdef FIXED_POINT             exp -= 25;             /* IMDCT pre-scaling */             if (hDecoder->object_type == LD)             {                 exp -= 6 /*9*/;             } else {                 if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)                     exp -= 4 /*7*/;                 else                     exp -= 7 /*10*/;             } #endif             wa = gindex + j; #ifndef FIXED_POINT             scf = pow2sf_tab[exp/*+25*/] * pow2_table[frac]; #endif             for (win = 0; win < g->window_group_length; win++)             {                 for (bin = 0; bin < width; bin += 4)                 { #ifndef FIXED_POINT                     wb = wa + bin;                     spec_data[wb+0] = iquant(quant_data[k+0], tab, &error) * scf;                     spec_data[wb+1] = iquant(quant_data[k+1], tab, &error) * scf;                                             spec_data[wb+2] = iquant(quant_data[k+2], tab, &error) * scf;                                             spec_data[wb+3] = iquant(quant_data[k+3], tab, &error) * scf;                          #else                     real_t iq0 = iquant(quant_data[k+0], tab, &error);                     real_t iq1 = iquant(quant_data[k+1], tab, &error);                     real_t iq2 = iquant(quant_data[k+2], tab, &error);                     real_t iq3 = iquant(quant_data[k+3], tab, &error);                     wb = wa + bin;                     if (exp < 0)                     {                         spec_data[wb+0] = iq0 >>= -exp;                         spec_data[wb+1] = iq1 >>= -exp;                         spec_data[wb+2] = iq2 >>= -exp;                         spec_data[wb+3] = iq3 >>= -exp;                     } else {                         spec_data[wb+0] = iq0 <<= exp;                         spec_data[wb+1] = iq1 <<= exp;                         spec_data[wb+2] = iq2 <<= exp;                         spec_data[wb+3] = iq3 <<= exp;                     }                     if (frac != 0)                     {                         spec_data[wb+0] = MUL_C(spec_data[wb+0],pow2_table[frac]);                         spec_data[wb+1] = MUL_C(spec_data[wb+1],pow2_table[frac]);                         spec_data[wb+2] = MUL_C(spec_data[wb+2],pow2_table[frac]);                         spec_data[wb+3] = MUL_C(spec_data[wb+3],pow2_table[frac]);                     } //#define SCFS_PRINT #ifdef SCFS_PRINT                     printf("%dn", spec_data[gindex+(win*win_inc)+j+bin+0]);                     printf("%dn", spec_data[gindex+(win*win_inc)+j+bin+1]);                     printf("%dn", spec_data[gindex+(win*win_inc)+j+bin+2]);                     printf("%dn", spec_data[gindex+(win*win_inc)+j+bin+3]);                     //printf("0x%.8Xn", spec_data[gindex+(win*win_inc)+j+bin+0]);                     //printf("0x%.8Xn", spec_data[gindex+(win*win_inc)+j+bin+1]);                     //printf("0x%.8Xn", spec_data[gindex+(win*win_inc)+j+bin+2]);                     //printf("0x%.8Xn", spec_data[gindex+(win*win_inc)+j+bin+3]); #endif #endif                     k += 4;                 }
  7.                 wa += win_inc;             }             j += width;
  9. gincrease += width * g->window_group_length;         }         gindex += gincrease;     }     return error; }
  10. static uint8_t allocate_single_channel(NeAACDecHandle hDecoder, uint8_t channel,
  11.                                        uint8_t output_channels)
  12. {
  13.     uint8_t mul = 1;
  15. #ifdef MAIN_DEC
  16.     /* MAIN object type prediction */
  17.     if (hDecoder->object_type == MAIN)
  18.     {
  19.         /* allocate the state only when needed */
  20.         if (hDecoder->pred_stat[channel] == NULL)
  21.         {
  22.             hDecoder->pred_stat[channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
  23.             reset_all_predictors(hDecoder->pred_stat[channel], hDecoder->frameLength);
  24.         }
  25.     }
  26. #endif
  28. #ifdef LTP_DEC
  29.     if (is_ltp_ot(hDecoder->object_type))
  30.     {
  31.         /* allocate the state only when needed */
  32.         if (hDecoder->lt_pred_stat[channel] == NULL)
  33.         {
  34.             hDecoder->lt_pred_stat[channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
  35.             memset(hDecoder->lt_pred_stat[channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
  36.         }
  37.     }
  38. #endif
  40.     if (hDecoder->time_out[channel] != NULL)
  41.     {
  42.         faad_free(hDecoder->time_out[channel]);
  43.         hDecoder->time_out[channel] = NULL;
  44.     }
  46.     {
  47.         mul = 1;
  48. #ifdef SBR_DEC
  49.         hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 0;
  50.         if ((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
  51.         {
  52.             /* SBR requires 2 times as much output data */
  53.             mul = 2;
  54.             hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 1;
  55.         }
  56. #endif
  57.         hDecoder->time_out[channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
  58. if (!hDecoder->time_out[channel])
  59. return 28;
  60.         memset(hDecoder->time_out[channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
  61.     }
  62. #if (defined(PS_DEC) || defined(DRM_PS))
  63.     if (output_channels == 2)
  64.     {
  65.         if (hDecoder->time_out[channel+1] != NULL)
  66.         {
  67.             faad_free(hDecoder->time_out[channel+1]);
  68.             hDecoder->time_out[channel+1] = NULL;
  69.         }
  71.         hDecoder->time_out[channel+1] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
  72. if (!hDecoder->time_out[channel+1])
  73. return 28;
  74.         memset(hDecoder->time_out[channel+1], 0, mul*hDecoder->frameLength*sizeof(real_t));
  75.     }
  76. #endif
  78.     if (hDecoder->fb_intermed[channel] != NULL)
  79.     {
  80.         faad_free(hDecoder->fb_intermed[channel]);
  81.         hDecoder->fb_intermed[channel] = NULL;
  82.     }
  84.     hDecoder->fb_intermed[channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
  85. if (!hDecoder->fb_intermed[channel])
  86. return 28;
  87.     memset(hDecoder->fb_intermed[channel], 0, hDecoder->frameLength*sizeof(real_t));
  90. #ifdef SSR_DEC
  91.     if (hDecoder->object_type == SSR)
  92.     {
  93.         if (hDecoder->ssr_overlap[channel] == NULL)
  94.         {
  95.             hDecoder->ssr_overlap[channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
  96.             memset(hDecoder->ssr_overlap[channel], 0, 2*hDecoder->frameLength*sizeof(real_t));
  97.         }
  98.         if (hDecoder->prev_fmd[channel] == NULL)
  99.         {
  100.             uint16_t k;
  101.             hDecoder->prev_fmd[channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
  102.             for (k = 0; k < 2*hDecoder->frameLength; k++)
  103.                 hDecoder->prev_fmd[channel][k] = REAL_CONST(-1);
  104.         }
  105.     }
  106. #endif
  108.     return 0;
  109. }
  111. static uint8_t allocate_channel_pair(NeAACDecHandle hDecoder,
  112.                                      uint8_t channel, uint8_t paired_channel)
  113. {
  114.     uint8_t mul = 1;
  116. #ifdef MAIN_DEC
  117.     /* MAIN object type prediction */
  118.     if (hDecoder->object_type == MAIN)
  119.     {
  120.         /* allocate the state only when needed */
  121.         if (hDecoder->pred_stat[channel] == NULL)
  122.         {
  123.             hDecoder->pred_stat[channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
  124.             reset_all_predictors(hDecoder->pred_stat[channel], hDecoder->frameLength);
  125.         }
  126.         if (hDecoder->pred_stat[paired_channel] == NULL)
  127.         {
  128.             hDecoder->pred_stat[paired_channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
  129.             reset_all_predictors(hDecoder->pred_stat[paired_channel], hDecoder->frameLength);
  130.         }
  131.     }
  132. #endif
  134. #ifdef LTP_DEC
  135.     if (is_ltp_ot(hDecoder->object_type))
  136.     {
  137.         /* allocate the state only when needed */
  138.         if (hDecoder->lt_pred_stat[channel] == NULL)
  139.         {
  140.             hDecoder->lt_pred_stat[channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
  141.             memset(hDecoder->lt_pred_stat[channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
  142.         }
  143.         if (hDecoder->lt_pred_stat[paired_channel] == NULL)
  144.         {
  145.             hDecoder->lt_pred_stat[paired_channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
  146.             memset(hDecoder->lt_pred_stat[paired_channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
  147.         }
  148.     }
  149. #endif
  151.     if (hDecoder->time_out[channel] == NULL)
  152.     {
  153.         mul = 1;
  154. #ifdef SBR_DEC
  155.         hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 0;
  156.         if ((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
  157.         {
  158.             /* SBR requires 2 times as much output data */
  159.             mul = 2;
  160.             hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 1;
  161.         }
  162. #endif
  163.         hDecoder->time_out[channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
  164. if (!hDecoder->time_out[channel])
  165. return 28;
  166.         memset(hDecoder->time_out[channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
  167.     }
  168.     if (hDecoder->time_out[paired_channel] == NULL)
  169.     {
  170.         hDecoder->time_out[paired_channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
  171. if (!hDecoder->time_out[paired_channel])
  172. return 28;
  173.         memset(hDecoder->time_out[paired_channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
  174.     }
  176.     if (hDecoder->fb_intermed[channel] == NULL)
  177.     {
  178.         hDecoder->fb_intermed[channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
  179. if (!hDecoder->fb_intermed[channel])
  180. return 28;
  181.         memset(hDecoder->fb_intermed[channel], 0, hDecoder->frameLength*sizeof(real_t));
  182.     }
  183.     if (hDecoder->fb_intermed[paired_channel] == NULL)
  184.     {
  185.         hDecoder->fb_intermed[paired_channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
  186. if (!hDecoder->fb_intermed[paired_channel])
  187. return 28;
  188.         memset(hDecoder->fb_intermed[paired_channel], 0, hDecoder->frameLength*sizeof(real_t));
  189.     }
  191. #ifdef SSR_DEC
  192.     if (hDecoder->object_type == SSR)
  193.     {
  194.         if (hDecoder->ssr_overlap[cpe->channel] == NULL)
  195.         {
  196.             hDecoder->ssr_overlap[cpe->channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
  197.             memset(hDecoder->ssr_overlap[cpe->channel], 0, 2*hDecoder->frameLength*sizeof(real_t));
  198.         }
  199.         if (hDecoder->ssr_overlap[cpe->paired_channel] == NULL)
  200.         {
  201.             hDecoder->ssr_overlap[cpe->paired_channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
  202.             memset(hDecoder->ssr_overlap[cpe->paired_channel], 0, 2*hDecoder->frameLength*sizeof(real_t));
  203.         }
  204.         if (hDecoder->prev_fmd[cpe->channel] == NULL)
  205.         {
  206.             uint16_t k;
  207.             hDecoder->prev_fmd[cpe->channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
  208.             for (k = 0; k < 2*hDecoder->frameLength; k++)
  209.                 hDecoder->prev_fmd[cpe->channel][k] = REAL_CONST(-1);
  210.         }
  211.         if (hDecoder->prev_fmd[cpe->paired_channel] == NULL)
  212.         {
  213.             uint16_t k;
  214.             hDecoder->prev_fmd[cpe->paired_channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
  215.             for (k = 0; k < 2*hDecoder->frameLength; k++)
  216.                 hDecoder->prev_fmd[cpe->paired_channel][k] = REAL_CONST(-1);
  217.         }
  218.     }
  219. #endif
  221.     return 0;
  222. }
  224. extern uint8_t safestack(uint8_t (*)(NeAACDecHandle hDecoder, ic_stream *ics),NeAACDecHandle hDecoder, ic_stream *ics,void**);
  226. uint8_t sbrDecode(NeAACDecHandle hDecoder, ic_stream *ics)
  227. {
  228. uint8_t channel = hDecoder->channel;
  229. uint8_t retval;
  230.         uint8_t ele = hDecoder->fr_ch_ele;
  232.         /* following case can happen when forceUpSampling == 1 */
  233.         if (hDecoder->sbr[ele] == NULL)
  234.         {
  235.             hDecoder->sbr[ele] = sbrDecodeInit(hDecoder->frameLength,
  236.                 hDecoder->element_id[ele], 2*get_sample_rate(hDecoder->sf_index),
  237.                 hDecoder->downSampledSBR
  238. #ifdef DRM
  239.                 , 0
  240. #endif
  241.                 );
  242.         }
  244.         if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
  245.             hDecoder->sbr[ele]->maxAACLine = 8*ics->swb_offset[max(ics->max_sfb-1, 0)];
  246.         else
  247.             hDecoder->sbr[ele]->maxAACLine = ics->swb_offset[max(ics->max_sfb-1, 0)];
  249.         /* check if any of the PS tools is used */
  250. #if (defined(PS_DEC) || defined(DRM_PS))
  251.         if (hDecoder->ps_used[ele] == 0)
  252.         {
  253. #endif
  254.             retval = sbrDecodeSingleFrame(hDecoder->sbr[ele], hDecoder->time_out[channel],
  255.                 hDecoder->postSeekResetFlag, hDecoder->downSampledSBR);
  256. #if (defined(PS_DEC) || defined(DRM_PS))
  257.         } else {
  258.             retval = sbrDecodeSingleFramePS(hDecoder->sbr[ele], hDecoder->time_out[channel],
  259.                 hDecoder->time_out[channel+1], hDecoder->postSeekResetFlag,
  260.                 hDecoder->downSampledSBR);
  261.         }
  262. #endif
  263. return retval;
  264. }
  266. uint8_t sbrDecodeCouple(NeAACDecHandle hDecoder, ic_stream *ics1)
  267. {
  268. uint8_t paired_channel = hDecoder->paired_channel;
  269. uint8_t channel = hDecoder->channel;
  270. uint8_t retval;
  271.         uint8_t ele = hDecoder->fr_ch_ele;
  273.         /* following case can happen when forceUpSampling == 1 */
  274.         if (hDecoder->sbr[ele] == NULL)
  275.         {
  276.             hDecoder->sbr[ele] = sbrDecodeInit(hDecoder->frameLength,
  277.                 hDecoder->element_id[ele], 2*get_sample_rate(hDecoder->sf_index),
  278.                 hDecoder->downSampledSBR
  279. #ifdef DRM
  280.                 , 0
  281. #endif
  282.                 );
  283.         }
  285.         if (ics1->window_sequence == EIGHT_SHORT_SEQUENCE)
  286.             hDecoder->sbr[ele]->maxAACLine = 8*ics1->swb_offset[max(ics1->max_sfb-1, 0)];
  287.         else
  288.             hDecoder->sbr[ele]->maxAACLine = ics1->swb_offset[max(ics1->max_sfb-1, 0)];
  290.         retval = sbrDecodeCoupleFrame(hDecoder->sbr[ele],
  291.             hDecoder->time_out[channel], hDecoder->time_out[paired_channel],
  292.             hDecoder->postSeekResetFlag, hDecoder->downSampledSBR);
  294. return retval;
  295. }
  297. uint8_t reconstruct_single_channel(NeAACDecHandle hDecoder, ic_stream *ics) {     uint8_t retval; uint8_t channel = hDecoder->channel;
  298.     uint8_t output_channels;
  299. #ifdef PROFILE     int64_t count = faad_get_ts(); #endif
  300.     /* always allocate 2 channels, PS can always "suddenly" turn up */
  301. #if ( (defined(DRM) && defined(DRM_PS)) )
  302.     output_channels = 2;
  303. #elif defined(PS_DEC)
  304.     if (hDecoder->ps_used[hDecoder->fr_ch_ele])
  305.         output_channels = 2;
  306.     else
  307.         output_channels = 1;
  308. #endif
  310.     if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 0)
  311.     {
  312.         /* element_output_channels not set yet */
  313.         hDecoder->element_output_channels[hDecoder->fr_ch_ele] = output_channels;
  314.     } else if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] != output_channels) {
  315.         /* element inconsistency */
  317.         /* this only happens if PS is actually found but not in the first frame
  318.          * this means that there is only 1 bitstream element!
  319.          */
  321.         /* reset the allocation */
  322.         hDecoder->element_alloced[hDecoder->fr_ch_ele] = 0;
  324.         hDecoder->element_output_channels[hDecoder->fr_ch_ele] = output_channels;
  326.         //return 21;
  327.     }
  329.     if (hDecoder->element_alloced[hDecoder->fr_ch_ele] == 0)
  330.     {
  331.         retval = allocate_single_channel(hDecoder, channel, output_channels);
  332.         if (retval > 0)
  333.             return retval;
  335.         hDecoder->element_alloced[hDecoder->fr_ch_ele] = 1;
  336.     }
  338. ics->buffer = hDecoder->time_out[channel];
  339.     /* dequantisation and scaling */     retval = quant_to_spec(hDecoder, ics, hDecoder->d.spec_data[0], hDecoder->frameLength);     if (retval > 0)         return retval; #ifdef PROFILE     count = faad_get_ts() - count;     hDecoder->requant_cycles += count; #endif     /* pns decoding */     pns_decode(ics, NULL, hDecoder->frameLength, 0, hDecoder->object_type); #ifdef MAIN_DEC     /* MAIN object type prediction */     if (hDecoder->object_type == MAIN)     {         /* intra channel prediction */         ic_prediction(ics, hDecoder->pred_stat[channel], hDecoder->frameLength,             hDecoder->sf_index);         /* In addition, for scalefactor bands coded by perceptual            noise substitution the predictors belonging to the            corresponding spectral coefficients are reset.         */         pns_reset_pred_state(ics, hDecoder->pred_stat[channel]);     } #endif #ifdef LTP_DEC     if (is_ltp_ot(hDecoder->object_type))     { #ifdef LD_DEC         if (hDecoder->object_type == LD)         {             if (ics->ltp.data_present)             {                 if (ics->ltp.lag_update)                     hDecoder->ltp_lag[channel] = ics->ltp.lag;             }             ics->ltp.lag = hDecoder->ltp_lag[channel];         } #endif         /* long term prediction */         lt_prediction(ics, &(ics->ltp), hDecoder->lt_pred_stat[channel], hDecoder->fb,             ics->window_shape, hDecoder->window_shape_prev[channel],             hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);     } #endif     /* tns decoding */     tns_decode_frame(ics, &(ics->tns), hDecoder->sf_index, hDecoder->object_type,         hDecoder->frameLength);     /* drc decoding */     if (hDecoder->drc->present)     {         if (!hDecoder->drc->exclude_mask[channel] || !hDecoder->drc->excluded_chns_present)             drc_decode(hDecoder->drc, ics->buffer);     }     /* filter bank */ #ifdef SSR_DEC     if (hDecoder->object_type != SSR)     { #endif
  340. #ifdef LIBPAAC
  341.         hDecoder->Lib.Filter(&hDecoder->Lib, ics->window_sequence, ics->window_shape,
  342.             hDecoder->window_shape_prev[channel], 
  343.             hDecoder->time_out[channel], hDecoder->fb_intermed[channel], hDecoder->d.buffer);
  344. #else         ifilter_bank(hDecoder->fb, ics->window_sequence, ics->window_shape,             hDecoder->window_shape_prev[channel], ics->buffer,             hDecoder->time_out[channel], hDecoder->fb_intermed[channel], hDecoder->d.buffer,             hDecoder->object_type, hDecoder->frameLength);
  345. #endif #ifdef SSR_DEC     } else {         ssr_decode(&(ics->ssr), hDecoder->fb, ics->window_sequence, ics->window_shape,             hDecoder->window_shape_prev[channel], ics->buffer, hDecoder->time_out[channel],             hDecoder->ssr_overlap[channel], hDecoder->ipqf_buffer[channel], hDecoder->prev_fmd[channel],             hDecoder->frameLength);     } #endif     /* save window shape for next frame */     hDecoder->window_shape_prev[channel] = ics->window_shape; #ifdef LTP_DEC     if (is_ltp_ot(hDecoder->object_type))     {         lt_update_state(hDecoder->lt_pred_stat[channel], hDecoder->time_out[channel],             hDecoder->fb_intermed[channel], hDecoder->frameLength, hDecoder->object_type);     } #endif #ifdef SBR_DEC     if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))         && hDecoder->sbr_alloced[hDecoder->fr_ch_ele])     {
  346. retval = safestack(sbrDecode,hDecoder,ics,&hDecoder->stack);
  347.         if (retval > 0)             return retval;     } else if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))         && !hDecoder->sbr_alloced[hDecoder->fr_ch_ele])     {         return 23;     } #endif     /* copy L to R when no PS is used */
  348. #if (defined(PS_DEC) || defined(DRM_PS))
  349.     if ((hDecoder->ps_used[hDecoder->fr_ch_ele] == 0) &&
  350.         (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 2))
  351.     {
  352.         uint8_t ele = hDecoder->fr_ch_ele;
  353.         uint16_t frame_size = (hDecoder->sbr_alloced[ele]) ? 2 : 1;
  354.         frame_size *= hDecoder->frameLength*sizeof(real_t);
  356.         memcpy(hDecoder->time_out[channel+1], hDecoder->time_out[channel], frame_size);
  357.     }
  358. #endif
  359.     return 0; } uint8_t reconstruct_channel_pair(NeAACDecHandle hDecoder, ic_stream *ics1, ic_stream *ics2) {     uint8_t retval;
  360. uint8_t channel = hDecoder->channel;
  361. uint8_t paired_channel = hDecoder->paired_channel; #ifdef PROFILE     int64_t count = faad_get_ts(); #endif
  362.     if (hDecoder->element_alloced[hDecoder->fr_ch_ele] == 0)
  363.     {
  364.         retval = allocate_channel_pair(hDecoder, channel, paired_channel);
  365.         if (retval > 0)
  366.             return retval;
  368.         hDecoder->element_alloced[hDecoder->fr_ch_ele] = 1;
  369.     }
  371. ics1->buffer = hDecoder->time_out[channel];
  372. ics2->buffer = hDecoder->time_out[paired_channel];
  373.     /* dequantisation and scaling */     retval = quant_to_spec(hDecoder, ics1, hDecoder->d.spec_data[0], hDecoder->frameLength);     if (retval > 0)         return retval;     retval = quant_to_spec(hDecoder, ics2, hDecoder->d.spec_data[1], hDecoder->frameLength);     if (retval > 0)         return retval; #ifdef PROFILE     count = faad_get_ts() - count;     hDecoder->requant_cycles += count; #endif     /* pns decoding */     if (ics1->ms_mask_present)     {         pns_decode(ics1, ics2, hDecoder->frameLength, 1, hDecoder->object_type);     } else {         pns_decode(ics1, NULL, hDecoder->frameLength, 0, hDecoder->object_type);         pns_decode(ics2, NULL, hDecoder->frameLength, 0, hDecoder->object_type);     }     /* mid/side decoding */     ms_decode(ics1, ics2, hDecoder->frameLength); #if 0     {         int i;         for (i = 0; i < 1024; i++)         {             //printf("%dn", ics1->buffer[i]);             printf("0x%.8Xn", ics1->buffer[i]);         }         for (i = 0; i < 1024; i++)         {             //printf("%dn", ics2->buffer[i]);             printf("0x%.8Xn", ics2->buffer[i]);         }     } #endif     /* intensity stereo decoding */     is_decode(ics1, ics2, hDecoder->frameLength); #if 0     {         int i;         for (i = 0; i < 1024; i++)         {             printf("%dn", ics1->buffer[i]);             //printf("0x%.8Xn", ics1->buffer[i]);         }         for (i = 0; i < 1024; i++)         {             printf("%dn", ics2->buffer[i]);             //printf("0x%.8Xn", ics2->buffer[i]);         }     } #endif #ifdef MAIN_DEC     /* MAIN object type prediction */     if (hDecoder->object_type == MAIN)     {         /* intra channel prediction */         ic_prediction(ics1, hDecoder->pred_stat[channel], hDecoder->frameLength,             hDecoder->sf_index);         ic_prediction(ics2, hDecoder->pred_stat[paired_channel], hDecoder->frameLength,             hDecoder->sf_index);         /* In addition, for scalefactor bands coded by perceptual            noise substitution the predictors belonging to the            corresponding spectral coefficients are reset.         */         pns_reset_pred_state(ics1, hDecoder->pred_stat[channel]);         pns_reset_pred_state(ics2, hDecoder->pred_stat[paired_channel]);     } #endif #ifdef LTP_DEC     if (is_ltp_ot(hDecoder->object_type))     {         ltp_info *ltp1 = &(ics1->ltp);         ltp_info *ltp2 = (hDecoder->common_window) ? &(ics2->ltp2) : &(ics2->ltp); #ifdef LD_DEC         if (hDecoder->object_type == LD)         {             if (ltp1->data_present)             {                 if (ltp1->lag_update)                     hDecoder->ltp_lag[channel] = ltp1->lag;             }             ltp1->lag = hDecoder->ltp_lag[channel];             if (ltp2->data_present)             {                 if (ltp2->lag_update)                     hDecoder->ltp_lag[paired_channel] = ltp2->lag;             }             ltp2->lag = hDecoder->ltp_lag[paired_channel];         } #endif         /* long term prediction */         lt_prediction(ics1, ltp1, hDecoder->lt_pred_stat[channel], hDecoder->fb,             ics1->window_shape, hDecoder->window_shape_prev[channel],             hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);         lt_prediction(ics2, ltp2, hDecoder->lt_pred_stat[paired_channel], hDecoder->fb,             ics2->window_shape, hDecoder->window_shape_prev[paired_channel],             hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);     } #endif     /* tns decoding */     tns_decode_frame(ics1, &(ics1->tns), hDecoder->sf_index, hDecoder->object_type,         hDecoder->frameLength);     tns_decode_frame(ics2, &(ics2->tns), hDecoder->sf_index, hDecoder->object_type,         hDecoder->frameLength);     /* drc decoding */     if (hDecoder->drc->present)     {         if (!hDecoder->drc->exclude_mask[channel] || !hDecoder->drc->excluded_chns_present)             drc_decode(hDecoder->drc, ics1->buffer);         if (!hDecoder->drc->exclude_mask[paired_channel] || !hDecoder->drc->excluded_chns_present)             drc_decode(hDecoder->drc, ics1->buffer);     }     /* filter bank */ #ifdef SSR_DEC     if (hDecoder->object_type != SSR)     { #endif #ifdef LIBPAAC
  374.         hDecoder->Lib.Filter(&hDecoder->Lib, ics1->window_sequence, ics1->window_shape,
  375.             hDecoder->window_shape_prev[channel],
  376.             hDecoder->time_out[channel], hDecoder->fb_intermed[channel], hDecoder->d.buffer);
  377.         hDecoder->Lib.Filter(&hDecoder->Lib, ics2->window_sequence, ics2->window_shape,
  378.             hDecoder->window_shape_prev[paired_channel], 
  379.             hDecoder->time_out[paired_channel], hDecoder->fb_intermed[paired_channel], hDecoder->d.buffer);
  380. #else
  381.         ifilter_bank(hDecoder->fb, ics1->window_sequence, ics1->window_shape,             hDecoder->window_shape_prev[channel], ics1->buffer,             hDecoder->time_out[channel], hDecoder->fb_intermed[channel], hDecoder->d.buffer,             hDecoder->object_type, hDecoder->frameLength);         ifilter_bank(hDecoder->fb, ics2->window_sequence, ics2->window_shape,             hDecoder->window_shape_prev[paired_channel], ics2->buffer,             hDecoder->time_out[paired_channel], hDecoder->fb_intermed[paired_channel], hDecoder->d.buffer,             hDecoder->object_type, hDecoder->frameLength);
  382. #endif #ifdef SSR_DEC     } else {
  383.         ssr_decode(&(ics1->ssr), hDecoder->fb, ics1->window_sequence, ics1->window_shape,             hDecoder->window_shape_prev[channel], ics1->buffer, hDecoder->time_out[channel],             hDecoder->ssr_overlap[channel], hDecoder->ipqf_buffer[channel],             hDecoder->prev_fmd[channel], hDecoder->frameLength);         ssr_decode(&(ics2->ssr), hDecoder->fb, ics2->window_sequence, ics2->window_shape,             hDecoder->window_shape_prev[paired_channel], ics2->buffer, hDecoder->time_out[paired_channel],             hDecoder->ssr_overlap[paired_channel], hDecoder->ipqf_buffer[paired_channel],             hDecoder->prev_fmd[paired_channel], hDecoder->frameLength);     } #endif     /* save window shape for next frame */     hDecoder->window_shape_prev[channel] = ics1->window_shape;     hDecoder->window_shape_prev[paired_channel] = ics2->window_shape; #ifdef LTP_DEC     if (is_ltp_ot(hDecoder->object_type))     {         lt_update_state(hDecoder->lt_pred_stat[channel], hDecoder->time_out[channel],             hDecoder->fb_intermed[channel], hDecoder->frameLength, hDecoder->object_type);         lt_update_state(hDecoder->lt_pred_stat[paired_channel], hDecoder->time_out[paired_channel],             hDecoder->fb_intermed[paired_channel], hDecoder->frameLength, hDecoder->object_type);     } #endif #ifdef SBR_DEC     if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))         && hDecoder->sbr_alloced[hDecoder->fr_ch_ele])     {
  384. retval = safestack(sbrDecodeCouple,hDecoder,ics1,&hDecoder->stack);
  385.         if (retval > 0)             return retval;     } else if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))         && !hDecoder->sbr_alloced[hDecoder->fr_ch_ele])     {         return 23;     } #endif     return 0; }