update to the 2.0 release of faad, patch by adland

git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@12528 b3059339-0415-0410-9bf9-f77b7e298cf2

1 files changed, 288 insertions, 204 deletions

diff --git a/libfaad2/sbr_dec.c b/libfaad2/sbr_dec.c
index ed1e28dd5b..af1edb20d1 100644
--- a/libfaad2/sbr_dec.c
+++ b/libfaad2/sbr_dec.c
@@ -1,6 +1,6 @@
 /*
 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
-** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.com
+** Copyright (C) 2003-2004 M. Bakker, Ahead Software AG, http://www.nero.com
 **  
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
@@ -22,7 +22,7 @@
 ** Commercial non-GPL licensing of this software is possible.
 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
 **
-** $Id: sbr_dec.c,v 1.12 2003/09/25 12:04:31 menno Exp $
+** $Id: sbr_dec.c,v 1.2 2003/10/03 22:22:27 alex Exp $
 **/
 
 
@@ -31,6 +31,7 @@
 
 #ifdef SBR_DEC
 
+#include <string.h>
 #include <stdlib.h>
 
 #include "syntax.h"
@@ -40,16 +41,23 @@
 #include "sbr_hfgen.h"
 #include "sbr_hfadj.h"
 
+/* static function declarations */
+static uint8_t sbr_save_prev_data(sbr_info *sbr, uint8_t ch);
 
