src/lib/doslib/ext/faad/sbr_dec.c

   1 /*
   2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
   3 ** Copyright (C) 2003-2005 M. Bakker, Nero 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 ** The "appropriate copyright message" mentioned in section 2c of the GPLv2
  23 ** must read: "Code from FAAD2 is copyright (c) Nero AG, www.nero.com"
  24 **
  25 ** Commercial non-GPL licensing of this software is possible.
  26 ** For more info contact Nero AG through Mpeg4AAClicense@nero.com.
  27 **
  28 ** $Id: sbr_dec.c,v 1.44 2009/01/26 22:32:31 menno Exp $
  29 **/
  30
  31
  32 #include "common.h"
  33 #include "structs.h"
  34
  35 #ifdef SBR_DEC
  36
  37 #include <string.h>
  38 #include <stdlib.h>
  39
  40 #include "syntax.h"
  41 #include "bits.h"
  42 #include "sbr_synt.h"
  43 #include "sbr_qmf.h"
  44 #include "sbrhfgen.h"
  45 #include "sbrhfadj.h"
  46
  47
  48 /* static function declarations */
  49 static uint8_t sbr_save_prev_data(sbr_info *sbr, uint8_t ch);
  50 static void sbr_save_matrix(sbr_info *sbr, uint8_t ch);
  51
  52
  53 sbr_info *sbrDecodeInit(uint16_t framelength, uint8_t id_aac,
  54                         uint32_t sample_rate, uint8_t downSampledSBR
  55 #ifdef DRM
  56                                                 , uint8_t IsDRM
  57 #endif
  58                         )
  59 {
  60     sbr_info *sbr = faad_malloc(sizeof(sbr_info));
  61     memset(sbr, 0, sizeof(sbr_info));
  62
  63     /* save id of the parent element */
  64     sbr->id_aac = id_aac;
  65     sbr->sample_rate = sample_rate;
  66
  67     sbr->bs_freq_scale = 2;
  68     sbr->bs_alter_scale = 1;
  69     sbr->bs_noise_bands = 2;
  70     sbr->bs_limiter_bands = 2;
  71     sbr->bs_limiter_gains = 2;
  72     sbr->bs_interpol_freq = 1;
  73     sbr->bs_smoothing_mode = 1;
  74     sbr->bs_start_freq = 5;
  75     sbr->bs_amp_res = 1;
  76     sbr->bs_samplerate_mode = 1;
  77     sbr->prevEnvIsShort[0] = -1;
  78     sbr->prevEnvIsShort[1] = -1;
  79     sbr->header_count = 0;
  80     sbr->Reset = 1;
  81
  82 #ifdef DRM
  83     sbr->Is_DRM_SBR = IsDRM;
  84 #endif
  85     sbr->tHFGen = T_HFGEN;
  86     sbr->tHFAdj = T_HFADJ;
  87
  88     sbr->bsco = 0;
  89     sbr->bsco_prev = 0;
  90     sbr->M_prev = 0;
  91     sbr->frame_len = framelength;
  92
  93     /* force sbr reset */
  94     sbr->bs_start_freq_prev = -1;
  95
  96     if (framelength == 960)
  97     {
  98         sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS_960;
  99         sbr->numTimeSlots = NO_TIME_SLOTS_960;
 100     } else {
 101         sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS;
 102         sbr->numTimeSlots = NO_TIME_SLOTS;
 103     }
 104
 105     sbr->GQ_ringbuf_index[0] = 0;
 106     sbr->GQ_ringbuf_index[1] = 0;
 107
 108     if (id_aac == ID_CPE)
 109     {
 110         /* stereo */
 111         uint8_t j;
 112         sbr->qmfa[0] = qmfa_init(32);
 113         sbr->qmfa[1] = qmfa_init(32);
 114         sbr->qmfs[0] = qmfs_init((downSampledSBR)?32:64);
 115         sbr->qmfs[1] = qmfs_init((downSampledSBR)?32:64);
 116
 117         for (j = 0; j < 5; j++)
 118         {
 119             sbr->G_temp_prev[0][j] = faad_malloc(64*sizeof(real_t));
 120             sbr->G_temp_prev[1][j] = faad_malloc(64*sizeof(real_t));
 121             sbr->Q_temp_prev[0][j] = faad_malloc(64*sizeof(real_t));
 122             sbr->Q_temp_prev[1][j] = faad_malloc(64*sizeof(real_t));
 123         }
 124
 125         memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
 126         memset(sbr->Xsbr[1], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
 127     } else {
 128         /* mono */
 129         uint8_t j;
 130         sbr->qmfa[0] = qmfa_init(32);
 131         sbr->qmfs[0] = qmfs_init((downSampledSBR)?32:64);
 132         sbr->qmfs[1] = NULL;
 133
 134         for (j = 0; j < 5; j++)
 135         {
 136             sbr->G_temp_prev[0][j] = faad_malloc(64*sizeof(real_t));
 137             sbr->Q_temp_prev[0][j] = faad_malloc(64*sizeof(real_t));
 138         }
 139
 140         memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
 141     }
 142
 143     return sbr;
 144 }
 145
 146 void sbrDecodeEnd(sbr_info *sbr)
 147 {
 148     uint8_t j;
 149
 150     if (sbr)
 151     {
 152         qmfa_end(sbr->qmfa[0]);
 153         qmfs_end(sbr->qmfs[0]);
 154         if (sbr->qmfs[1] != NULL)
 155         {
 156             qmfa_end(sbr->qmfa[1]);
 157             qmfs_end(sbr->qmfs[1]);
 158         }
 159
 160         for (j = 0; j < 5; j++)
 161         {
 162             if (sbr->G_temp_prev[0][j]) faad_free(sbr->G_temp_prev[0][j]);
 163             if (sbr->Q_temp_prev[0][j]) faad_free(sbr->Q_temp_prev[0][j]);
 164             if (sbr->G_temp_prev[1][j]) faad_free(sbr->G_temp_prev[1][j]);
 165             if (sbr->Q_temp_prev[1][j]) faad_free(sbr->Q_temp_prev[1][j]);
 166         }
 167
 168 #ifdef PS_DEC
 169         if (sbr->ps != NULL)
 170             ps_free(sbr->ps);
 171 #endif
 172
 173 #ifdef DRM_PS
 174         if (sbr->drm_ps != NULL)
 175             drm_ps_free(sbr->drm_ps);
 176 #endif
 177
 178         faad_free(sbr);
 179     }
 180 }
 181
 182 void sbrReset(sbr_info *sbr)
 183 {
 184     uint8_t j;
 185     if (sbr->qmfa[0] != NULL)
 186         memset(sbr->qmfa[0]->x, 0, 2 * sbr->qmfa[0]->channels * 10 * sizeof(real_t));
 187     if (sbr->qmfa[1] != NULL)
 188         memset(sbr->qmfa[1]->x, 0, 2 * sbr->qmfa[1]->channels * 10 * sizeof(real_t));
 189     if (sbr->qmfs[0] != NULL)
 190         memset(sbr->qmfs[0]->v, 0, 2 * sbr->qmfs[0]->channels * 20 * sizeof(real_t));
 191     if (sbr->qmfs[1] != NULL)
 192         memset(sbr->qmfs[1]->v, 0, 2 * sbr->qmfs[1]->channels * 20 * sizeof(real_t));
 193
 194     for (j = 0; j < 5; j++)
 195     {
 196         if (sbr->G_temp_prev[0][j] != NULL)
 197             memset(sbr->G_temp_prev[0][j], 0, 64*sizeof(real_t));
 198         if (sbr->G_temp_prev[1][j] != NULL)
 199             memset(sbr->G_temp_prev[1][j], 0, 64*sizeof(real_t));
 200         if (sbr->Q_temp_prev[0][j] != NULL)
 201             memset(sbr->Q_temp_prev[0][j], 0, 64*sizeof(real_t));
 202         if (sbr->Q_temp_prev[1][j] != NULL)
 203             memset(sbr->Q_temp_prev[1][j], 0, 64*sizeof(real_t));
 204     }
 205
 206     memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
 207     memset(sbr->Xsbr[1], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
 208
 209     sbr->GQ_ringbuf_index[0] = 0;
 210     sbr->GQ_ringbuf_index[1] = 0;
 211     sbr->header_count = 0;
 212     sbr->Reset = 1;
 213
 214     sbr->L_E_prev[0] = 0;
 215     sbr->L_E_prev[1] = 0;
 216     sbr->bs_freq_scale = 2;
 217     sbr->bs_alter_scale = 1;
 218     sbr->bs_noise_bands = 2;
 219     sbr->bs_limiter_bands = 2;
 220     sbr->bs_limiter_gains = 2;
 221     sbr->bs_interpol_freq = 1;
 222     sbr->bs_smoothing_mode = 1;
 223     sbr->bs_start_freq = 5;
 224     sbr->bs_amp_res = 1;
 225     sbr->bs_samplerate_mode = 1;
 226     sbr->prevEnvIsShort[0] = -1;
 227     sbr->prevEnvIsShort[1] = -1;
 228     sbr->bsco = 0;
 229     sbr->bsco_prev = 0;
 230     sbr->M_prev = 0;
 231     sbr->bs_start_freq_prev = -1;
 232
 233     sbr->f_prev[0] = 0;
 234     sbr->f_prev[1] = 0;
 235     for (j = 0; j < MAX_M; j++)
 236     {
 237         sbr->E_prev[0][j] = 0;
 238         sbr->Q_prev[0][j] = 0;
 239         sbr->E_prev[1][j] = 0;
 240         sbr->Q_prev[1][j] = 0;
 241         sbr->bs_add_harmonic_prev[0][j] = 0;
 242         sbr->bs_add_harmonic_prev[1][j] = 0;
 243     }
 244     sbr->bs_add_harmonic_flag_prev[0] = 0;
 245     sbr->bs_add_harmonic_flag_prev[1] = 0;
 246 }
 247
 248 static uint8_t sbr_save_prev_data(sbr_info *sbr, uint8_t ch)
 249 {
 250     uint8_t i;
 251
 252     /* save data for next frame */
 253     sbr->kx_prev = sbr->kx;
 254     sbr->M_prev = sbr->M;
 255     sbr->bsco_prev = sbr->bsco;
 256
 257     sbr->L_E_prev[ch] = sbr->L_E[ch];
 258
 259     /* sbr->L_E[ch] can become 0 on files with bit errors */
 260     if (sbr->L_E[ch] <= 0)
 261         return 19;
 262
 263     sbr->f_prev[ch] = sbr->f[ch][sbr->L_E[ch] - 1];
 264     for (i = 0; i < MAX_M; i++)
 265     {
 266         sbr->E_prev[ch][i] = sbr->E[ch][i][sbr->L_E[ch] - 1];
 267         sbr->Q_prev[ch][i] = sbr->Q[ch][i][sbr->L_Q[ch] - 1];
 268     }
 269
 270     for (i = 0; i < MAX_M; i++)
 271     {
 272         sbr->bs_add_harmonic_prev[ch][i] = sbr->bs_add_harmonic[ch][i];
 273     }
 274     sbr->bs_add_harmonic_flag_prev[ch] = sbr->bs_add_harmonic_flag[ch];
 275
 276     if (sbr->l_A[ch] == sbr->L_E[ch])
 277         sbr->prevEnvIsShort[ch] = 0;
 278     else
 279         sbr->prevEnvIsShort[ch] = -1;
 280
 281     return 0;
 282 }
 283
 284 static void sbr_save_matrix(sbr_info *sbr, uint8_t ch)
 285 {
 286     uint8_t i;
 287
 288     for (i = 0; i < sbr->tHFGen; i++)
 289     {
 290         memmove(sbr->Xsbr[ch][i], sbr->Xsbr[ch][i+sbr->numTimeSlotsRate], 64 * sizeof(qmf_t));
 291     }
 292     for (i = sbr->tHFGen; i < MAX_NTSRHFG; i++)
 293     {
 294         memset(sbr->Xsbr[ch][i], 0, 64 * sizeof(qmf_t));
 295     }
 296 }
 297
 298 static uint8_t sbr_process_channel(sbr_info *sbr, real_t *channel_buf, qmf_t X[MAX_NTSR][64],
 299                                    uint8_t ch, uint8_t dont_process,
 300                                    const uint8_t downSampledSBR)
 301 {
 302     int16_t k, l;
 303     uint8_t ret = 0;
 304
 305 #ifdef SBR_LOW_POWER
 306     ALIGN real_t deg[64];
 307 #endif
 308
 309 #ifdef DRM
 310     if (sbr->Is_DRM_SBR)
 311     {
 312         sbr->bsco = max((int32_t)sbr->maxAACLine*32/(int32_t)sbr->frame_len - (int32_t)sbr->kx, 0);
 313     } else {
 314 #endif
 315         sbr->bsco = 0;
 316 #ifdef DRM
 317     }
 318 #endif
 319
 320
 321 //#define PRE_QMF_PRINT
 322 #ifdef PRE_QMF_PRINT
 323     {
 324         int i;
 325         for (i = 0; i < 1024; i++)
 326         {
 327             printf("%d\n", channel_buf[i]);
 328         }
 329     }
 330 #endif
 331
 332
 333     /* subband analysis */
 334     if (dont_process)
 335         sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xsbr[ch], sbr->tHFGen, 32);
 336     else
 337         sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xsbr[ch], sbr->tHFGen, sbr->kx);
 338
 339     if (!dont_process)
 340     {
 341 #if 1
 342         /* insert high frequencies here */
 343         /* hf generation using patching */
 344         hf_generation(sbr, sbr->Xsbr[ch], sbr->Xsbr[ch]
 345 #ifdef SBR_LOW_POWER
 346             ,deg
 347 #endif
 348             ,ch);
 349 #endif
 350
 351 #if 0 //def SBR_LOW_POWER
 352         for (l = sbr->t_E[ch][0]; l < sbr->t_E[ch][sbr->L_E[ch]]; l++)
 353         {
 354             for (k = 0; k < sbr->kx; k++)
 355             {
 356                 QMF_RE(sbr->Xsbr[ch][sbr->tHFAdj + l][k]) = 0;
 357             }
 358         }
 359 #endif
 360
 361 #if 1
 362         /* hf adjustment */
 363         ret = hf_adjustment(sbr, sbr->Xsbr[ch]
 364 #ifdef SBR_LOW_POWER
 365             ,deg
 366 #endif
 367             ,ch);
 368 #endif
 369         if (ret > 0)
 370         {
 371             dont_process = 1;
 372         }
 373     }
 374
 375     if ((sbr->just_seeked != 0) || dont_process)
 376     {
 377         for (l = 0; l < sbr->numTimeSlotsRate; l++)
 378         {
 379             for (k = 0; k < 32; k++)
 380             {
 381                 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
 382 #ifndef SBR_LOW_POWER
 383                 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
 384 #endif
 385             }
 386             for (k = 32; k < 64; k++)
 387             {
 388                 QMF_RE(X[l][k]) = 0;
 389 #ifndef SBR_LOW_POWER
 390                 QMF_IM(X[l][k]) = 0;
 391 #endif
 392             }
 393         }
 394     } else {
 395         for (l = 0; l < sbr->numTimeSlotsRate; l++)
 396         {
 397             uint8_t kx_band, M_band, bsco_band;
 398
 399             if (l < sbr->t_E[ch][0])
 400             {
 401                 kx_band = sbr->kx_prev;
 402                 M_band = sbr->M_prev;
 403                 bsco_band = sbr->bsco_prev;
 404             } else {
 405                 kx_band = sbr->kx;
 406                 M_band = sbr->M;
 407                 bsco_band = sbr->bsco;
 408             }
 409
 410 #ifndef SBR_LOW_POWER
 411             for (k = 0; k < kx_band + bsco_band; k++)
 412             {
 413                 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
 414                 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
 415             }
 416             for (k = kx_band + bsco_band; k < kx_band + M_band; k++)
 417             {
 418                 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
 419                 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
 420             }
 421             for (k = max(kx_band + bsco_band, kx_band + M_band); k < 64; k++)
 422             {
 423                 QMF_RE(X[l][k]) = 0;
 424                 QMF_IM(X[l][k]) = 0;
 425             }
 426 #else
 427             for (k = 0; k < kx_band + bsco_band; k++)
 428             {
 429                 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
 430             }
 431             for (k = kx_band + bsco_band; k < min(kx_band + M_band, 63); k++)
 432             {
 433                 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
 434             }
 435             for (k = max(kx_band + bsco_band, kx_band + M_band); k < 64; k++)
 436             {
 437                 QMF_RE(X[l][k]) = 0;
 438             }
 439             QMF_RE(X[l][kx_band - 1 + bsco_band]) +=
 440                 QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][kx_band - 1 + bsco_band]);
 441 #endif
 442         }
 443     }
 444
 445     return ret;
 446 }
 447
 448 uint8_t sbrDecodeCoupleFrame(sbr_info *sbr, real_t *left_chan, real_t *right_chan,
 449                              const uint8_t just_seeked, const uint8_t downSampledSBR)
 450 {
 451     uint8_t dont_process = 0;
 452     uint8_t ret = 0;
 453     ALIGN qmf_t X[MAX_NTSR][64];
 454
 455     if (sbr == NULL)
 456         return 20;
 457
 458     /* case can occur due to bit errors */
 459     if (sbr->id_aac != ID_CPE)
 460         return 21;
 461
 462     if (sbr->ret || (sbr->header_count == 0))
 463     {
 464         /* don't process just upsample */
 465         dont_process = 1;
 466
 467         /* Re-activate reset for next frame */
 468         if (sbr->ret && sbr->Reset)
 469             sbr->bs_start_freq_prev = -1;
 470     }
 471
 472     if (just_seeked)
 473     {
 474         sbr->just_seeked = 1;
 475     } else {
 476         sbr->just_seeked = 0;
 477     }
 478
 479     sbr->ret += sbr_process_channel(sbr, left_chan, X, 0, dont_process, downSampledSBR);
 480     /* subband synthesis */
 481     if (downSampledSBR)
 482     {
 483         sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X, left_chan);
 484     } else {
 485         sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, left_chan);
 486     }
 487
 488     sbr->ret += sbr_process_channel(sbr, right_chan, X, 1, dont_process, downSampledSBR);
 489     /* subband synthesis */
 490     if (downSampledSBR)
 491     {
 492         sbr_qmf_synthesis_32(sbr, sbr->qmfs[1], X, right_chan);
 493     } else {
 494         sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X, right_chan);
 495     }
 496
 497     if (sbr->bs_header_flag)
 498         sbr->just_seeked = 0;
 499
 500     if (sbr->header_count != 0 && sbr->ret == 0)
 501     {
 502         ret = sbr_save_prev_data(sbr, 0);
 503         if (ret) return ret;
 504         ret = sbr_save_prev_data(sbr, 1);
 505         if (ret) return ret;
 506     }
 507
 508     sbr_save_matrix(sbr, 0);
 509     sbr_save_matrix(sbr, 1);
 510
 511     sbr->frame++;
 512
 513 //#define POST_QMF_PRINT
 514 #ifdef POST_QMF_PRINT
 515     {
 516         int i;
 517         for (i = 0; i < 2048; i++)
 518         {
 519             printf("%d\n", left_chan[i]);
 520         }
 521         for (i = 0; i < 2048; i++)
 522         {
 523             printf("%d\n", right_chan[i]);
 524         }
 525     }
 526 #endif
 527
 528     return 0;
 529 }
 530
 531 uint8_t sbrDecodeSingleFrame(sbr_info *sbr, real_t *channel,
 532                              const uint8_t just_seeked, const uint8_t downSampledSBR)
 533 {
 534     uint8_t dont_process = 0;
 535     uint8_t ret = 0;
 536     ALIGN qmf_t X[MAX_NTSR][64];
 537
 538     if (sbr == NULL)
 539         return 20;
 540
 541     /* case can occur due to bit errors */
 542     if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE)
 543         return 21;
 544
 545     if (sbr->ret || (sbr->header_count == 0))
 546     {
 547         /* don't process just upsample */
 548         dont_process = 1;
 549
 550         /* Re-activate reset for next frame */
 551         if (sbr->ret && sbr->Reset)
 552             sbr->bs_start_freq_prev = -1;
 553     }
 554
 555     if (just_seeked)
 556     {
 557         sbr->just_seeked = 1;
 558     } else {
 559         sbr->just_seeked = 0;
 560     }
 561
 562     sbr->ret += sbr_process_channel(sbr, channel, X, 0, dont_process, downSampledSBR);
 563     /* subband synthesis */
 564     if (downSampledSBR)
 565     {
 566         sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X, channel);
 567     } else {
 568         sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, channel);
 569     }
 570
 571     if (sbr->bs_header_flag)
 572         sbr->just_seeked = 0;
 573
 574     if (sbr->header_count != 0 && sbr->ret == 0)
 575     {
 576         ret = sbr_save_prev_data(sbr, 0);
 577         if (ret) return ret;
 578     }
 579
 580     sbr_save_matrix(sbr, 0);
 581
 582     sbr->frame++;
 583
 584 //#define POST_QMF_PRINT
 585 #ifdef POST_QMF_PRINT
 586     {
 587         int i;
 588         for (i = 0; i < 2048; i++)
 589         {
 590             printf("%d\n", channel[i]);
 591         }
 592     }
 593 #endif
 594
 595     return 0;
 596 }
 597
 598 #if (defined(PS_DEC) || defined(DRM_PS))
 599 uint8_t sbrDecodeSingleFramePS(sbr_info *sbr, real_t *left_channel, real_t *right_channel,
 600                                const uint8_t just_seeked, const uint8_t downSampledSBR)
 601 {
 602     uint8_t l, k;
 603     uint8_t dont_process = 0;
 604     uint8_t ret = 0;
 605     ALIGN qmf_t X_left[38][64] = {{0}};
 606     ALIGN qmf_t X_right[38][64] = {{0}}; /* must set this to 0 */
 607
 608     if (sbr == NULL)
 609         return 20;
 610
 611     /* case can occur due to bit errors */
 612     if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE)
 613         return 21;
 614
 615     if (sbr->ret || (sbr->header_count == 0))
 616     {
 617         /* don't process just upsample */
 618         dont_process = 1;
 619
 620         /* Re-activate reset for next frame */
 621         if (sbr->ret && sbr->Reset)
 622             sbr->bs_start_freq_prev = -1;
 623     }
 624
 625     if (just_seeked)
 626     {
 627         sbr->just_seeked = 1;
 628     } else {
 629         sbr->just_seeked = 0;
 630     }
 631
 632     if (sbr->qmfs[1] == NULL)
 633     {
 634         sbr->qmfs[1] = qmfs_init((downSampledSBR)?32:64);
 635     }
 636
 637     sbr->ret += sbr_process_channel(sbr, left_channel, X_left, 0, dont_process, downSampledSBR);
 638
 639     /* copy some extra data for PS */
 640     for (l = sbr->numTimeSlotsRate; l < sbr->numTimeSlotsRate + 6; l++)
 641     {
 642         for (k = 0; k < 5; k++)
 643         {
 644             QMF_RE(X_left[l][k]) = QMF_RE(sbr->Xsbr[0][sbr->tHFAdj+l][k]);
 645             QMF_IM(X_left[l][k]) = QMF_IM(sbr->Xsbr[0][sbr->tHFAdj+l][k]);
 646         }
 647     }
 648
 649     /* perform parametric stereo */
 650 #ifdef DRM_PS
 651     if (sbr->Is_DRM_SBR)
 652     {
 653         drm_ps_decode(sbr->drm_ps, (sbr->ret > 0), X_left, X_right);
 654     } else {
 655 #endif
 656 #ifdef PS_DEC
 657         ps_decode(sbr->ps, X_left, X_right);
 658 #endif
 659 #ifdef DRM_PS
 660     }
 661 #endif
 662
 663     /* subband synthesis */
 664     if (downSampledSBR)
 665     {
 666         sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X_left, left_channel);
 667         sbr_qmf_synthesis_32(sbr, sbr->qmfs[1], X_right, right_channel);
 668     } else {
 669         sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X_left, left_channel);
 670         sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X_right, right_channel);
 671     }
 672
 673     if (sbr->bs_header_flag)
 674         sbr->just_seeked = 0;
 675
 676     if (sbr->header_count != 0 && sbr->ret == 0)
 677     {
 678         ret = sbr_save_prev_data(sbr, 0);
 679         if (ret) return ret;
 680     }
 681
 682     sbr_save_matrix(sbr, 0);
 683
 684     sbr->frame++;
 685
 686     return 0;
 687 }
 688 #endif
 689
 690 #endif