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