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