开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
sbr_dec.c
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：19k
源码类别：

多媒体编程

开发平台：

Visual C++

sbr_dec.c：源码内容
  1. /*
  2. ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
  3. ** Copyright (C) 2003-2005 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. ** Software using this code must display the following message visibly in the
  23. ** software:
  24. ** "FAAD2 AAC/HE-AAC/HE-AACv2/DRM decoder (c) Ahead Software, www.nero.com"
  25. ** in, for example, the about-box or help/startup screen.
  26. **
  27. ** Commercial non-GPL licensing of this software is possible.
  28. ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
  29. **
  30. ** $Id: sbr_dec.c,v 1.3 2005/11/01 21:41:43 gabest Exp $
  31. **/
  34. #include "common.h"
  35. #include "structs.h"
  37. #ifdef SBR_DEC
  39. #include <string.h>
  40. #include <stdlib.h>
  42. #include "syntax.h"
  43. #include "bits.h"
  44. #include "sbr_syntax.h"
  45. #include "sbr_qmf.h"
  46. #include "sbr_hfgen.h"
  47. #include "sbr_hfadj.h"
  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);
  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));
  65.     /* save id of the parent element */
  66.     sbr->id_aac = id_aac;
  67.     sbr->sample_rate = sample_rate;
  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;
  84. #ifdef DRM
  85.     sbr->Is_DRM_SBR = IsDRM;
  86. #endif
  87.     sbr->tHFGen = T_HFGEN;
  88.     sbr->tHFAdj = T_HFADJ;
  90.     sbr->bsco = 0;
  91.     sbr->bsco_prev = 0;
  92.     sbr->M_prev = 0;
  93.     sbr->frame_len = framelength;
  95.     /* force sbr reset */
  96.     sbr->bs_start_freq_prev = -1;
  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.     }
  107.     sbr->GQ_ringbuf_index[0] = 0;
  108.     sbr->GQ_ringbuf_index[1] = 0;
  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);
  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.         }
  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;
  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.         }
  142.         memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
  143.     }
  145.     return sbr;
  146. }
  148. void sbrDecodeEnd(sbr_info *sbr)
  149. {
  150.     uint8_t j;
  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.         }
  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.         }
  170. #ifdef PS_DEC
  171.         if (sbr->ps != NULL) 
  172.             ps_free(sbr->ps);
  173. #endif
  175. #ifdef DRM_PS
  176.         if (sbr->drm_ps != NULL)
  177.             drm_ps_free(sbr->drm_ps);
  178. #endif
  180.         faad_free(sbr);
  181.     }
  182. }
  184. void sbrReset(sbr_info *sbr)
  185. {
  186.     uint8_t j;
  187.     if (sbr->qmfa[0] != NULL)
  188.         memset(sbr->qmfa[0]->x, 0, 2 * sbr->qmfa[0]->channels * 10 * sizeof(real_t));
  189.     if (sbr->qmfa[1] != NULL)
  190.         memset(sbr->qmfa[1]->x, 0, 2 * sbr->qmfa[1]->channels * 10 * sizeof(real_t));
  191.     if (sbr->qmfs[0] != NULL)
  192.         memset(sbr->qmfs[0]->v, 0, 2 * sbr->qmfs[0]->channels * 20 * sizeof(real_t));
  193.     if (sbr->qmfs[1] != NULL)
  194.         memset(sbr->qmfs[1]->v, 0, 2 * sbr->qmfs[1]->channels * 20 * sizeof(real_t));
  196.     for (j = 0; j < 5; j++)
  197.     {
  198.         if (sbr->G_temp_prev[0][j] != NULL)
  199.             memset(sbr->G_temp_prev[0][j], 0, 64*sizeof(real_t));
  200.         if (sbr->G_temp_prev[1][j] != NULL)
  201.             memset(sbr->G_temp_prev[1][j], 0, 64*sizeof(real_t));
  202.         if (sbr->Q_temp_prev[0][j] != NULL)
  203.             memset(sbr->Q_temp_prev[0][j], 0, 64*sizeof(real_t));
  204.         if (sbr->Q_temp_prev[1][j] != NULL)
  205.             memset(sbr->Q_temp_prev[1][j], 0, 64*sizeof(real_t));
  206.     }
  208.     memset(sbr->Xsbr[0], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
  209.     memset(sbr->Xsbr[1], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
  210.     
  211.     sbr->GQ_ringbuf_index[0] = 0;
  212.     sbr->GQ_ringbuf_index[1] = 0;
  213.     sbr->header_count = 0;
  214.     sbr->Reset = 1;
  216.     sbr->L_E_prev[0] = 0;
  217.     sbr->L_E_prev[1] = 0;
  218.     sbr->bs_freq_scale = 2;
  219.     sbr->bs_alter_scale = 1;
  220.     sbr->bs_noise_bands = 2;
  221.     sbr->bs_limiter_bands = 2;
  222.     sbr->bs_limiter_gains = 2;
  223.     sbr->bs_interpol_freq = 1;
  224.     sbr->bs_smoothing_mode = 1;
  225.     sbr->bs_start_freq = 5;
  226.     sbr->bs_amp_res = 1;
  227.     sbr->bs_samplerate_mode = 1;
  228.     sbr->prevEnvIsShort[0] = -1;
  229.     sbr->prevEnvIsShort[1] = -1;
  230.     sbr->bsco = 0;
  231.     sbr->bsco_prev = 0;
  232.     sbr->M_prev = 0;
  233.     sbr->bs_start_freq_prev = -1;
  235.     sbr->f_prev[0] = 0;
  236.     sbr->f_prev[1] = 0;
  237.     for (j = 0; j < MAX_M; j++)
  238.     {
  239.         sbr->E_prev[0][j] = 0;
  240.         sbr->Q_prev[0][j] = 0;
  241.         sbr->E_prev[1][j] = 0;
  242.         sbr->Q_prev[1][j] = 0;
  243.         sbr->bs_add_harmonic_prev[0][j] = 0;
  244.         sbr->bs_add_harmonic_prev[1][j] = 0;
  245.     }
  246.     sbr->bs_add_harmonic_flag_prev[0] = 0;
  247.     sbr->bs_add_harmonic_flag_prev[1] = 0;
  248. }
  250. static uint8_t sbr_save_prev_data(sbr_info *sbr, uint8_t ch)
  251. {
  252.     uint8_t i;
  254.     /* save data for next frame */
  255.     sbr->kx_prev = sbr->kx;
  256.     sbr->M_prev = sbr->M;
  257.     sbr->bsco_prev = sbr->bsco;
  259.     sbr->L_E_prev[ch] = sbr->L_E[ch];
  261.     /* sbr->L_E[ch] can become 0 on files with bit errors */
  262.     if (sbr->L_E[ch] <= 0)
  263.         return 19;
  265.     sbr->f_prev[ch] = sbr->f[ch][sbr->L_E[ch] - 1];
  266.     for (i = 0; i < MAX_M; i++)
  267.     {
  268.         sbr->E_prev[ch][i] = sbr->E[ch][i][sbr->L_E[ch] - 1];
  269.         sbr->Q_prev[ch][i] = sbr->Q[ch][i][sbr->L_Q[ch] - 1];
  270.     }
  272.     for (i = 0; i < MAX_M; i++)
  273.     {
  274.         sbr->bs_add_harmonic_prev[ch][i] = sbr->bs_add_harmonic[ch][i];
  275.     }
  276.     sbr->bs_add_harmonic_flag_prev[ch] = sbr->bs_add_harmonic_flag[ch];
  278.     if (sbr->l_A[ch] == sbr->L_E[ch])
  279.         sbr->prevEnvIsShort[ch] = 0;
  280.     else
  281.         sbr->prevEnvIsShort[ch] = -1;
  283.     return 0;
  284. }
  286. static void sbr_save_matrix(sbr_info *sbr, uint8_t ch)
  287. {
  288.     uint8_t i;
  290.     for (i = 0; i < sbr->tHFGen; i++)
  291.     {
  292.         memmove(sbr->Xsbr[ch][i], sbr->Xsbr[ch][i+sbr->numTimeSlotsRate], 64 * sizeof(qmf_t));
  293.     }
  294.     for (i = sbr->tHFGen; i < MAX_NTSRHFG; i++)
  295.     {
  296.         memset(sbr->Xsbr[ch][i], 0, 64 * sizeof(qmf_t));
  297.     }
  298. }
  300. static uint8_t sbr_process_channel(sbr_info *sbr, real_t *channel_buf, qmf_t X[MAX_NTSR][64],
  301.                                    uint8_t ch, uint8_t dont_process,
  302.                                    const uint8_t downSampledSBR)
  303. {
  304.     int16_t k, l;
  305.     uint8_t ret = 0;
  307. #ifdef SBR_LOW_POWER
  308.     ALIGN real_t deg[64];
  309. #endif
  311. #ifdef DRM
  312.     if (sbr->Is_DRM_SBR)
  313.     {
  314.         sbr->bsco = max((int32_t)sbr->maxAACLine*32/(int32_t)sbr->frame_len - (int32_t)sbr->kx, 0);
  315.     } else {
  316. #endif
  317.         sbr->bsco = 0;
  318. #ifdef DRM
  319.     }
  320. #endif
  323. //#define PRE_QMF_PRINT
  324. #ifdef PRE_QMF_PRINT
  325.     {
  326.         int i;
  327.         for (i = 0; i < 1024; i++)
  328.         {
  329.             printf("%dn", channel_buf[i]);
  330.         }
  331.     }
  332. #endif
  335.     /* subband analysis */
  336.     if (dont_process)
  337.         sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xsbr[ch], sbr->tHFGen, 32);
  338.     else
  339.         sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xsbr[ch], sbr->tHFGen, sbr->kx);
  341.     if (!dont_process)
  342.     {
  343. #if 1
  344.         /* insert high frequencies here */
  345.         /* hf generation using patching */
  346.         hf_generation(sbr, sbr->Xsbr[ch], sbr->Xsbr[ch]
  347. #ifdef SBR_LOW_POWER
  348.             ,deg
  349. #endif
  350.             ,ch);
  351. #endif
  353. #if 0 //def SBR_LOW_POWER
  354.         for (l = sbr->t_E[ch][0]; l < sbr->t_E[ch][sbr->L_E[ch]]; l++)
  355.         {
  356.             for (k = 0; k < sbr->kx; k++)
  357.             {
  358.                 QMF_RE(sbr->Xsbr[ch][sbr->tHFAdj + l][k]) = 0;
  359.             }
  360.         }
  361. #endif
  363. #if 1
  364.         /* hf adjustment */
  365.         ret = hf_adjustment(sbr, sbr->Xsbr[ch]
  366. #ifdef SBR_LOW_POWER
  367.             ,deg
  368. #endif
  369.             ,ch);
  370. #endif
  371.         if (ret > 0)
  372.         {
  373.             dont_process = 1;
  374.         }
  375.     }
  377.     if ((sbr->just_seeked != 0) || dont_process)
  378.     {
  379.         for (l = 0; l < sbr->numTimeSlotsRate; l++)
  380.         {
  381.             for (k = 0; k < 32; k++)
  382.             {
  383.                 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
  384. #ifndef SBR_LOW_POWER
  385.                 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
  386. #endif
  387.             }
  388.             for (k = 32; k < 64; k++)
  389.             {
  390.                 QMF_RE(X[l][k]) = 0;
  391. #ifndef SBR_LOW_POWER
  392.                 QMF_IM(X[l][k]) = 0;
  393. #endif
  394.             }
  395.         }
  396.     } else {
  397.         for (l = 0; l < sbr->numTimeSlotsRate; l++)
  398.         {
  399.             uint8_t kx_band, M_band, bsco_band;
  401.             if (l < sbr->t_E[ch][0])
  402.             {
  403.                 kx_band = sbr->kx_prev;
  404.                 M_band = sbr->M_prev;
  405.                 bsco_band = sbr->bsco_prev;
  406.             } else {
  407.                 kx_band = sbr->kx;
  408.                 M_band = sbr->M;
  409.                 bsco_band = sbr->bsco;
  410.             }
  412. #ifndef SBR_LOW_POWER
  413.             for (k = 0; k < kx_band + bsco_band; k++)
  414.             {
  415.                 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
  416.                 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
  417.             }
  418.             for (k = kx_band + bsco_band; k < kx_band + M_band; k++)
  419.             {
  420.                 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
  421.                 QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
  422.             }
  423.             for (k = max(kx_band + bsco_band, kx_band + M_band); k < 64; k++)
  424.             {
  425.                 QMF_RE(X[l][k]) = 0;
  426.                 QMF_IM(X[l][k]) = 0;
  427.             }
  428. #else
  429.             for (k = 0; k < kx_band + bsco_band; k++)
  430.             {
  431.                 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
  432.             }
  433.             for (k = kx_band + bsco_band; k < min(kx_band + M_band, 63); k++)
  434.             {
  435.                 QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
  436.             }
  437.             for (k = max(kx_band + bsco_band, kx_band + M_band); k < 64; k++)
  438.             {
  439.                 QMF_RE(X[l][k]) = 0;
  440.             }
  441.             QMF_RE(X[l][kx_band - 1 + bsco_band]) +=
  442.                 QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][kx_band - 1 + bsco_band]);
  443. #endif
  444.         }
  445.     }
  447.     return ret;
  448. }
  450. uint8_t sbrDecodeCoupleFrame(sbr_info *sbr, real_t *left_chan, real_t *right_chan,
  451.                              const uint8_t just_seeked, const uint8_t downSampledSBR)
  452. {
  453.     uint8_t dont_process = 0;
  454.     uint8_t ret = 0;
  455.     ALIGN qmf_t X[MAX_NTSR][64];
  457.     if (sbr == NULL)
  458.         return 20;
  460.     /* case can occur due to bit errors */
  461.     if (sbr->id_aac != ID_CPE)
  462.         return 21;
  464.     if (sbr->ret || (sbr->header_count == 0))
  465.     {
  466.         /* don't process just upsample */
  467.         dont_process = 1;
  469.         /* Re-activate reset for next frame */
  470.         if (sbr->ret && sbr->Reset)
  471.             sbr->bs_start_freq_prev = -1;
  472.     }
  474.     if (just_seeked)
  475.     {
  476.         sbr->just_seeked = 1;
  477.     } else {
  478.         sbr->just_seeked = 0;
  479.     }
  481.     sbr->ret += sbr_process_channel(sbr, left_chan, X, 0, dont_process, downSampledSBR);
  482.     /* subband synthesis */
  483.     if (downSampledSBR)
  484.     {
  485.         sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X, left_chan);
  486.     } else {
  487.         sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, left_chan);
  488.     }
  490.     sbr->ret += sbr_process_channel(sbr, right_chan, X, 1, dont_process, downSampledSBR);
  491.     /* subband synthesis */
  492.     if (downSampledSBR)
  493.     {
  494.         sbr_qmf_synthesis_32(sbr, sbr->qmfs[1], X, right_chan);
  495.     } else {
  496.         sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X, right_chan);
  497.     }
  499.     if (sbr->bs_header_flag)
  500.         sbr->just_seeked = 0;
  502.     if (sbr->header_count != 0 && sbr->ret == 0)
  503.     {
  504.         ret = sbr_save_prev_data(sbr, 0);
  505.         if (ret) return ret;
  506.         ret = sbr_save_prev_data(sbr, 1);
  507.         if (ret) return ret;
  508.     }
  510.     sbr_save_matrix(sbr, 0);
  511.     sbr_save_matrix(sbr, 1);
  513.     sbr->frame++;
  515. //#define POST_QMF_PRINT
  516. #ifdef POST_QMF_PRINT
  517.     {
  518.         int i;
  519.         for (i = 0; i < 2048; i++)
  520.         {
  521.             printf("%dn", left_chan[i]);
  522.         }
  523.         for (i = 0; i < 2048; i++)
  524.         {
  525.             printf("%dn", right_chan[i]);
  526.         }
  527.     }
  528. #endif
  530.     return 0;
  531. }
  533. uint8_t sbrDecodeSingleFrame(sbr_info *sbr, real_t *channel,
  534.                              const uint8_t just_seeked, const uint8_t downSampledSBR)
  535. {
  536.     uint8_t dont_process = 0;
  537.     uint8_t ret = 0;
  538.     ALIGN qmf_t X[MAX_NTSR][64];
  540.     if (sbr == NULL)
  541.         return 20;
  543.     /* case can occur due to bit errors */
  544.     if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE)
  545.         return 21;
  547.     if (sbr->ret || (sbr->header_count == 0))
  548.     {
  549.         /* don't process just upsample */
  550.         dont_process = 1;
  552.         /* Re-activate reset for next frame */
  553.         if (sbr->ret && sbr->Reset)
  554.             sbr->bs_start_freq_prev = -1;
  555.     }
  557.     if (just_seeked)
  558.     {
  559.         sbr->just_seeked = 1;
  560.     } else {
  561.         sbr->just_seeked = 0;
  562.     }
  564.     sbr->ret += sbr_process_channel(sbr, channel, X, 0, dont_process, downSampledSBR);
  565.     /* subband synthesis */
  566.     if (downSampledSBR)
  567.     {
  568.         sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X, channel);
  569.     } else {
  570.         sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, channel);
  571.     }
  573.     if (sbr->bs_header_flag)
  574.         sbr->just_seeked = 0;
  576.     if (sbr->header_count != 0 && sbr->ret == 0)
  577.     {
  578.         ret = sbr_save_prev_data(sbr, 0);
  579.         if (ret) return ret;
  580.     }
  582.     sbr_save_matrix(sbr, 0);
  584.     sbr->frame++;
  586. //#define POST_QMF_PRINT
  587. #ifdef POST_QMF_PRINT
  588.     {
  589.         int i;
  590.         for (i = 0; i < 2048; i++)
  591.         {
  592.             printf("%dn", channel[i]);
  593.         }
  594.     }
  595. #endif
  597.     return 0;
  598. }
  600. #if (defined(PS_DEC) || defined(DRM_PS))
  601. uint8_t sbrDecodeSingleFramePS(sbr_info *sbr, real_t *left_channel, real_t *right_channel,
  602.                                const uint8_t just_seeked, const uint8_t downSampledSBR)
  603. {
  604.     uint8_t l, k;
  605.     uint8_t dont_process = 0;
  606.     uint8_t ret = 0;
  607.     ALIGN qmf_t X_left[38][64] = {{0}};
  608.     ALIGN qmf_t X_right[38][64] = {{0}}; /* must set this to 0 */
  610.     if (sbr == NULL)
  611.         return 20;
  613.     /* case can occur due to bit errors */
  614.     if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE)
  615.         return 21;
  617.     if (sbr->ret || (sbr->header_count == 0))
  618.     {
  619.         /* don't process just upsample */
  620.         dont_process = 1;
  622.         /* Re-activate reset for next frame */
  623.         if (sbr->ret && sbr->Reset)
  624.             sbr->bs_start_freq_prev = -1;
  625.     }
  627.     if (just_seeked)
  628.     {
  629.         sbr->just_seeked = 1;
  630.     } else {
  631.         sbr->just_seeked = 0;
  632.     }
  634.     if (sbr->qmfs[1] == NULL)
  635.     {
  636.         sbr->qmfs[1] = qmfs_init((downSampledSBR)?32:64);
  637.     }
  639.     sbr->ret += sbr_process_channel(sbr, left_channel, X_left, 0, dont_process, downSampledSBR);
  641.     /* copy some extra data for PS */
  642.     for (l = 32; l < 38; l++)
  643.     {
  644.         for (k = 0; k < 5; k++)
  645.         {
  646.             QMF_RE(X_left[l][k]) = QMF_RE(sbr->Xsbr[0][sbr->tHFAdj+l][k]);
  647.             QMF_IM(X_left[l][k]) = QMF_IM(sbr->Xsbr[0][sbr->tHFAdj+l][k]);
  648.         }
  649.     }
  651.     /* perform parametric stereo */
  652. #ifdef DRM_PS
  653.     if (sbr->Is_DRM_SBR)
  654.     {
  655.         drm_ps_decode(sbr->drm_ps, (sbr->ret > 0), X_left, X_right);
  656.     } else {
  657. #endif
  658. #ifdef PS_DEC
  659.         ps_decode(sbr->ps, X_left, X_right);
  660. #endif
  661. #ifdef DRM_PS
  662.     }
  663. #endif
  665.     /* subband synthesis */
  666.     if (downSampledSBR)
  667.     {
  668.         sbr_qmf_synthesis_32(sbr, sbr->qmfs[0], X_left, left_channel);
  669.         sbr_qmf_synthesis_32(sbr, sbr->qmfs[1], X_right, right_channel);
  670.     } else {
  671.         sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X_left, left_channel);
  672.         sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X_right, right_channel);
  673.     }
  675.     if (sbr->bs_header_flag)
  676.         sbr->just_seeked = 0;
  678.     if (sbr->header_count != 0 && sbr->ret == 0)
  679.     {
  680.         ret = sbr_save_prev_data(sbr, 0);
  681.         if (ret) return ret;
  682.     }
  684.     sbr_save_matrix(sbr, 0);
  686.     sbr->frame++;
  688.     return 0;
  689. }
  690. #endif
  692. #endif