-sbr_info *sbrDecodeInit(uint16_t framelength
+sbr_info *sbrDecodeInit(uint16_t framelength, uint8_t id_aac,
+                        uint32_t sample_rate
 #ifdef DRM
 						, uint8_t IsDRM
 #endif
                         )
 {
-    sbr_info *sbr = malloc(sizeof(sbr_info));
+    sbr_info *sbr = faad_malloc(sizeof(sbr_info));
     memset(sbr, 0, sizeof(sbr_info));
 
+    /* save id of the parent element */
+    sbr->id_aac = id_aac;
+    sbr->sample_rate = sample_rate;
+
     sbr->bs_freq_scale = 2;
     sbr->bs_alter_scale = 1;
     sbr->bs_noise_bands = 2;
@@ -65,22 +73,11 @@ sbr_info *sbrDecodeInit(uint16_t framelength
     sbr->header_count = 0;
 
 #ifdef DRM
-    sbr->Is_DRM_SBR = 0;
-    if (IsDRM)
-    {
-        sbr->Is_DRM_SBR = 1;
-        sbr->tHFGen = T_HFGEN_DRM;
-        sbr->tHFAdj = T_HFADJ_DRM;
-
-        /* "offset" is different in DRM */
-        sbr->bs_samplerate_mode = 0;
-    } else
+    sbr->Is_DRM_SBR = IsDRM;
 #endif
-    {
-        sbr->bs_samplerate_mode = 1;
-        sbr->tHFGen = T_HFGEN;
-        sbr->tHFAdj = T_HFADJ;
-    }
+    sbr->bs_samplerate_mode = 1;
+    sbr->tHFGen = T_HFGEN;
+    sbr->tHFAdj = T_HFADJ;
 
     /* force sbr reset */
     sbr->bs_start_freq_prev = -1;
@@ -105,30 +102,25 @@ void sbrDecodeEnd(sbr_info *sbr)
     {
         qmfa_end(sbr->qmfa[0]);
         qmfs_end(sbr->qmfs[0]);
-        if (sbr->id_aac == ID_CPE)
+        if (sbr->qmfs[1] != NULL)
         {
             qmfa_end(sbr->qmfa[1]);
             qmfs_end(sbr->qmfs[1]);
         }
 
-        if (sbr->Xcodec[0]) free(sbr->Xcodec[0]);
-        if (sbr->Xsbr[0]) free(sbr->Xsbr[0]);
-        if (sbr->Xcodec[1]) free(sbr->Xcodec[1]);
-        if (sbr->Xsbr[1]) free(sbr->Xsbr[1]);
-
         for (j = 0; j < 5; j++)
         {
-            if (sbr->G_temp_prev[0][j]) free(sbr->G_temp_prev[0][j]);
-            if (sbr->Q_temp_prev[0][j]) free(sbr->Q_temp_prev[0][j]);
-            if (sbr->G_temp_prev[1][j]) free(sbr->G_temp_prev[1][j]);
-            if (sbr->Q_temp_prev[1][j]) free(sbr->Q_temp_prev[1][j]);
+            if (sbr->G_temp_prev[0][j]) faad_free(sbr->G_temp_prev[0][j]);
+            if (sbr->Q_temp_prev[0][j]) faad_free(sbr->Q_temp_prev[0][j]);
+            if (sbr->G_temp_prev[1][j]) faad_free(sbr->G_temp_prev[1][j]);
+            if (sbr->Q_temp_prev[1][j]) faad_free(sbr->Q_temp_prev[1][j]);
         }
 
-        free(sbr);
+        faad_free(sbr);
     }
 }
 
-void sbr_save_prev_data(sbr_info *sbr, uint8_t ch)
+static uint8_t sbr_save_prev_data(sbr_info *sbr, uint8_t ch)
 {
     uint8_t i;
 
@@ -137,6 +129,10 @@ void sbr_save_prev_data(sbr_info *sbr, uint8_t ch)
 
     sbr->L_E_prev[ch] = sbr->L_E[ch];
 
+    /* sbr->L_E[ch] can become 0 on files with bit errors */
+    if (sbr->L_E[ch] <= 0)
+        return 19;
+
     sbr->f_prev[ch] = sbr->f[ch][sbr->L_E[ch] - 1];
     for (i = 0; i < 64; i++)
     {
@@ -154,55 +150,150 @@ void sbr_save_prev_data(sbr_info *sbr, uint8_t ch)
         sbr->prevEnvIsShort[ch] = 0;
     else
         sbr->prevEnvIsShort[ch] = -1;
+
+    return 0;
 }
 
-void sbrDecodeFrame(sbr_info *sbr, real_t *left_channel,
-                    real_t *right_channel, uint8_t id_aac,
-                    uint8_t just_seeked, uint8_t upsample_only)
+static void sbr_process_channel(sbr_info *sbr, real_t *channel_buf, qmf_t X[MAX_NTSR][64],
+                                uint8_t ch, uint8_t dont_process)
 {
     int16_t i, k, l;
 
-    uint8_t dont_process = 0;
-    uint8_t ch, channels, ret;
-    real_t *ch_buf;
+#ifdef SBR_LOW_POWER
+    ALIGN real_t deg[64];
+#endif
+
+    if (sbr->frame == 0)
+    {
+        uint8_t j;
+        sbr->qmfa[ch] = qmfa_init(32);
+        sbr->qmfs[ch] = qmfs_init(64);
+
+        for (j = 0; j < 5; j++)
+        {
+            sbr->G_temp_prev[ch][j] = faad_malloc(64*sizeof(real_t));
+            sbr->Q_temp_prev[ch][j] = faad_malloc(64*sizeof(real_t));
+        }
+
+        memset(sbr->Xsbr[ch], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
+        memset(sbr->Xcodec[ch], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*32 * sizeof(qmf_t));
+    }
+
+    /* subband analysis */
+    if (dont_process)
+        sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xcodec[ch], sbr->tHFGen, 32);
+    else
+        sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], channel_buf, sbr->Xcodec[ch], sbr->tHFGen, sbr->kx);
 
-    qmf_t X[32*64];
+    if (!dont_process)
+    {
+#if 1
+        /* insert high frequencies here */
+        /* hf generation using patching */
+        hf_generation(sbr, sbr->Xcodec[ch], sbr->Xsbr[ch]
 #ifdef SBR_LOW_POWER
-    real_t deg[64];
+            ,deg
+#endif
+            ,ch);
 #endif
 
-    bitfile *ld = NULL;
+#ifdef SBR_LOW_POWER
+        for (l = sbr->t_E[ch][0]; l < sbr->t_E[ch][sbr->L_E[ch]]; l++)
+        {
+            for (k = 0; k < sbr->kx; k++)
+            {
+                QMF_RE(sbr->Xsbr[ch][sbr->tHFAdj + l][k]) = 0;
+            }
+        }
+#endif
 
-    sbr->id_aac = id_aac;
-    channels = (id_aac == ID_SCE) ? 1 : 2;
+#if 1
+        /* hf adjustment */
+        hf_adjustment(sbr, sbr->Xsbr[ch]
+#ifdef SBR_LOW_POWER
+            ,deg
+#endif
+            ,ch);
+#endif
+    }
 
-    if (sbr->data == NULL || sbr->data_size == 0)
+    if ((sbr->just_seeked != 0) || dont_process)
     {
-        ret = 1;
+        for (l = 0; l < sbr->numTimeSlotsRate; l++)
+        {
+            for (k = 0; k < 32; k++)
+            {
+                QMF_RE(X[l][k]) = QMF_RE(sbr->Xcodec[ch][l + sbr->tHFAdj][k]);
+#ifndef SBR_LOW_POWER
+                QMF_IM(X[l][k]) = QMF_IM(sbr->Xcodec[ch][l + sbr->tHFAdj][k]);
+#endif
+            }
+            for (k = 32; k < 64; k++)
+            {
+                QMF_RE(X[l][k]) = 0;
+#ifndef SBR_LOW_POWER
+                QMF_IM(X[l][k]) = 0;
+#endif
+            }
+        }
     } else {
-        ld = (bitfile*)malloc(sizeof(bitfile));
+        for (l = 0; l < sbr->numTimeSlotsRate; l++)
+        {
+            uint8_t xover_band;
 
-    /* initialise and read the bitstream */
-    faad_initbits(ld, sbr->data, sbr->data_size);
+            if (l < sbr->t_E[ch][0])
+                xover_band = sbr->kx_prev;
+            else
+                xover_band = sbr->kx;
 
-    ret = sbr_extension_data(ld, sbr, id_aac);
+            for (k = 0; k < xover_band; k++)
+            {
+                QMF_RE(X[l][k]) = QMF_RE(sbr->Xcodec[ch][l + sbr->tHFAdj][k]);
+#ifndef SBR_LOW_POWER
+                QMF_IM(X[l][k]) = QMF_IM(sbr->Xcodec[ch][l + sbr->tHFAdj][k]);
+#endif
+            }
+            for (k = xover_band; k < 64; k++)
+            {
+                QMF_RE(X[l][k]) = QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
+#ifndef SBR_LOW_POWER
+                QMF_IM(X[l][k]) = QMF_IM(sbr->Xsbr[ch][l + sbr->tHFAdj][k]);
+#endif
+            }
+#ifdef SBR_LOW_POWER
+            QMF_RE(X[l][xover_band - 1]) += QMF_RE(sbr->Xsbr[ch][l + sbr->tHFAdj][xover_band - 1]);
+#endif
+        }
+    }
 
-    ret = ld->error ? ld->error : ret;
-    faad_endbits(ld);
-    if (ld) free(ld);
-    ld = NULL;
+    for (i = 0; i < sbr->tHFGen; i++)
+    {
+        memmove(sbr->Xcodec[ch][i], sbr->Xcodec[ch][i+sbr->numTimeSlotsRate], 32 * sizeof(qmf_t));
+        memmove(sbr->Xsbr[ch][i], sbr->Xsbr[ch][i+sbr->numTimeSlotsRate], 64 * sizeof(qmf_t));
     }
+}
 
-    if (sbr->data) free(sbr->data);
-    sbr->data = NULL;
+uint8_t sbrDecodeCoupleFrame(sbr_info *sbr, real_t *left_chan, real_t *right_chan,
+                             const uint8_t just_seeked, const uint8_t upsample_only)
+{
+    uint8_t dont_process = 0;
+    uint8_t ret = 0;
+    ALIGN qmf_t X[MAX_NTSR][64];
+
+    if (sbr == NULL)
+        return 20;
 
-    if (ret || (sbr->header_count == 0))
+    /* case can occur due to bit errors */
+    if (sbr->id_aac != ID_CPE)
+        return 21;
+
+    if (sbr->ret || (sbr->header_count == 0))
     {
         /* don't process just upsample */
         dont_process = 1;
 
         /* Re-activate reset for next frame */
-        if (ret && sbr->Reset)
+        if (sbr->ret && sbr->Reset)
             sbr->bs_start_freq_prev = -1;
     }
 
@@ -213,183 +304,176 @@ void sbrDecodeFrame(sbr_info *sbr, real_t *left_channel,
         sbr->just_seeked = 0;
     }
 
-    for (ch = 0; ch < channels; ch++)
+    sbr_process_channel(sbr, left_chan, X, 0, dont_process);
+    /* subband synthesis */
+#ifndef USE_SSE
+    sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, left_chan);
+#else
+    sbr->qmfs[ch]->qmf_func(sbr, sbr->qmfs[0], X, left_chan);
+#endif
+
+    sbr_process_channel(sbr, right_chan, X, 1, dont_process);
+    /* subband synthesis */
+#ifndef USE_SSE
+    sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X, right_chan);
+#else
+    sbr->qmfs[ch]->qmf_func(sbr, sbr->qmfs[1], X, right_chan);
+#endif
+
+    if (sbr->bs_header_flag)
+        sbr->just_seeked = 0;
+
+    if (sbr->header_count != 0 && sbr->ret == 0)
     {
-        if (sbr->frame == 0)
-        {
-            uint8_t j;
-            sbr->qmfa[ch] = qmfa_init(32);
-            sbr->qmfs[ch] = qmfs_init(64);
-            
-            for (j = 0; j < 5; j++)
-            {
-                sbr->G_temp_prev[ch][j] = malloc(64*sizeof(real_t));
-                sbr->Q_temp_prev[ch][j] = malloc(64*sizeof(real_t));
-            }
+        ret = sbr_save_prev_data(sbr, 0);
+        if (ret) return ret;
+        ret = sbr_save_prev_data(sbr, 1);
+        if (ret) return ret;
+    }
 
-            sbr->Xsbr[ch] = malloc((sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
-            sbr->Xcodec[ch] = malloc((sbr->numTimeSlotsRate+sbr->tHFGen)*32 * sizeof(qmf_t));
+    sbr->frame++;
 
-            memset(sbr->Xsbr[ch], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*64 * sizeof(qmf_t));
-            memset(sbr->Xcodec[ch], 0, (sbr->numTimeSlotsRate+sbr->tHFGen)*32 * sizeof(qmf_t));
-        }
+    return 0;
+}
 
-        if (ch == 0)
-            ch_buf = left_channel;
-        else
-            ch_buf = right_channel;
+uint8_t sbrDecodeSingleFrame(sbr_info *sbr, real_t *channel,
+                             const uint8_t just_seeked, const uint8_t upsample_only)
+{
+    uint8_t dont_process = 0;
+    uint8_t ret = 0;
+    ALIGN qmf_t X[MAX_NTSR][64];
 
-#if 0
-        for (i = 0; i < sbr->tHFAdj; i++)
-        {
-            int8_t j;
-            for (j = sbr->kx_prev; j < sbr->kx; j++)
-            {
-                QMF_RE(sbr->Xcodec[ch][i*32 + j]) = 0;
-#ifndef SBR_LOW_POWER
-                QMF_IM(sbr->Xcodec[ch][i*32 + j]) = 0;
-#endif
-            }
-        }
-#endif
+    if (sbr == NULL)
+        return 20;
 
-        /* subband analysis */
-        if (dont_process)
-            sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], ch_buf, sbr->Xcodec[ch], sbr->tHFGen, 32);
-        else
-            sbr_qmf_analysis_32(sbr, sbr->qmfa[ch], ch_buf, sbr->Xcodec[ch], sbr->tHFGen, sbr->kx);
+    /* case can occur due to bit errors */
+    if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE)
+        return 21;
 
