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 /* 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->tHFGen = T_HFGEN;
  83     sbr->tHFAdj = T_HFADJ;
  84
  85     sbr->bsco = 0;
  86     sbr->bsco_prev = 0;
  87     sbr->M_prev = 0;
  88     sbr->frame_len = framelength;
  89
  90     /* force sbr reset */
  91     sbr->bs_start_freq_prev = -1;
  92
  93     if (framelength == 960)
  94     {
  95         sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS_960;
  96         sbr->numTimeSlots = NO_TIME_SLOTS_960;
  97     } else {
  98         sbr->numTimeSlotsRate = RATE * NO_TIME_SLOTS;
  99         sbr->numTimeSlots = NO_TIME_SLOTS;
 100     }
 101
 102     sbr->GQ_ringbuf_index[0] = 0;
 103     sbr->GQ_ringbuf_index[1] = 0;
 104
 105     if (id_aac == ID_CPE)
 106     {
 107         /* stereo */
 108         uint8_t j;
 109         sbr->qmfa[0] = qmfa_init(32);
 110         sbr->qmfa[1] = qmfa_init(32);
 111         sbr->qmfs[0] = qmfs_init((downSampledSBR)?32:64);
 112         sbr->qmfs[1] = qmfs_init((downSampledSBR)?32:64);
 113
 114         for (j = 0; j < 5; j++)
 115         {
 116             sbr->G_temp_prev[0][j] = faad_malloc(64*sizeof(real_t));
 117             sbr->G_temp_prev[1][j] = faad_malloc(64*sizeof(real_t));
 118             sbr->Q_temp_prev[0][j] = faad_malloc(64*sizeof(real_t));
 119             sbr->Q_temp_prev[1][j] = faad_malloc(64*sizeof(real_t));
 120         }
 121
 122         memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
 123         memset(sbr->Xsbr[1], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
 124     } else {
 125         /* mono */
 126         uint8_t j;
 127         sbr->qmfa[0] = qmfa_init(32);
 128         sbr->qmfs[0] = qmfs_init((downSampledSBR)?32:64);
 129         sbr->qmfs[1] = NULL;
 130
 131         for (j = 0; j < 5; j++)
 132         {
 133             sbr->G_temp_prev[0][j] = faad_malloc(64*sizeof(real_t));
 134             sbr->Q_temp_prev[0][j] = faad_malloc(64*sizeof(real_t));
 135         }
 136
 137         memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
 138     }
 139
 140     return sbr;
 141 }
 142
 143 void sbrDecodeEnd(sbr_info *sbr)
 144 {
 145     uint8_t j;
 146
 147     if (sbr)
 148     {
 149         qmfa_end(sbr->qmfa[0]);
 150         qmfs_end(sbr->qmfs[0]);
 151         if (sbr->qmfs[1] != NULL)
 152         {
 153             qmfa_end(sbr->qmfa[1]);
 154             qmfs_end(sbr->qmfs[1]);
 155         }
 156
 157         for (j = 0; j < 5; j++)
 158         {
 159             if (sbr->G_temp_prev[0][j]) faad_free(sbr->G_temp_prev[0][j]);
 160             if (sbr->Q_temp_prev[0][j]) faad_free(sbr->Q_temp_prev[0][j]);
 161             if (sbr->G_temp_prev[1][j]) faad_free(sbr->G_temp_prev[1][j]);
 162             if (sbr->Q_temp_prev[1][j]) faad_free(sbr->Q_temp_prev[1][j]);
 163         }
 164
 165 #ifdef PS_DEC
 166         if (sbr->ps != NULL)
 167             ps_free(sbr->ps);
 168 #endif
 169
 170 #ifdef DRM_PS
 171         if (sbr->drm_ps != NULL)
 172             drm_ps_free(sbr->drm_ps);
 173 #endif
 174
 175         faad_free(sbr);
 176     }
 177 }
 178
 179 static uint8_t sbr_save_prev_data(sbr_info *sbr, uint8_t ch)
 180 {
 181     uint8_t i;
 182
 183     /* save data for next frame */
 184     sbr->kx_prev = sbr->kx;
 185     sbr->M_prev = sbr->M;
 186     sbr->bsco_prev = sbr->bsco;
 187
 188     sbr->L_E_prev[ch] = sbr->L_E[ch];
 189
 190     /* sbr->L_E[ch] can become 0 on files with bit errors */
 191     if (sbr->L_E[ch] <= 0)
 192         return 19;
 193
 194     sbr->f_prev[ch] = sbr->f[ch][sbr->L_E[ch] - 1];
 195     for (i = 0; i < MAX_M; i++)
 196     {
 197         sbr->E_prev[ch][i] = sbr->E[ch][i][sbr->L_E[ch] - 1];
 198         sbr->Q_prev[ch][i] = sbr->Q[ch][i][sbr->L_Q[ch] - 1];
 199     }
 200
 201     for (i = 0; i < MAX_M; i++)
 202     {
 203         sbr->bs_add_harmonic_prev[ch][i] = sbr->bs_add_harmonic[ch][i];
 204     }
 205     sbr->bs_add_harmonic_flag_prev[ch] = sbr->bs_add_harmonic_flag[ch];
 206
 207     if (sbr->l_A[ch] == sbr->L_E[ch])
 208         sbr->prevEnvIsShort[ch] = 0;
 209     else
 210         sbr->prevEnvIsShort[ch] = -1;
 211
 212     return 0;
 213 }
 214
 215 static void sbr_save_matrix(sbr_info *sbr, uint8_t ch)
 216 {
 217     uint8_t i;
 218
 219     for (i = 0; i < sbr->tHFGen; i++)
 220     {
 221         memmove(sbr->Xsbr[ch][i], sbr->Xsbr[ch][i+sbr->numTimeSlotsRate], 64 * sizeof(qmf_t));
 222     }
 223     for (i = sbr->tHFGen; i < MAX_NTSRHFG; i++)
 224     {
 225         memset(sbr->Xsbr[ch][i], 0, 64 * sizeof(qmf_t));
 226     }
 227 }
 228
 229 #ifdef SBR_LOW_POWER
 230     ALIGN real_t deg[64];
 231 #endif
 232
 233 static void sbr_process_channel(sbr_info *sbr, real_t *channel_buf, qmf_t X[MAX_NTSR][64],
 234                                 uint8_t ch, uint8_t dont_process,
 235                                 const uint8_t downSampledSBR)
 236 {
 237     int16_t k, l;
 238
 239     (void)downSampledSBR;
 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 ALIGN qmf_t X[MAX_NTSR][64];
 374 uint8_t sbrDecodeCoupleFrame(sbr_info *sbr, real_t *left_chan, real_t *right_chan,
 375                              const uint8_t just_seeked, const uint8_t downSampledSBR)
 376 {
 377     uint8_t dont_process = 0;
 378     uint8_t ret = 0;
 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 ALIGN qmf_t X[MAX_NTSR][64];
 457
 458 uint8_t sbrDecodeSingleFrame(sbr_info *sbr, real_t *channel,
 459                              const uint8_t just_seeked, const uint8_t downSampledSBR)
 460 {
 461     uint8_t dont_process = 0;
 462     uint8_t ret = 0;
 463
 464     if (sbr == NULL)
 465         return 20;
 466
 467     /* case can occur due to bit errors */
 468     if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE)
 469         return 21;
 470
 471     if (sbr->ret || (sbr->header_count == 0))
 472     {
 473         /* don't process just upsample */
 474         dont_process = 1;
 475
 476         /* Re-activate reset for next frame */
 477         if (sbr->ret && sbr->Reset)
 478             sbr->bs_start_freq_prev = -1;
 479     }
 480
 481     if (just_seeked)
 482     {
 483         sbr->just_seeked = 1;
 484     } else {
 485         sbr->just_seeked = 0;
 486     }
 487
 488     sbr_process_channel(sbr, channel, X, 0, dont_process, downSampledSBR);
 489     /* subband synthesis */
 490     if (downSampledSBR)
 491     {
 492         sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X, channel);
 493     } else {
 494         sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, channel);
 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     }
 505
 506     sbr_save_matrix(sbr, 0);
 507
 508     sbr->frame++;
 509
 510 //#define POST_QMF_PRINT
 511 #ifdef POST_QMF_PRINT
 512     {
 513         int i;
 514         for (i = 0; i < 2048; i++)
 515         {
 516             printf("%d\n", channel[i]);
 517         }
 518     }
 519 #endif
 520
 521     return 0;
 522 }
 523
 524 ALIGN qmf_t X_left[MAX_NTSRHFG][64];// = {{0}};
 525 ALIGN qmf_t X_right[MAX_NTSRHFG][64];// = {{0}}; /* must set this to 0 */
 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