apps/codecs/libfaad/sbr_tf_grid.c

   1 /*
   2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
   3 ** Copyright (C) 2003-2004 M. Bakker, Ahead Software AG, http://www.nero.com
   4 **
   5 ** This program is free software; you can redistribute it and/or modify
   6 ** it under the terms of the GNU General Public License as published by
   7 ** the Free Software Foundation; either version 2 of the License, or
   8 ** (at your option) any later version.
   9 **
  10 ** This program is distributed in the hope that it will be useful,
  11 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 ** GNU General Public License for more details.
  14 **
  15 ** You should have received a copy of the GNU General Public License
  16 ** along with this program; if not, write to the Free Software
  17 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18 **
  19 ** Any non-GPL usage of this software or parts of this software is strictly
  20 ** forbidden.
  21 **
  22 ** Commercial non-GPL licensing of this software is possible.
  23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
  24 **
  25 ** $Id$
  26 **/
  27
  28 /* Time/Frequency grid */
  29
  30 #include "common.h"
  31 #include "structs.h"
  32
  33 #ifdef SBR_DEC
  34
  35 #include <stdlib.h>
  36
  37 #include "sbr_syntax.h"
  38 #include "sbr_tf_grid.h"
  39
  40
  41 /* static function declarations */
  42 #if 0
  43 static int16_t rel_bord_lead(sbr_info *sbr, uint8_t ch, uint8_t l);
  44 static int16_t rel_bord_trail(sbr_info *sbr, uint8_t ch, uint8_t l);
  45 #endif
  46 static uint8_t middleBorder(sbr_info *sbr, uint8_t ch);
  47
  48
  49 /* function constructs new time border vector */
  50 /* first build into temp vector to be able to use previous vector on error */
  51 uint8_t envelope_time_border_vector(sbr_info *sbr, uint8_t ch)
  52 {
  53     uint8_t l, temp;
  54     int8_t border;
  55     uint8_t t_E_temp[6] = {0};
  56
  57     t_E_temp[0] = sbr->rate * sbr->abs_bord_lead[ch];
  58     t_E_temp[sbr->L_E[ch]] = sbr->rate * sbr->abs_bord_trail[ch];
  59
  60     switch (sbr->bs_frame_class[ch])
  61     {
  62     case FIXFIX:
  63         switch (sbr->L_E[ch])
  64         {
  65         case 4:
  66             temp = (int) (sbr->numTimeSlots / 4);
  67             t_E_temp[3] = sbr->rate * 3 * temp;
  68             t_E_temp[2] = sbr->rate * 2 * temp;
  69             t_E_temp[1] = sbr->rate * temp;
  70             break;
  71         case 2:
  72             t_E_temp[1] = sbr->rate * (int) (sbr->numTimeSlots / 2);
  73             break;
  74         default:
  75             break;
  76         }
  77         break;
  78
  79     case FIXVAR:
  80         if (sbr->L_E[ch] > 1)
  81         {
  82             int8_t i = sbr->L_E[ch];
  83             border = sbr->abs_bord_trail[ch];
  84
  85             for (l = 0; l < (sbr->L_E[ch] - 1); l++)
  86             {
  87                 if (border < sbr->bs_rel_bord[ch][l])
  88                     return 1;
  89
  90                 border -= sbr->bs_rel_bord[ch][l];
  91                 t_E_temp[--i] = sbr->rate * border;
  92             }
  93         }
  94         break;
  95
  96     case VARFIX:
  97         if (sbr->L_E[ch] > 1)
  98         {
  99             int8_t i = 1;
 100             border = sbr->abs_bord_lead[ch];
 101
 102             for (l = 0; l < (sbr->L_E[ch] - 1); l++)
 103             {
 104                 border += sbr->bs_rel_bord[ch][l];
 105
 106                 if (sbr->rate * border + sbr->tHFAdj > sbr->numTimeSlotsRate+sbr->tHFGen)
 107                     return 1;
 108
 109                 t_E_temp[i++] = sbr->rate * border;
 110             }
 111         }
 112         break;
 113
 114     case VARVAR:
 115         if (sbr->bs_num_rel_0[ch])
 116         {
 117             int8_t i = 1;
 118             border = sbr->abs_bord_lead[ch];
 119
 120             for (l = 0; l < sbr->bs_num_rel_0[ch]; l++)
 121             {
 122                 border += sbr->bs_rel_bord_0[ch][l];
 123
 124                 if (sbr->rate * border + sbr->tHFAdj > sbr->numTimeSlotsRate+sbr->tHFGen)
 125                     return 1;
 126
 127                 t_E_temp[i++] = sbr->rate * border;
 128             }
 129         }
 130
 131         if (sbr->bs_num_rel_1[ch])
 132         {
 133             int8_t i = sbr->L_E[ch];
 134             border = sbr->abs_bord_trail[ch];
 135
 136             for (l = 0; l < sbr->bs_num_rel_1[ch]; l++)
 137             {
 138                 if (border < sbr->bs_rel_bord_1[ch][l])
 139                     return 1;
 140
 141                 border -= sbr->bs_rel_bord_1[ch][l];
 142                 t_E_temp[--i] = sbr->rate * border;
 143             }
 144         }
 145         break;
 146     }
 147
 148     /* no error occured, we can safely use this t_E vector */
 149     for (l = 0; l < 6; l++)
 150     {
 151         sbr->t_E[ch][l] = t_E_temp[l];
 152     }
 153
 154     return 0;
 155 }
 156
 157 void noise_floor_time_border_vector(sbr_info *sbr, uint8_t ch)
 158 {
 159     sbr->t_Q[ch][0] = sbr->t_E[ch][0];
 160
 161     if (sbr->L_E[ch] == 1)
 162     {
 163         sbr->t_Q[ch][1] = sbr->t_E[ch][1];
 164         sbr->t_Q[ch][2] = 0;
 165     } else {
 166         uint8_t index = middleBorder(sbr, ch);
 167         sbr->t_Q[ch][1] = sbr->t_E[ch][index];
 168         sbr->t_Q[ch][2] = sbr->t_E[ch][sbr->L_E[ch]];
 169     }
 170 }
 171
 172 #if 0
 173 static int16_t rel_bord_lead(sbr_info *sbr, uint8_t ch, uint8_t l)
 174 {
 175     uint8_t i;
 176     int16_t acc = 0;
 177
 178     switch (sbr->bs_frame_class[ch])
 179     {
 180     case FIXFIX:
 181         return sbr->numTimeSlots/sbr->L_E[ch];
 182     case FIXVAR:
 183         return 0;
 184     case VARFIX:
 185         for (i = 0; i < l; i++)
 186         {
 187             acc += sbr->bs_rel_bord[ch][i];
 188         }
 189         return acc;
 190     case VARVAR:
 191         for (i = 0; i < l; i++)
 192         {
 193             acc += sbr->bs_rel_bord_0[ch][i];
 194         }
 195         return acc;
 196     }
 197
 198     return 0;
 199 }
 200
 201 static int16_t rel_bord_trail(sbr_info *sbr, uint8_t ch, uint8_t l)
 202 {
 203     uint8_t i;
 204     int16_t acc = 0;
 205
 206     switch (sbr->bs_frame_class[ch])
 207     {
 208     case FIXFIX:
 209     case VARFIX:
 210         return 0;
 211     case FIXVAR:
 212         for (i = 0; i < l; i++)
 213         {
 214             acc += sbr->bs_rel_bord[ch][i];
 215         }
 216         return acc;
 217     case VARVAR:
 218         for (i = 0; i < l; i++)
 219         {
 220             acc += sbr->bs_rel_bord_1[ch][i];
 221         }
 222         return acc;
 223     }
 224
 225     return 0;
 226 }
 227 #endif
 228
 229 static uint8_t middleBorder(sbr_info *sbr, uint8_t ch)
 230 {
 231     int8_t retval = 0;
 232
 233     switch (sbr->bs_frame_class[ch])
 234     {
 235     case FIXFIX:
 236         retval = sbr->L_E[ch]/2;
 237         break;
 238     case VARFIX:
 239         if (sbr->bs_pointer[ch] == 0)
 240             retval = 1;
 241         else if (sbr->bs_pointer[ch] == 1)
 242             retval = sbr->L_E[ch] - 1;
 243         else
 244             retval = sbr->bs_pointer[ch] - 1;
 245         break;
 246     case FIXVAR:
 247     case VARVAR:
 248         if (sbr->bs_pointer[ch] > 1)
 249             retval = sbr->L_E[ch] + 1 - sbr->bs_pointer[ch];
 250         else
 251             retval = sbr->L_E[ch] - 1;
 252         break;
 253     }
 254
 255     return (retval > 0) ? retval : 0;
 256 }
 257
 258
 259 #endif