-        if (!dont_process)
-        {
-            /* insert high frequencies here */
-            /* hf generation using patching */
-            hf_generation(sbr, sbr->Xcodec[ch], sbr->Xsbr[ch]
-#ifdef SBR_LOW_POWER
-                ,deg
-#endif
-                ,ch);
+    if (sbr->ret || (sbr->header_count == 0))
+    {
+        /* don't process just upsample */
+        dont_process = 1;
 
-#ifdef SBR_LOW_POWER
-            for (l = sbr->t_E[ch][0]; l < sbr->t_E[ch][sbr->L_E[ch]]; l++)
-            {
-                for (k = 0; k < sbr->kx; k++)
-                {
-                    QMF_RE(sbr->Xsbr[ch][(sbr->tHFAdj + l)*64 + k]) = 0;
-                }
-            }
-#endif
+        /* Re-activate reset for next frame */
+        if (sbr->ret && sbr->Reset)
+            sbr->bs_start_freq_prev = -1;
+    }
 
-#if 1
-            /* hf adjustment */
-            hf_adjustment(sbr, sbr->Xsbr[ch]
-#ifdef SBR_LOW_POWER
-                ,deg
-#endif
-                ,ch);
-#endif
-        }
+    if (just_seeked)
+    {
+        sbr->just_seeked = 1;
+    } else {
+        sbr->just_seeked = 0;
+    }
 
-        if ((sbr->just_seeked != 0) || dont_process)
-        {
-            for (l = 0; l < sbr->numTimeSlotsRate; l++)
-            {
-                for (k = 0; k < 32; k++)
-                {
-                    QMF_RE(X[l * 64 + k]) = QMF_RE(sbr->Xcodec[ch][(l + sbr->tHFAdj)*32 + k]);
-#ifndef SBR_LOW_POWER
-                    QMF_IM(X[l * 64 + k]) = QMF_IM(sbr->Xcodec[ch][(l + sbr->tHFAdj)*32 + k]);
-#endif
-                }
-                for (k = 32; k < 64; k++)
-                {
-                    QMF_RE(X[l * 64 + k]) = 0;
-#ifndef SBR_LOW_POWER
-                    QMF_IM(X[l * 64 + k]) = 0;
+    sbr_process_channel(sbr, channel, X, 0, dont_process);
+    /* subband synthesis */
+#ifndef USE_SSE
+    sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X, channel);
+#else
+    sbr->qmfs[ch]->qmf_func(sbr, sbr->qmfs[0], X, channel);
 #endif
-                }
-            }
-        } else {
-            for (l = 0; l < sbr->numTimeSlotsRate; l++)
-            {
-                uint8_t xover_band;
 
-                if (l < sbr->t_E[ch][0])
-                    xover_band = sbr->kx_prev;
-                else
-                    xover_band = sbr->kx;
+    if (sbr->bs_header_flag)
+        sbr->just_seeked = 0;
 
-#ifdef DRM
-				if (sbr->Is_DRM_SBR)
-					xover_band = sbr->kx;
-#endif
+    if (sbr->header_count != 0 && sbr->ret == 0)
+    {
+        ret = sbr_save_prev_data(sbr, 0);
+        if (ret) return ret;
+    }
 
-                for (k = 0; k < xover_band; k++)
-                {
-                    QMF_RE(X[l * 64 + k]) = QMF_RE(sbr->Xcodec[ch][(l + sbr->tHFAdj)*32 + k]);
-#ifndef SBR_LOW_POWER
-                    QMF_IM(X[l * 64 + k]) = QMF_IM(sbr->Xcodec[ch][(l + sbr->tHFAdj)*32 + k]);
-#endif
-                }
-                for (k = xover_band; k < 64; k++)
-                {
-                    QMF_RE(X[l * 64 + k]) = QMF_RE(sbr->Xsbr[ch][(l + sbr->tHFAdj)*64 + k]);
-#ifndef SBR_LOW_POWER
-                    QMF_IM(X[l * 64 + k]) = QMF_IM(sbr->Xsbr[ch][(l + sbr->tHFAdj)*64 + k]);
-#endif
-                }
-#ifdef SBR_LOW_POWER
-                QMF_RE(X[l * 64 + xover_band - 1]) += QMF_RE(sbr->Xsbr[ch][(l + sbr->tHFAdj)*64 + xover_band - 1]);
-#endif
-#ifdef DRM
-                if (sbr->Is_DRM_SBR)
-                {
-                    for (k = xover_band; k < xover_band + 4; k++)
-                    {
-                        QMF_RE(X[l * 64 + k]) += QMF_RE(sbr->Xcodec[ch][(l + sbr->tHFAdj)*32 + k]);
-                        QMF_IM(X[l * 64 + k]) += QMF_IM(sbr->Xcodec[ch][(l + sbr->tHFAdj)*32 + k]);
-                    }
-                }
-#endif
-            }
-        }
+    sbr->frame++;
 
-        /* subband synthesis */
-        sbr_qmf_synthesis_64(sbr, sbr->qmfs[ch], (const complex_t*)X, ch_buf);
+    return 0;
+}
 
-        for (i = 0; i < 32; i++)
-        {
-            int8_t j;
-            for (j = 0; j < sbr->tHFGen; j++)
-            {
-                QMF_RE(sbr->Xcodec[ch][j*32 + i]) = QMF_RE(sbr->Xcodec[ch][(j+sbr->numTimeSlotsRate)*32 + i]);
-#ifndef SBR_LOW_POWER
-                QMF_IM(sbr->Xcodec[ch][j*32 + i]) = QMF_IM(sbr->Xcodec[ch][(j+sbr->numTimeSlotsRate)*32 + i]);
-#endif
-            }
-        }
-        for (i = 0; i < 64; i++)
+static void ps_dummy_function(qmf_t X_mono[MAX_NTSR][64],
+                              qmf_t X_left[MAX_NTSR][64], qmf_t X_right[MAX_NTSR][64])
+{
+    uint8_t i, j;
+
+    for (i = 0; i < MAX_NTSR; i++)
+    {
+        for (j = 0; j < 64; j++)
         {
-            int8_t j;
-            for (j = 0; j < sbr->tHFGen; j++)
-            {
-                QMF_RE(sbr->Xsbr[ch][j*64 + i]) = QMF_RE(sbr->Xsbr[ch][(j+sbr->numTimeSlotsRate)*64 + i]);
+            QMF_RE(X_left[i][j]) = QMF_RE(X_mono[i][j]);
+            QMF_RE(X_right[i][j]) = QMF_RE(X_mono[i][j]);
 #ifndef SBR_LOW_POWER
-                QMF_IM(sbr->Xsbr[ch][j*64 + i]) = QMF_IM(sbr->Xsbr[ch][(j+sbr->numTimeSlotsRate)*64 + i]);
+            QMF_IM(X_left[i][j]) = QMF_IM(X_mono[i][j]);
+            QMF_IM(X_right[i][j]) = QMF_IM(X_mono[i][j]);
 #endif
-            }
         }
     }
+}
+
+#if (defined(PS_DEC) || defined(DRM_PS))
+uint8_t sbrDecodeSingleFramePS(sbr_info *sbr, real_t *left_channel, real_t *right_channel,
+                               const uint8_t just_seeked, const uint8_t upsample_only)
+{
+    uint8_t dont_process = 0;
+    uint8_t ret = 0;
+    ALIGN qmf_t X_mono[MAX_NTSR][64];
+    ALIGN qmf_t X_left[MAX_NTSR][64];
+    ALIGN qmf_t X_right[MAX_NTSR][64];
+
+    if (sbr == NULL)
+        return 20;
+
+    /* case can occur due to bit errors */
+    if (sbr->id_aac != ID_SCE && sbr->id_aac != ID_LFE)
+        return 21;
+
+    if (sbr->ret || (sbr->header_count == 0))
+    {
+        /* don't process just upsample */
+        dont_process = 1;
+
+        /* Re-activate reset for next frame */
+        if (sbr->ret && sbr->Reset)
+            sbr->bs_start_freq_prev = -1;
+    }
+
+    if (just_seeked)
+    {
+        sbr->just_seeked = 1;
+    } else {
+        sbr->just_seeked = 0;
+    }
+
+    if (sbr->frame == 0)
+    {
+        sbr->qmfs[1] = qmfs_init(64);
+    }
+
+    sbr_process_channel(sbr, left_channel, X_mono, 0, dont_process);
+
+    /* perform parametric stereo */
+    ps_dummy_function(X_mono, X_left, X_right);
+
+    /* subband synthesis */
+#ifndef USE_SSE
+    sbr_qmf_synthesis_64(sbr, sbr->qmfs[0], X_left, left_channel);
+    sbr_qmf_synthesis_64(sbr, sbr->qmfs[1], X_right, right_channel);
+#else
+    sbr->qmfs[ch]->qmf_func(sbr, sbr->qmfs[0], X_left, left_channel);
+    sbr->qmfs[ch]->qmf_func(sbr, sbr->qmfs[1], X_right, right_channel);
+#endif
 
     if (sbr->bs_header_flag)
         sbr->just_seeked = 0;
 
-    if (sbr->header_count != 0)
+    if (sbr->header_count != 0 && sbr->ret == 0)
     {
-        for (ch = 0; ch < channels; ch++)
-            sbr_save_prev_data(sbr, ch);
+        ret = sbr_save_prev_data(sbr, 0);
+        if (ret) return ret;
     }
 
     sbr->frame++;
+
+    return 0;
 }
+#endif
 
 #endif