/* ------------------------------------------------------------------
 * Copyright (C) 2008 PacketVideo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 * -------------------------------------------------------------------
 */
/*

  Pathname: ./src/trans4m_freq_2_time_fxp.c
  Function: trans4m_freq_2_time_fxp

      Date: 4/02/2001

------------------------------------------------------------------------------
 REVISION HISTORY

 Description:
    changed to decrement loop
    change wnd_shape from structure to passing parameters
    modified window tables from UInt to UInt16 to assure proper operation
    without dubious typecast
    changed logic to hit most common states first.
    modified Time_data from Int to Int32 to hold
    possible overflow before saturation process.

 Description:
    Increase processing on some loop by using more pointers
    changed interface to avoid passing a pointer for wnd_shape_prev_bk, this
    element is not change in this function because of this function use
    in the LTP module

 Description:
    Added rounding to multiplication

 Description:
    Update input description and eliminate unneeded comments

 Description:
    LONG_START_WINDOW was using SHORT_WINDOW instead of
    HALF_SHORT_WINDOW, causing a for loop to exceed its count

 Description:
    Modified structure of code so exp is not tested before it
    is initialized.  Also, new structure avoids double-testing
    of exp_freq = ALL_ZEROS_BUFFER.

 Description:
    The result of a shift is undefined if the right operand is greater than
    or equal to the number of bits in the left expression's type
    To avoid undefined shift by 32, a check of the shift has been
    added, so the function proceeds only when the exponent is less
    than 32. By design the shift up is related to the global gain,
    and controlled by the encoder, so saturation is not allowed.
    In both short and long window, processing is skip if an all zero
    input buffer or excessive down shift is detected.

 Description:
    Changes according to code review comments. Also, modified if-else
    structure so the imdct_fxp is not called with an all zero input buffer

 Description:
    Replaced function buffer_normalization by buffer_adaptation, to ease
    use of 16 bits. Function buffer_normalization becomes  obsolete.

 Description:
    Modified call to imdct_fxp to reflect extended precision use. Added
    routine buffer_adaptation to extract 16 MSB and keep highest.
    precision. Modify casting to ensure proper operations for different
    platforms

 Description:
    Eliminate double access to memory by loading data directly to the
    time array. Also reduced cycle count and added precision by combining
    downshifting in only one operation. Added adaptive rounding factor.
    Change exponent threshold when operations are waived. It is use to be 32
    but by combining downshifting, this new threshold is now 16. This may
    avoid unneeded calculations for extremely small numbers.

 Description:
    Per review comments:
        - Added comments to clarify buffer_adaptation function
        - Deleted  reference to include file "buffer_normalization.h"
        - Modified IF-ELSE so long_windows case is considered first
        - Eliminated extra IF when computing the rounding, so when exp ==0
          less cycles are used shifting than in an extra if-else
        - Corrected negative shift when computing rounding factor
        - Added condition when exp > 16 (for long windows)

 Description:
    Modified IF-ELSE structure so now ALL_ZEROS_BUFFER condition is share
    with exp > 16 condition. This avoid code duplication for both cases.

 Description:
        - Modified function interface to add output_buffer
        - Eliminated the 32 bit version of the current output, calculations
          are placed directly in output_buffer. In this way the buffer
          Time_data needs only to be 1024 Int32, instead of 2048 (per channel).
          Also, added the limit macro inside the function (this reduces access
          to memory).
        - Updated Pseudo - Code

 Description:
    Per review comments:
          Corrected line sizes and mispelling,  added comments and swap
          order or switch statement for ONLY_LONG_SEQUENCE.

 Description:
    Eliminated adaptive rounding due to potential saturation.

 Description:
    Eliminated use of buffer adaptation by shifting this functionality inside
    the imdct_fxp() routine. Also modified the call to imdct_fxp to accomodate
    new function interface.
    Modified macro limit() to save cycles when testing the most common case:
    no saturation.

 Description:
    Changed new function interface for imdct_fxp().

 Description:
    Replaced for-loop with memset and memcopy.

 Description:

------------------------------------------------------------------------------
 INPUT AND OUTPUT DEFINITIONS

 Inputs:
    Frequency_data    =  vector with spectral information, size 2048
                         type Int32

    Time_data         =  buffer with data from previous Frequency to Time
                         conversion, used for overlap and add, size 1024
                         type Int32

    Output_buffer     =  place holder for current output,  size 1024
                         type Int16

    wnd_seq           =  window sequence
                         type WINDOW_SEQUENCE

    wnd_shape_prev_bk =  previous window shape type
                         type Int

    wnd_shape_this_bk =  current window shape type
                         type Int

    Q_format          =  Q format for the input frequency data
                         type Int

    freq_2_time_buffer[] =  scratch memory for computing FFT
                         type Int32


 Local Stores/Buffers/Pointers Needed:
    None

 Global Stores/Buffers/Pointers Needed:
    None

 Outputs:
    None

 Pointers and Buffers Modified:
    Output_buffer
    Time_data
    Frequency_data
    pWnd_shape_prev_bk

 Local Stores Modified:
    None

 Global Stores Modified:
    None

------------------------------------------------------------------------------
 FUNCTION DESCRIPTION

The time/frequency representation of the signal is mapped onto the time
domain by feeding it into the filterbank module. This module consists of
an inverse modified discrete cosine transform (IMDCT), and a window and an
overlap-add function. In order to adapt the time/frequency resolution of the
filterbank to the characteristics of the input signal, a block switching tool
is also adopted. N represents the window length, where N is a function of the
window_sequence. For each channel, the N/2 time-frequency values are
transformed into the N time domain values via the IMDCT. After applying the
window function, for each channel, the first half of the sequence is added to
the second half of the previous block windowed sequence to reconstruct the
output samples for each channel outi,n.

The adaptation of the time-frequency resolution of the filterbank to the
characteristics of the input signal is done by shifting between transforms
whose input lengths are either 2048 or 256 samples. By enabling the block
switching tool, the following transitions are meaningful:

from ONLY_LONG_SEQUENCE to   { LONG_START_SEQUENCE
                               ONLY_LONG_SEQUENCE

from LONG_START_SEQUENCE to  { LONG_STOP_SEQUENCE
                               EIGHT_SHORT_SEQUENCE

from LONG_STOP_SEQUENCE to   { LONG_START_SEQUENCE
                               ONLY_LONG_SEQUENCE

from EIGHT_SHORT_SEQUENCE to { LONG_STOP_SEQUENCE
                               EIGHT_SHORT_SEQUENCE

Window shape decisions are made by the encoder on a frame-by-frame-basis.
The window selected is applicable to the second half of the window function
only, since the first half is constrained to use the appropriate window
shape from the preceding frame.
The 2048 time-domain values x'(i)(n), (i window, n sample) to be windowed are
the last 1024 values of the previous window_sequence concatenated with 1024
values of the current block. The formula below shows this fact:

                     |  x(i-1)(n+1024)      for    0 < n < 1024
            x'(i)(n) {
                     |  x(i)(n)             for 1024 < n < 2048


Buffer Time_data data from previous Frequency to Time conversion, used
for overlap and add

Once the window shape is selected, the window_shape syntax element is
initialized. Together with the chosen window_sequence all information needed
for windowing exist.
With the window halves described below all window_sequences can be assembled.
For window_shape == 1, the window coefficients are given by the Kaiser -
Bessel derived (KBD) window.
Otherwise, for window_shape == 0, a sine window is employed.

The window length N can be 2048 or 256 for the KBD and the sine window.
All four window_sequences explained below have a total length of 2048
samples.
For all kinds of window_sequences the window_shape of the left half of
the first transform window is determined by the window shape of the previous
block.

In the case of EIGHT_SHORT_SEQUENCE the processing is done in-place and
in descendent order to avoid using extra memory.
The ordering is as follows:

                                            Pn: Previous data for window n
                                            Cn:  Current data for window n


                                                128 freq.
                                                 samples
                  FREQ                          ++++++
IN                         ===========================
                                                    \
                                                      \
                                                        ->  256 time
                                                             samples

                                                           P8    C8
           8                                            #######++++++
                                                    P7     C7
           7                                     #######++++++
           :                                :
           :                                :
                            P2    C2
           2             #######++++++
                     P1    C1
           1      #######++++++
                                                                          TIME
OUT          ==============================================================

------------------------------------------------------------------------------
 REQUIREMENTS

    This module shall implement a scheme to switch between window types

------------------------------------------------------------------------------
 REFERENCES

    [1] ISO 14496-3:1999, pag 111

------------------------------------------------------------------------------
 PSEUDO-CODE


    IF ( wnd_seq == EIGHT_SHORT_SEQUENCE)
    THEN

        FOR ( i=0; i<LONG_WINDOW; i++)
            Time_data[LONG_WINDOW + i] = 0;
        ENDFOR

        FOR ( wnd=NUM_SHORT_WINDOWS-1; wnd>=0; wnd--)

            pFreqInfo = &Frequency_data[ wnd*SHORT_WINDOW];

            CALL IMDCT( pFreqInfo, SHORT_BLOCK1);
            MODIFYING(pFreqInfo)


            IF (wnd == 0)
            THEN
                pShort_Window_1 = &Short_Window[wnd_shape_prev_bk][0];
            ELSE
                pShort_Window_1 = &Short_Window[wnd_shape_this_bk][0];
            ENDIF

            pShort_Window_2   =
                    &Short_Window[wnd_shape->this_bk][SHORT_WINDOW_m_1];

            FOR( i=0, j=SHORT_WINDOW; i<SHORT_WINDOW; i++, j--)
                pFreqInfo[             i]  *= pShort_Window_1[i];
                pFreqInfo[SHORT_WINDOW+i]  *= pShort_Window_2[j];
            ENDFOR


            FOR( i=0; i<SHORT_BLOCK1; i++)
                Time_data[W_L_STOP_1 + SHORT_WINDOW*wnd + i] += pFreqInfo[i];
            ENDFOR

        ENDFOR

        FOR ( i=0; i<LONG_WINDOW; i++)
            temp              = Time_data[i];
            Output_buffer[i]  = Time_data[i];
            Time_data[i]      = temp;
        ENDFOR
    ELSE

        CALL IMDCT( Frequency_data, LONG_BLOCK1)
            MODIFYING(Frequency_data)

        SWITCH ( wnd_seq)

            CASE ( ONLY_LONG_SEQUENCE)

                pLong_Window_1 = &Long_Window[wnd_shape_prev_bk][0];
                pLong_Window_2 =
                        &Long_Window[wnd_shape_this_bk][LONG_WINDOW_m_1];

                FOR (i=0; i<LONG_WINDOW; i++)
                    Frequency_data[            i] *= *pLong_Window_1++;
                    Frequency_data[LONG_WINDOW+i] *= *pLong_Window_2--;
                ENDFOR

                BREAK

            CASE ( LONG_START_SEQUENCE)

                pLong_Window_1 = &Long_Window[wnd_shape_prev_bk][0];

                FOR ( i=0; i<LONG_WINDOW; i++)
                    Frequency_data[ i] *= *pLong_Window_1++;
                ENDFOR

                pShort_Window_1   =
                        &Short_Window[wnd_shape_this_bk][SHORT_WINDOW_m_1];

                FOR ( i=0; i<SHORT_WINDOW; i++)
                    Frequency_data[W_L_START_1 + i] *= *pShort_Window_1--;
                ENDFOR

                FOR ( i=W_L_START_2; i<LONG_BLOCK1; i++)
                    Frequency_data[W_L_START_2 + i] = 0;
                ENDFOR

                BREAK


            CASE ( LONG_STOP_SEQUENCE )

                FOR ( i=0; i<W_L_STOP_1; i++)
                    Frequency_data[ i] = 0;
                ENDFOR

                pShort_Window_1   = &Short_Window[wnd_shape_prev_bk][0];

                FOR ( i=0; i<SHORT_WINDOW; i++)
                    Frequency_data[W_L_STOP_1+ i] *= *pShort_Window_1++;
                ENDFOR

                pLong_Window_1 =
                        &Long_Window[wnd_shape_this_bk][LONG_WINDOW_m_1];

                FOR ( i=0; i<LONG_WINDOW; i++)
                    Frequency_data[LONG_WINDOW + i]  *=  *pLong_Window_1--;
                ENDFOR

                BREAK

        }


        FOR ( i=0; i<LONG_WINDOW; i++)
            Output_buffer[i]  = Frequency_data[i]  + Time_data[i];
            Time_data[i] = Frequency_data[LONG_WINDOW+i];
        ENDFOR

    }

    ENDIF


------------------------------------------------------------------------------
 RESOURCES USED
   When the code is written for a specific target processor the
     the resources used should be documented below.

 STACK USAGE: [stack count for this module] + [variable to represent
          stack usage for each subroutine called]

     where: [stack usage variable] = stack usage for [subroutine
         name] (see [filename].ext)

 DATA MEMORY USED: x words

 PROGRAM MEMORY USED: x words

 CLOCK CYCLES: [cycle count equation for this module] + [variable
           used to represent cycle count for each subroutine
           called]

     where: [cycle count variable] = cycle count for [subroutine
        name] (see [filename].ext)

------------------------------------------------------------------------------
*/


/*----------------------------------------------------------------------------
; INCLUDES
----------------------------------------------------------------------------*/

#include "pv_audio_type_defs.h"
#include "aac_mem_funcs.h"
#include "window_block_fxp.h"
#include "imdct_fxp.h"

#include "fxp_mul32.h"


/*----------------------------------------------------------------------------
; MACROS
; limit(x) saturates any number that exceeds a 16-bit representation into a
; 16 bit number.
----------------------------------------------------------------------------*/

#define  ROUNDING_SCALED     (ROUNDING<<(16 - SCALING))


#if defined(_ARM)


__inline Int16 sat(Int32 y)
{
    Int32 x;
    Int32 z;
    __asm
    {
        mov x, ROUNDING_SCALED
        mov y, y, lsl #(15-SCALING)
        qdadd z, x, y
        mov y, z, lsr #16
    }
    return((Int16)y);
}

#define  limiter( y, x)   y = sat(x);


#elif defined(_ARM_GCC)


__inline Int16 sat(Int32 y)
{
    register Int32 x;
    register Int32 ra = (Int32)y;
    register Int32 z = ROUNDING_SCALED;


    asm volatile(
        "mov %0, %1, lsl #5\n\t"    // (15-SCALING) assembler does not take symbols
        "qdadd %0, %2, %0\n\t"
        "mov %0, %0, lsr #16"
    : "=&r*i"(x)
                : "r"(ra),
                "r"(z));

    return ((Int16)x);
}

#define  limiter( y, x)   y = sat(x);


#else

#define  limiter( y, x)   z = ((x + ROUNDING )>>SCALING); \
                          if ((z>>15) != (z>>31))         \
                          {                                    \
                              z = (z >> 31) ^ INT16_MAX;       \
                          } \
                          y = (Int16)(z);

#endif


/*----------------------------------------------------------------------------
; DEFINES
; Include all pre-processor statements here. Include conditional
; compile variables also.
----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------
; LOCAL FUNCTION DEFINITIONS
; Function Prototype declaration
----------------------------------------------------------------------------*/


/*----------------------------------------------------------------------------
; LOCAL VARIABLE DEFINITIONS
; Variable declaration - defined here and used outside this module
----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------
; EXTERNAL FUNCTION REFERENCES
; Declare functions defined elsewhere and referenced in this module
----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------
; EXTERNAL VARIABLES REFERENCES
; Declare variables used in this module but defined elsewhere
----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------
; EXTERNAL GLOBAL STORE/BUFFER/POINTER REFERENCES
; Declare variables used in this module but defined elsewhere
----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------
; FUNCTION CODE
----------------------------------------------------------------------------*/

#ifdef AAC_PLUS


void trans4m_freq_2_time_fxp_1(
    Int32               Frequency_data[],
    Int32               Time_data[],
    Int16               Output_buffer[],
    WINDOW_SEQUENCE     wnd_seq,
    Int                 wnd_shape_prev_bk,
    Int                 wnd_shape_this_bk,
    Int                 Q_format,
    Int32               abs_max_per_window[],
    Int32               freq_2_time_buffer[])

{
    Int exp;
    Int shift;

    Int  i;
    Int  wnd;
#if !(defined( _ARM_GCC)||(_ARM))
    Int32 z;
#endif

    Int16 *pFreqInfo;
    Int32 temp;
    Int32 test;

    Int16 *pFreq_2_Time_data_1;
    Int16 *pFreq_2_Time_data_2;

    const Int16 *pLong_Window_1;
    const Int16 *pLong_Window_2;
    const Int16 *pShort_Window_1;
    const Int16 *pShort_Window_2;

    Int32 *pOverlap_and_Add_Buffer_1;
    Int32 *pOverlap_and_Add_Buffer_2;

    Int16  *pOutput_buffer;
    Int16  *pOutput_buffer_2;

    const Int16 * Long_Window_fxp[NUM_WINDOW_SHAPES];
    const Int16 * Short_Window_fxp[NUM_WINDOW_SHAPES];

    Long_Window_fxp[0] = Long_Window_sine_fxp;
    Long_Window_fxp[1] = Long_Window_KBD_fxp;
    Short_Window_fxp[0] = Short_Window_sine_fxp;
    Short_Window_fxp[1] = Short_Window_KBD_fxp;


    if (wnd_seq != EIGHT_SHORT_SEQUENCE)
    {

        pFreqInfo = (Int16 *)Frequency_data;


        exp = imdct_fxp(
                  (Int32 *)pFreqInfo,
                  freq_2_time_buffer,
                  LONG_BLOCK1,
                  Q_format,
                  abs_max_per_window[0]);


        /*
         *  The C Programming Language, Second Edition, Kernighan & Ritchie,
         *  page 206.
         *  "The result [of a shift] is undefined if the right operand is
         *  negative, or greater than or equal to the number of bits in the
         *  left expression's type"
         *   => avoid shift by 32 or 16
         */

        if (exp < 16)
        {

            pFreq_2_Time_data_1 = pFreqInfo;

            switch (wnd_seq)
            {

                case ONLY_LONG_SEQUENCE:
                default:

                    pOutput_buffer = Output_buffer;

                    pOverlap_and_Add_Buffer_1 = Time_data;

                    {
                        const Int16 *pLong_Window_2 = &Long_Window_fxp[wnd_shape_this_bk][LONG_WINDOW_m_1];

                        Int32 * pFreq2T = (Int32 *)pFreqInfo;
                        Int32 * win = (Int32 *) & Long_Window_fxp[wnd_shape_prev_bk][0];
                        Int shift = exp + 15 - SCALING;


                        Int32 * pFreq2T_2 = &pFreq2T[HALF_LONG_WINDOW];


                        for (i = HALF_LONG_WINDOW; i != 0; i--)
                        {
                            Int16 win1, win2;
                            Int32  temp2, test2;

                            Int32  winx;

                            temp2 = *(pFreq2T++);
                            winx = *(win++);

                            test  = *(pOverlap_and_Add_Buffer_1++);
                            test2 = *(pOverlap_and_Add_Buffer_1--);
                            temp  =   fxp_mul_16_by_16bb(temp2, winx) >> shift;
                            temp2 =   fxp_mul_16_by_16tt(temp2, winx) >> shift;
                            limiter(*(pOutput_buffer++), (temp + test));
                            limiter(*(pOutput_buffer++), (temp2 + test2));

                            temp2 = *(pFreq2T_2++);

                            win1  = *(pLong_Window_2--);
                            win2  = *(pLong_Window_2--);
                            temp  = fxp_mul_16_by_16bb(temp2, win1) >> shift;
                            test2 = fxp_mul_16_by_16tb(temp2, win2) >> shift;
                            *(pOverlap_and_Add_Buffer_1++) = temp;
                            *(pOverlap_and_Add_Buffer_1++) = test2;

                        }
                    }

                    break;

                case LONG_START_SEQUENCE:


                    pFreq_2_Time_data_2 =
                        &pFreq_2_Time_data_1[ HALF_LONG_WINDOW];

                    pLong_Window_1 = &Long_Window_fxp[wnd_shape_prev_bk][0];
                    pLong_Window_2 = &pLong_Window_1[ HALF_LONG_WINDOW];

                    pOverlap_and_Add_Buffer_1 = &Time_data[0];
                    pOverlap_and_Add_Buffer_2 = &Time_data[HALF_LONG_WINDOW];

                    pOutput_buffer   = Output_buffer;
                    pOutput_buffer_2 = pOutput_buffer + HALF_LONG_WINDOW;


                    shift = exp + 15 - SCALING;

                    for (i = HALF_LONG_WINDOW; i != 0; i--)
                    {

                        Int16 win1, win2;
                        Int16  dat1, dat2;
                        Int32  test1, test2;

                        dat1   = *(pFreq_2_Time_data_1++);
                        win1   = *(pLong_Window_1++);
                        test1  = *(pOverlap_and_Add_Buffer_1++);

                        dat2  =  *(pFreq_2_Time_data_2++);
                        win2  = *(pLong_Window_2++);
                        test2 = *(pOverlap_and_Add_Buffer_2++);

                        limiter(*(pOutput_buffer++), (test1 + (fxp_mul_16_by_16(dat1, win1) >> shift)));

                        limiter(*(pOutput_buffer_2++), (test2 + (fxp_mul_16_by_16(dat2, win2) >> shift)));

                    }

                    /*
                     *  data unchanged from  LONG_WINDOW to W_L_START_1
                     *  only scaled accordingly
                     */

                    pOverlap_and_Add_Buffer_1 = &Time_data[0];
                    pFreq_2_Time_data_1       = &pFreqInfo[LONG_WINDOW];

                    exp -= SCALING;

                    if (exp >= 0)
                    {

                        for (i = (W_L_START_1 - LONG_WINDOW) >> 1; i != 0; i--)
                        {
                            *(pOverlap_and_Add_Buffer_1++) =
                                *(pFreq_2_Time_data_1++) >> exp;
                            *(pOverlap_and_Add_Buffer_1++) =
                                *(pFreq_2_Time_data_1++) >> exp;

                        }

                    }
                    else if (exp < 0)
                    {

                        Int shift = -exp;
                        for (i = (W_L_START_1 - LONG_WINDOW) >> 1; i != 0 ; i--)
                        {
                            Int32 temp2 = ((Int32) * (pFreq_2_Time_data_1++)) << shift;
                            *(pOverlap_and_Add_Buffer_1++) = temp2;
                            temp2 = ((Int32) * (pFreq_2_Time_data_1++)) << shift;
                            *(pOverlap_and_Add_Buffer_1++) = temp2;
                        }

                    }
                    else
                    {

                        for (i = (W_L_START_1 - LONG_WINDOW) >> 1; i != 0; i--)
                        {
                            *(pOverlap_and_Add_Buffer_1++) =
                                *(pFreq_2_Time_data_1++);
                            *(pOverlap_and_Add_Buffer_1++) =
                                *(pFreq_2_Time_data_1++);

                        }

                    }


                    pFreq_2_Time_data_1  = &pFreqInfo[W_L_START_1];
                    pFreq_2_Time_data_2  =
                        &pFreq_2_Time_data_1[HALF_SHORT_WINDOW];

                    pShort_Window_1   =
                        &Short_Window_fxp[wnd_shape_this_bk][SHORT_WINDOW_m_1];

                    pShort_Window_2   = pShort_Window_1 - HALF_SHORT_WINDOW;

                    pOverlap_and_Add_Buffer_2 = pOverlap_and_Add_Buffer_1 +
                                                HALF_SHORT_WINDOW;


                    for (i = HALF_SHORT_WINDOW; i != 0; i--)
                    {
                        Int16 win1, win2;
                        Int16  dat1, dat2;
                        Int32  temp2;
                        dat1  = (*pFreq_2_Time_data_1++);
                        dat2  = (*pFreq_2_Time_data_2++);
                        win1  = *(pShort_Window_1--);
                        win2  = *(pShort_Window_2--);

                        temp   =   fxp_mul_16_by_16(dat1, win1) >> shift;
                        *(pOverlap_and_Add_Buffer_1++) = temp;

                        temp2 =   fxp_mul_16_by_16(dat2, win2) >> shift;
                        *(pOverlap_and_Add_Buffer_2++) = temp2;


                    }


                    pOverlap_and_Add_Buffer_1 += HALF_SHORT_WINDOW;

                    pv_memset(
                        pOverlap_and_Add_Buffer_1,
                        0,
                        (LONG_BLOCK1 - W_L_START_2)
                        *sizeof(*pOverlap_and_Add_Buffer_1));


                    break;


                case LONG_STOP_SEQUENCE:

                    pOverlap_and_Add_Buffer_1 = &Time_data[ W_L_STOP_2];

                    pOutput_buffer         = &Output_buffer[W_L_STOP_2];

                    pFreq_2_Time_data_1      = &pFreqInfo[W_L_STOP_2];

                    exp -= SCALING; /*  !!!! */

                    if (exp > 0)
                    {
                        Int16 tmp1 = (*(pFreq_2_Time_data_1++) >> exp);
                        temp = *(pOverlap_and_Add_Buffer_1++);

                        for (i = (LONG_WINDOW - W_L_STOP_2); i != 0; i--)
                        {
                            limiter(*(pOutput_buffer++), (temp + tmp1));

                            tmp1 = *(pFreq_2_Time_data_1++) >> exp;
                            temp = *(pOverlap_and_Add_Buffer_1++);

                        }
                    }
                    else if (exp < 0)
                    {
                        shift = -exp;
                        Int32 temp1 = ((Int32) * (pFreq_2_Time_data_1++)) << shift;
                        temp = *(pOverlap_and_Add_Buffer_1++);

                        for (i = (LONG_WINDOW - W_L_STOP_2); i != 0; i--)
                        {
                            limiter(*(pOutput_buffer++), (temp + temp1));

                            temp1 = ((Int32) * (pFreq_2_Time_data_1++)) << shift;
                            temp = *(pOverlap_and_Add_Buffer_1++);

                        }
                    }
                    else
                    {
                        Int16 tmp1 = *(pFreq_2_Time_data_1++);
                        temp = *(pOverlap_and_Add_Buffer_1++);

                        for (i = (LONG_WINDOW - W_L_STOP_2); i != 0; i--)
                        {
                            limiter(*(pOutput_buffer++), (temp + tmp1));

                            tmp1 = *(pFreq_2_Time_data_1++);
                            temp = *(pOverlap_and_Add_Buffer_1++);

                        }
                    }


                    pShort_Window_1 = &Short_Window_fxp[wnd_shape_prev_bk][0];
                    pShort_Window_2 = &pShort_Window_1[HALF_SHORT_WINDOW];

                    pFreq_2_Time_data_1 = &pFreqInfo[W_L_STOP_1];
                    pFreq_2_Time_data_2 =
                        &pFreq_2_Time_data_1[HALF_SHORT_WINDOW];

                    pOverlap_and_Add_Buffer_1 = &Time_data[ W_L_STOP_1];
                    pOverlap_and_Add_Buffer_2 = pOverlap_and_Add_Buffer_1
                                                + HALF_SHORT_WINDOW;

                    pOutput_buffer   = &Output_buffer[W_L_STOP_1];
                    pOutput_buffer_2 = pOutput_buffer + HALF_SHORT_WINDOW;

                    exp += SCALING;  /* +8 back to what it was */

                    shift = exp + 15 - SCALING;


                    for (i = HALF_SHORT_WINDOW; i != 0; i--)
                    {
                        Int16 win1;
                        Int16  dat1;

                        dat1 = *(pFreq_2_Time_data_1++);
                        win1 = *(pShort_Window_1++);
                        temp = *(pOverlap_and_Add_Buffer_1++);

                        test  = fxp_mul_16_by_16(dat1, win1);

                        limiter(*(pOutput_buffer++), (temp + (test >> shift)));

                        dat1 = *(pFreq_2_Time_data_2++);
                        win1 = *(pShort_Window_2++);
                        temp = *(pOverlap_and_Add_Buffer_2++);
                        test =  fxp_mul_16_by_16(dat1, win1);
                        limiter(*(pOutput_buffer_2++), (temp + (test >> shift)));

                    }


                    pFreq_2_Time_data_2 = &pFreqInfo[LONG_WINDOW];

                    pOverlap_and_Add_Buffer_1 = Time_data;

                    pOutput_buffer = Output_buffer;

                    pLong_Window_2   =
                        &Long_Window_fxp[wnd_shape_this_bk][LONG_WINDOW_m_1];


                    /*
                     *  Copy previous time in current buffer, also copy overlap
                     *  and add buffer
                     */

                    for (i = W_L_STOP_1; i != 0; i--)
                    {
                        Int16 win1;
                        Int16 dat1;

                        win1 = *(pLong_Window_2--);
                        dat1 = *pFreq_2_Time_data_2++;

                        limiter(*(pOutput_buffer++), *(pOverlap_and_Add_Buffer_1));


                        temp = fxp_mul_16_by_16(dat1, win1) >> shift;
                        *(pOverlap_and_Add_Buffer_1++) = temp ;

                    }

                    for (i = (LONG_WINDOW - W_L_STOP_1); i != 0; i--)
                    {
                        temp = fxp_mul_16_by_16(*pFreq_2_Time_data_2++, *(pLong_Window_2--)) >> shift;
                        *(pOverlap_and_Add_Buffer_1++) = temp ;
                    }


                    break;


            } /* switch (wnd_seq) */

        }   /*  if (exp < 16)  */

        else
        {
            /* all zeros buffer or excessive down shift */

            /* Overlap and add, setup buffer for next iteration */
            pOverlap_and_Add_Buffer_1 = &Time_data[0];

            pOutput_buffer = Output_buffer;

            temp  = (*pOverlap_and_Add_Buffer_1++);

            for (i = LONG_WINDOW; i != 0; i--)
            {

                limiter(*(pOutput_buffer++), temp);

                temp = (*pOverlap_and_Add_Buffer_1++);

            }

            pv_memset(Time_data, 0, LONG_WINDOW*sizeof(Time_data[0]));


        }

    }
    else
    {

        Int32 *pScrath_mem;
        Int32 *pScrath_mem_entry;
        Int32  *pFrequency_data = Frequency_data;

        Int32 * pOverlap_and_Add_Buffer_1;
        Int32 * pOverlap_and_Add_Buffer_2;
        Int32 * pOverlap_and_Add_Buffer_1x;
        Int32 * pOverlap_and_Add_Buffer_2x;

        /*
         *  Frequency_data is 2*LONG_WINDOW length but only
         *  the first LONG_WINDOW elements are filled in,
         *  then the second part can be used as scratch mem,
         *  then grab data from one window at a time in
         *  reverse order.
         *  The upper LONG_WINDOW Int32 are used to hold the
         *  computed overlap and add, used in the next call to
         *  this function, and also as sctrach memory
         */

        /*
         *  Frequency_data usage for the case EIGHT_SHORT_SEQUENCE

          |<----- Input Freq. data ----->|< Overlap & Add ->| Unused |-Scratch-|
          |                              |  Store for next  |        |  memory |
          |                              |  call            |        |         |
          |                              |                  |        |         |
          |//////////////////////////////|\\\\\\\\\\\\\\\\\\|--------|+++++++++|
          |                              |                  |        |         |
          0                         LONG_WINDOW        LONG_WINDOW   |   2*LONG_WINDOW
                                                            +        |         |
                                                       W_L_STOP_2    |         |
                                                                     |<--   -->|
                                                                      SHORT_WINDOW +
                                                                    HALF_SHORT_WINDOW
          *
          */

        pOverlap_and_Add_Buffer_1  = &pFrequency_data[
                                         LONG_WINDOW + 3*SHORT_WINDOW + HALF_SHORT_WINDOW];

        /*
         *  Initialize to zero, only the firt short window used in overlap
         *  and add
         */
        pv_memset(
            pOverlap_and_Add_Buffer_1,
            0,
            SHORT_WINDOW*sizeof(*pOverlap_and_Add_Buffer_1));

        /*
         *  Showt windows are evaluated in decresing order. Windows from 7
         *  to 0 are break down in four cases: window numbers 7 to 5, 4, 3,
         *  and 2 to 0.
         *  The data from short windows 3 and 4 is situated at the boundary
         *  between the 'overlap and add' buffer and the output buffer.
         */
        for (wnd = NUM_SHORT_WINDOWS - 1; wnd >= NUM_SHORT_WINDOWS / 2 + 1; wnd--)
        {

            pFreqInfo = (Int16 *) & pFrequency_data[ wnd*SHORT_WINDOW];

            exp = imdct_fxp(
                      (Int32 *)pFreqInfo,
                      freq_2_time_buffer,
                      SHORT_BLOCK1,
                      Q_format,
                      abs_max_per_window[wnd]);

            pOverlap_and_Add_Buffer_1 =
                &pFrequency_data[ W_L_STOP_1 + SHORT_WINDOW*wnd];


            pOverlap_and_Add_Buffer_2 =
                pOverlap_and_Add_Buffer_1 + SHORT_WINDOW;

            /*
             *  If all element are zero or if the exponent is bigger than
             *  16 ( it becomes an undefined shift) ->  skip
             */

            if (exp < 16)
            {


                pFreq_2_Time_data_1 = &pFreqInfo[0];
                pFreq_2_Time_data_2 = &pFreqInfo[SHORT_WINDOW];


                /*
                 *  Each of the eight short blocks is windowed separately.
                 *  Window shape decisions are made on a frame-by-frame
                 *  basis.
                 */

                pShort_Window_1 = &Short_Window_fxp[wnd_shape_this_bk][0];

                pShort_Window_2   =
                    &Short_Window_fxp[wnd_shape_this_bk][SHORT_WINDOW_m_1];


                /*
                 * For short windows from 7 to 5
                 *                                      |   =========================
                 *                                      |   |     5     6     7
                 *               _--_  _--_  _--_  _--_ | _-|-_  _--_  _--_  _--_
                 *              /    \/    \/    \/    \|/  |  \/    \/    \/    \
                 *             /     /\    /\    /\    /|\  |  /\    /\    /\     \
                 *            /     /  \  /  \  /  \  / | \ | /  \  /  \  /  \     \
                 *           /     /    \/    \/    \/  |  \|/    \/    \     \     \
                 *      --------------------------------|---[///////////////////////]--------
                 *
                 */


                shift = exp + 15 - SCALING;


                for (i = SHORT_WINDOW; i != 0; i--)
                {
                    Int16 win1, win2;
                    Int16  dat1, dat2;

                    dat2 = *(pFreq_2_Time_data_2++);
                    win2 = *(pShort_Window_2--);
                    temp = *pOverlap_and_Add_Buffer_2;
                    dat1 = *(pFreq_2_Time_data_1++);
                    win1 = *(pShort_Window_1++);

                    *(pOverlap_and_Add_Buffer_2++) =  temp + (fxp_mul_16_by_16(dat2, win2) >> shift);

                    *(pOverlap_and_Add_Buffer_1++)  =  fxp_mul_16_by_16(dat1, win1) >> shift;

                }

            }   /* if (exp < 16) */
            else
            {
                pv_memset(
                    pOverlap_and_Add_Buffer_1,
                    0,
                    SHORT_WINDOW*sizeof(*pOverlap_and_Add_Buffer_1));
            }


        }/* for ( wnd=NUM_SHORT_WINDOWS-1; wnd>=NUM_SHORT_WINDOWS/2; wnd--) */


        wnd = NUM_SHORT_WINDOWS / 2;

        pFreqInfo = (Int16 *) & pFrequency_data[ wnd*SHORT_WINDOW];

        /*
         *  scratch memory is allocated in an unused part of memory
         */


        pScrath_mem = &pFrequency_data[ 2*LONG_WINDOW - HALF_SHORT_WINDOW];

        pOverlap_and_Add_Buffer_1 = &pFrequency_data[ LONG_WINDOW];

        pOverlap_and_Add_Buffer_2 = pOverlap_and_Add_Buffer_1
                                    + HALF_SHORT_WINDOW;


        exp = imdct_fxp(
                  (Int32 *)pFreqInfo,
                  freq_2_time_buffer,
                  SHORT_BLOCK1,
                  Q_format,
                  abs_max_per_window[wnd]);

        /*
         *  If all element are zero or if the exponent is bigger than
         *  16 ( it becomes an undefined shift) ->  skip
         */


        if (exp < 16)
        {

            pFreq_2_Time_data_1 = &pFreqInfo[0];
            pFreq_2_Time_data_2 = &pFreqInfo[SHORT_WINDOW];

            pShort_Window_1 = &Short_Window_fxp[wnd_shape_this_bk][0];

            pShort_Window_2 =
                &Short_Window_fxp[wnd_shape_this_bk][SHORT_WINDOW_m_1];


            /*
             * For short window 4
             *                                    ====|===========
             *                                        |   4
             *                                    |   |   |      |
             *                _--_  _--_  _--_  _-|-_ | _-|-_  _-|-_  _--_  _--_
             *               /    \/    \/    \/  |  \|/  |  \/  |  \/    \/    \
             *              /     /\    /\    /\  |  /|\  |  /\  |  /\    /\     \
             *             /     /  \  /  \  /  \ | / | \ | /  \ | /  \  /  \     \
             *            /     /    \/    \/    \|/  |  \|/    \|/    \/    \     \
             *      ------------------------------[\\\|\\\|//////]-------------------
             *           |                        | A | B |   C  |
             *           |
             *        W_L_STOP_1
             */

            shift = exp + 15 - SCALING;
            {
                Int16 win1;
                Int16  dat1;
                /* -------- segment A ---------------*/
                dat1 = *(pFreq_2_Time_data_1++);
                win1 = *(pShort_Window_1++);
                for (i = HALF_SHORT_WINDOW; i != 0; i--)
                {
                    *(pScrath_mem++)  =  fxp_mul_16_by_16(dat1, win1) >> (shift);
                    dat1 = *(pFreq_2_Time_data_1++);
                    win1 = *(pShort_Window_1++);
                }

                /* -------- segment B ---------------*/
                for (i = HALF_SHORT_WINDOW; i != 0; i--)
                {
                    *(pOverlap_and_Add_Buffer_1++)  =  fxp_mul_16_by_16(dat1, win1) >> shift;

                    dat1 = *(pFreq_2_Time_data_1++);
                    win1 = *(pShort_Window_1++);
                }

                /* -------- segment C ---------------*/
                temp = *pOverlap_and_Add_Buffer_2;
                dat1 = *(pFreq_2_Time_data_2++);
                win1 = *(pShort_Window_2--);

                for (i = SHORT_WINDOW; i != 0; i--)
                {
                    *(pOverlap_and_Add_Buffer_2++)  =  temp + (fxp_mul_16_by_16(dat1, win1) >> shift);

                    temp = *pOverlap_and_Add_Buffer_2;
                    dat1 = *(pFreq_2_Time_data_2++);
                    win1 = *(pShort_Window_2--);
                }
            }

        }   /* if (exp < 16) */
        else
        {
            pv_memset(
                pScrath_mem,
                0,
                HALF_SHORT_WINDOW*sizeof(*pScrath_mem));

            pv_memset(
                pOverlap_and_Add_Buffer_1,
                0,
                HALF_SHORT_WINDOW*sizeof(*pOverlap_and_Add_Buffer_1));
        }


        wnd = NUM_SHORT_WINDOWS / 2 - 1;

        pFreqInfo = (Int16 *) & pFrequency_data[ wnd*SHORT_WINDOW];

        pScrath_mem_entry =
            &pFrequency_data[2*LONG_WINDOW - HALF_SHORT_WINDOW - SHORT_WINDOW];
        pScrath_mem = pScrath_mem_entry;

        pOverlap_and_Add_Buffer_1 = &pFrequency_data[ LONG_WINDOW];

        /* point to end of buffer less HALF_SHORT_WINDOW */

        pOutput_buffer_2 = &Output_buffer[LONG_WINDOW - HALF_SHORT_WINDOW];
        pOutput_buffer   = pOutput_buffer_2;

        pOverlap_and_Add_Buffer_1x = &Time_data[W_L_STOP_1 + SHORT_WINDOW*(wnd+1)];  /* !!!! */

        exp = imdct_fxp(
                  (Int32 *)pFreqInfo,
                  freq_2_time_buffer,
                  SHORT_BLOCK1,
                  Q_format,
                  abs_max_per_window[wnd]);

        /*
         *  If all element are zero or if the exponent is bigger than
         *  16 ( it becomes an undefined shift) ->  skip
         */

        if (exp < 16)
        {

            pFreq_2_Time_data_1 = &pFreqInfo[0];
            pFreq_2_Time_data_2 = &pFreqInfo[SHORT_WINDOW];


            /*
             * For short window 3
             *                             ===========|====
             *                                    3   |
             *                             |      |   |   |
             *               _--_  _--_  _-|-_  _-|-_ | _-|-_  _--_  _--_  _--_
             *              /    \/    \/  |  \/  |  \|/  |  \/    \/    \/    \
             *             /     /\    /\  |  /\  |  /|\  |  /\    /\    /\     \
             *            /     /  \  /  \ | /  \ | / | \ | /  \  /  \  /  \     \
             *           /     /    \/    \|/    \|/  |  \|/    \/    \     \     \
             *     -----|------------------[\\\\\\|///|///]--------------------------
             *          |                  |   A  | B | C |
             *
             *      W_L_STOP_1
             */


            pShort_Window_1 = &Short_Window_fxp[wnd_shape_this_bk][0];

            pShort_Window_2 =
                &Short_Window_fxp[wnd_shape_this_bk][SHORT_WINDOW_m_1];

            shift = exp + 15 - SCALING;


            Int16 win1;
            Int16  dat1;
            /* -------- segment A ---------------*/
            dat1 = *(pFreq_2_Time_data_1++);
            win1 = *(pShort_Window_1++);
            for (i = SHORT_WINDOW; i != 0; i--)
            {
                *(pScrath_mem++)  =  fxp_mul_16_by_16(dat1, win1) >> shift;
                dat1 = *(pFreq_2_Time_data_1++);
                win1 = *(pShort_Window_1++);
            }

            dat1 = *(pFreq_2_Time_data_2++);
            win1 = *(pShort_Window_2--);

            /* -------- segment B ---------------*/
            for (i = HALF_SHORT_WINDOW; i != 0; i--)
            {
                test = fxp_mul_16_by_16(dat1, win1) >> shift;

                temp =  *(pScrath_mem++) + test;


                test = *(pOverlap_and_Add_Buffer_1x++);  /* !!!! */

                limiter(*(pOutput_buffer++), (temp + test));

                dat1 = *(pFreq_2_Time_data_2++);
                win1 = *(pShort_Window_2--);

            }

            /* -------- segment C ---------------*/
            for (i = HALF_SHORT_WINDOW; i != 0; i--)
            {
                temp = fxp_mul_16_by_16(dat1, win1) >> (shift);

                *(pOverlap_and_Add_Buffer_1++) += temp;

                dat1 = *(pFreq_2_Time_data_2++);
                win1 = *(pShort_Window_2--);
            }

        }   /* if (exp < 16) */
        else
        {

            pv_memset(
                pScrath_mem,
                0,
                SHORT_WINDOW*sizeof(*pScrath_mem));

            pScrath_mem += SHORT_WINDOW;

            temp = *(pScrath_mem++);
            for (i = HALF_SHORT_WINDOW; i != 0; i--)
            {
                limiter(*(pOutput_buffer++), temp);
                temp = *(pScrath_mem++);


            }
        }


        for (wnd = NUM_SHORT_WINDOWS / 2 - 2; wnd >= 0; wnd--)
        {


            pOutput_buffer_2 -= SHORT_WINDOW;
            pOutput_buffer = pOutput_buffer_2;

            /*
             * The same memory is used as scratch in every iteration
             */
            pScrath_mem = pScrath_mem_entry;

            pOverlap_and_Add_Buffer_2x =
                &Time_data[W_L_STOP_1 + SHORT_WINDOW*(wnd+1)];

            pFreqInfo = (Int16 *) & pFrequency_data[ wnd*SHORT_WINDOW];


            exp = imdct_fxp(
                      (Int32 *)pFreqInfo,
                      freq_2_time_buffer,
                      SHORT_BLOCK1,
                      Q_format,
                      abs_max_per_window[wnd]);

            /*
             *  If all element are zero or if the exponent is bigger than
             *  16 ( it becomes an undefined shift) ->  skip
             */

            if (exp < 16)
            {

                pFreq_2_Time_data_1 = &pFreqInfo[0];
                pFreq_2_Time_data_2 = &pFreqInfo[SHORT_WINDOW];


                /*
                 *  Each of the eight short blocks is windowed separately.
                 *  Window shape decisions are made on a frame-by-frame
                 *  basis.
                 */

                pShort_Window_1 = &Short_Window_fxp[wnd_shape_this_bk][0];

                if (wnd == 0)
                {
                    pShort_Window_1 =
                        &Short_Window_fxp[wnd_shape_prev_bk][0];
                }

                pShort_Window_2   =
                    &Short_Window_fxp[wnd_shape_this_bk][SHORT_WINDOW_m_1];


                /*
                 * For short windows from 2 to 0
                 *
                 *          =========================
                 *                                       |
                 *                0     1     2      |   |
                 *               _--_  _--_  _--_  _-|-_ | _--_  _--_  _--_  _--_
                 *              /    \/    \/    \/  |  \|/    \/    \/    \/    \
                 *             /     /\    /\    /\  |  /|\    /\    /\    /\     \
                 *            /     /  \  /  \  /  \ | / | \  /  \  /  \  /  \     \
                 *           /     /    \/    \/    \|/  |  \/    \/    \     \     \
                 *      ----[\\\\\\\\\\\\\\\\\\\\\\\\]---|-----------------------------
                 *          |
                 *
                 *      W_L_STOP_1
                 */

                shift = exp + 15 - SCALING;

                Int16 dat1 = *(pFreq_2_Time_data_2++);
                Int16 win1 = *(pShort_Window_2--);

                temp  =  *(pScrath_mem);
                for (i = SHORT_WINDOW; i != 0; i--)
                {
                    test  =  fxp_mul_16_by_16(dat1, win1) >> shift;

                    temp += test;

                    dat1 = *(pFreq_2_Time_data_1++);
                    win1 = *(pShort_Window_1++);

                    limiter(*(pOutput_buffer++), (temp + *(pOverlap_and_Add_Buffer_2x++)));


                    *(pScrath_mem++) = fxp_mul_16_by_16(dat1, win1) >> shift;
                    dat1 = *(pFreq_2_Time_data_2++);
                    win1 = *(pShort_Window_2--);
                    temp  =  *(pScrath_mem);

                }

            }   /* if (exp < 16) */
            else
            {
                test  = *(pScrath_mem);
                temp  = *(pOverlap_and_Add_Buffer_2x++);

                for (i = SHORT_WINDOW; i != 0; i--)
                {
                    limiter(*(pOutput_buffer++), (temp + test));

                    *(pScrath_mem++) = 0;
                    test  =  *(pScrath_mem);
                    temp  = *(pOverlap_and_Add_Buffer_2x++);

                }
            }

        }   /* for ( wnd=NUM_SHORT_WINDOWS/2-1; wnd>=0; wnd--) */

        pOverlap_and_Add_Buffer_2x =  &Time_data[W_L_STOP_1];

        pScrath_mem = pScrath_mem_entry;

        pOutput_buffer_2 -= SHORT_WINDOW;
        pOutput_buffer = pOutput_buffer_2;

        test  = *(pScrath_mem++);
        temp  = *(pOverlap_and_Add_Buffer_2x++);

        for (i = SHORT_WINDOW; i != 0; i--)
        {
            limiter(*(pOutput_buffer++), (temp + test));

            test  = *(pScrath_mem++);
            temp  = *(pOverlap_and_Add_Buffer_2x++);

        }

        pOverlap_and_Add_Buffer_1x = Time_data;

        pOutput_buffer = Output_buffer;


        temp = *(pOverlap_and_Add_Buffer_1x++);

        for (i = W_L_STOP_1; i != 0; i--)
        {
            limiter(*(pOutput_buffer++), temp);

            temp = *(pOverlap_and_Add_Buffer_1x++);
        }

        pOverlap_and_Add_Buffer_1x = &Time_data[0];

        pOverlap_and_Add_Buffer_2 = &pFrequency_data[LONG_WINDOW];

        /*
         *  update overlap and add buffer,
         *  so is ready for next iteration
         */

        for (int i = 0; i < W_L_STOP_2; i++)
        {
            temp = *(pOverlap_and_Add_Buffer_2++);
            *(pOverlap_and_Add_Buffer_1x++) = temp;
        }

        pv_memset(
            pOverlap_and_Add_Buffer_1x,
            0,
            W_L_STOP_1*sizeof(*pOverlap_and_Add_Buffer_1x));

    } /* if ( wnd_seq != EIGHT_SHORT_SEQUENCE) */

}

#endif
/*----------------------------------------------------------------------------
; FUNCTION CODE
----------------------------------------------------------------------------*/


void trans4m_freq_2_time_fxp_2(
    Int32               Frequency_data[],
    Int32               Time_data[],
    WINDOW_SEQUENCE     wnd_seq,
    Int                 wnd_shape_prev_bk,
    Int                 wnd_shape_this_bk,
    Int                 Q_format,
    Int32               abs_max_per_window[],
    Int32               freq_2_time_buffer[],
    Int16               *Interleaved_output)

{

    Int exp;
    Int shift;

    Int  i;
    Int  wnd;
#if !(defined( _ARM_GCC)||(_ARM))
    Int32 z;
#endif
    Int16 *pFreqInfo;
    Int32 temp;
    Int32 test;

    Int16 *pFreq_2_Time_data_1;
    Int16 *pFreq_2_Time_data_2;

    const Int16 *pLong_Window_1;
    const Int16 *pLong_Window_2;
    const Int16 *pShort_Window_1;
    const Int16 *pShort_Window_2;

    Int32 *pOverlap_and_Add_Buffer_1;
    Int32 *pOverlap_and_Add_Buffer_2;

    Int16  *pInterleaved_output;
    Int16  *pInterleaved_output_2;


    const Int16 * Long_Window_fxp[NUM_WINDOW_SHAPES];
    const Int16 * Short_Window_fxp[NUM_WINDOW_SHAPES];

    Long_Window_fxp[0] = Long_Window_sine_fxp;
    Long_Window_fxp[1] = Long_Window_KBD_fxp;
    Short_Window_fxp[0] = Short_Window_sine_fxp;
    Short_Window_fxp[1] = Short_Window_KBD_fxp;

    if (wnd_seq != EIGHT_SHORT_SEQUENCE)
    {

        pFreqInfo = (Int16 *)Frequency_data;


        exp = imdct_fxp(
                  (Int32 *)pFreqInfo,
                  freq_2_time_buffer,
                  LONG_BLOCK1,
                  Q_format,
                  abs_max_per_window[0]);


        /*
         *  The C Programming Language, Second Edition, Kernighan & Ritchie,
         *  page 206.
         *  "The result [of a shift] is undefined if the right operand is
         *  negative, or greater than or equal to the number of bits in the
         *  left expression's type"
         *   => avoid shift by 32 or 16
         */

        if (exp < 16)
        {

            pFreq_2_Time_data_1 = pFreqInfo;


            switch (wnd_seq)
            {

                case ONLY_LONG_SEQUENCE:
                default:

                {
                    pOverlap_and_Add_Buffer_1 = Time_data;

                    pInterleaved_output = Interleaved_output;

                    {

                        const Int16 *pLong_Window_2 = &Long_Window_fxp[wnd_shape_this_bk][LONG_WINDOW_m_1];

                        Int32 * pFreq2T   = (Int32 *)pFreqInfo;
                        Int32 * pFreq2T_2 = &pFreq2T[HALF_LONG_WINDOW];
                        Int32 * win = (Int32 *) & Long_Window_fxp[wnd_shape_prev_bk][0];

                        Int shift = exp + 15 - SCALING;

                        for (i = HALF_LONG_WINDOW; i != 0; i--)
                        {
                            Int16 win1, win2;
                            Int32  temp2, test2;

                            Int32  winx;

                            temp2 = *(pFreq2T++);
                            winx = *(win++);

                            test  = *(pOverlap_and_Add_Buffer_1++);
                            test2 = *(pOverlap_and_Add_Buffer_1--);
                            temp  =   fxp_mul_16_by_16bb(temp2, winx) >> shift;
                            temp2 =   fxp_mul_16_by_16tt(temp2, winx) >> shift;

                            limiter(*(pInterleaved_output), (temp + test));

                            limiter(*(pInterleaved_output + 2), (temp2 + test2));
                            pInterleaved_output += 4;

                            temp2 = *(pFreq2T_2++);

                            win1  = *(pLong_Window_2--);
                            win2  = *(pLong_Window_2--);
                            temp  = fxp_mul_16_by_16bb(temp2, win1) >> shift;
                            test2 = fxp_mul_16_by_16tb(temp2, win2) >> shift;

                            *(pOverlap_and_Add_Buffer_1++) = temp;
                            *(pOverlap_and_Add_Buffer_1++) = test2;
                        }

                    }

                }

                break;

                case LONG_START_SEQUENCE:

                    pFreq_2_Time_data_2 =
                        &pFreq_2_Time_data_1[ HALF_LONG_WINDOW];

                    pLong_Window_1 = &Long_Window_fxp[wnd_shape_prev_bk][0];
                    pLong_Window_2 = &pLong_Window_1[ HALF_LONG_WINDOW];

                    pOverlap_and_Add_Buffer_1 = &Time_data[0];
                    pOverlap_and_Add_Buffer_2 = &Time_data[HALF_LONG_WINDOW];


                    pInterleaved_output   = Interleaved_output;
                    pInterleaved_output_2 = pInterleaved_output + (2 * HALF_LONG_WINDOW);


                    /*
                     *  process first  LONG_WINDOW elements
                     */

                    shift = exp + 15 - SCALING;

                    for (i = HALF_LONG_WINDOW; i != 0; i--)
                    {
                        Int16 win1, win2;
                        Int16  dat1, dat2;
                        Int32  test1, test2;

                        dat1   = *(pFreq_2_Time_data_1++);
                        win1   = *(pLong_Window_1++);
                        test1  = *(pOverlap_and_Add_Buffer_1++);

                        dat2  =  *(pFreq_2_Time_data_2++);
                        win2  = *(pLong_Window_2++);
                        test2 = *(pOverlap_and_Add_Buffer_2++);

                        limiter(*(pInterleaved_output), (test1 + (fxp_mul_16_by_16(dat1, win1) >> shift)));

                        pInterleaved_output   += 2;

                        limiter(*(pInterleaved_output_2), (test2 + (fxp_mul_16_by_16(dat2, win2) >> shift)));

                        pInterleaved_output_2    += 2;
                    }


                    /*
                     *  data unchanged from  LONG_WINDOW to W_L_START_1
                     *  only scaled accordingly
                     */

                    pOverlap_and_Add_Buffer_1 = &Time_data[0];
                    pFreq_2_Time_data_1       = &pFreqInfo[LONG_WINDOW];

                    exp -= SCALING;

                    if (exp >= 0)
                    {

                        for (i = (W_L_START_1 - LONG_WINDOW) >> 1; i != 0; i--)
                        {
                            *(pOverlap_and_Add_Buffer_1++) =
                                *(pFreq_2_Time_data_1++) >> exp;
                            *(pOverlap_and_Add_Buffer_1++) =
                                *(pFreq_2_Time_data_1++) >> exp;

                        }

                    }
                    else if (exp < 0)
                    {

                        Int shift = -exp;
                        for (i = (W_L_START_1 - LONG_WINDOW) >> 1; i != 0 ; i--)
                        {
                            Int32 temp2 = ((Int32) * (pFreq_2_Time_data_1++)) << shift;
                            *(pOverlap_and_Add_Buffer_1++) = temp2;
                            temp2 = ((Int32) * (pFreq_2_Time_data_1++)) << shift;
                            *(pOverlap_and_Add_Buffer_1++) = temp2;
                        }

                    }
                    else
                    {

                        for (i = (W_L_START_1 - LONG_WINDOW) >> 1; i != 0; i--)
                        {
                            *(pOverlap_and_Add_Buffer_1++) =
                                *(pFreq_2_Time_data_1++);
                            *(pOverlap_and_Add_Buffer_1++) =
                                *(pFreq_2_Time_data_1++);

                        }

                    }


                    pFreq_2_Time_data_1  = &pFreqInfo[W_L_START_1];
                    pFreq_2_Time_data_2  =
                        &pFreq_2_Time_data_1[HALF_SHORT_WINDOW];

                    pShort_Window_1   =
                        &Short_Window_fxp[wnd_shape_this_bk][SHORT_WINDOW_m_1];

                    pShort_Window_2   = pShort_Window_1 - HALF_SHORT_WINDOW;

                    pOverlap_and_Add_Buffer_2 = pOverlap_and_Add_Buffer_1 +
                                                HALF_SHORT_WINDOW;

                    {
                        Int16 win1, win2;
                        Int16  dat1, dat2;
                        Int32  temp2;

                        for (i = HALF_SHORT_WINDOW; i != 0; i--)
                        {

                            dat1  = (*pFreq_2_Time_data_1++);
                            dat2  = (*pFreq_2_Time_data_2++);
                            win1  = *(pShort_Window_1--);
                            win2  = *(pShort_Window_2--);

                            temp   =   fxp_mul_16_by_16(dat1, win1) >> shift;
                            *(pOverlap_and_Add_Buffer_1++) = temp;

                            temp2 =   fxp_mul_16_by_16(dat2, win2) >> shift;
                            *(pOverlap_and_Add_Buffer_2++) = temp2;

                        }
                    }

                    pOverlap_and_Add_Buffer_1 += HALF_SHORT_WINDOW;


                    pv_memset(
                        pOverlap_and_Add_Buffer_1,
                        0,
                        (LONG_BLOCK1 - W_L_START_2)
                        *sizeof(*pOverlap_and_Add_Buffer_1));


                    break;


                case LONG_STOP_SEQUENCE:

                    pOverlap_and_Add_Buffer_1 = &Time_data[ W_L_STOP_2];

                    pInterleaved_output    = &Interleaved_output[2*W_L_STOP_2];

                    pFreq_2_Time_data_1      = &pFreqInfo[W_L_STOP_2];

                    exp -= SCALING;


                    if (exp > 0)
                    {
                        Int16 tmp1 = (*(pFreq_2_Time_data_1++) >> exp);
                        temp = *(pOverlap_and_Add_Buffer_1++);

                        for (i = (LONG_WINDOW - W_L_STOP_2); i != 0; i--)
                        {
                            limiter(*(pInterleaved_output), (temp + tmp1));

                            pInterleaved_output += 2;
                            tmp1 = *(pFreq_2_Time_data_1++) >> exp;
                            temp = *(pOverlap_and_Add_Buffer_1++);
                        }
                    }
                    else if (exp < 0)
                    {
                        shift = -exp;

                        Int32 temp1 = ((Int32) * (pFreq_2_Time_data_1++)) << shift;
                        temp = *(pOverlap_and_Add_Buffer_1++);

                        for (i = (LONG_WINDOW - W_L_STOP_2); i != 0; i--)
                        {
                            limiter(*(pInterleaved_output), (temp + temp1));

                            pInterleaved_output += 2;
                            temp1 = ((Int32) * (pFreq_2_Time_data_1++)) << shift;
                            temp = *(pOverlap_and_Add_Buffer_1++);
                        }
                    }
                    else
                    {
                        Int16 tmp1 = *(pFreq_2_Time_data_1++);
                        temp = *(pOverlap_and_Add_Buffer_1++);
                        for (i = (LONG_WINDOW - W_L_STOP_2); i != 0; i--)
                        {
                            limiter(*(pInterleaved_output), (temp + tmp1));

                            pInterleaved_output += 2;
                            tmp1 = *(pFreq_2_Time_data_1++);
                            temp = *(pOverlap_and_Add_Buffer_1++);
                        }
                    }


                    pShort_Window_1 = &Short_Window_fxp[wnd_shape_prev_bk][0];
                    pShort_Window_2 = &pShort_Window_1[HALF_SHORT_WINDOW];

                    pFreq_2_Time_data_1 = &pFreqInfo[W_L_STOP_1];
                    pFreq_2_Time_data_2 =
                        &pFreq_2_Time_data_1[HALF_SHORT_WINDOW];

                    pOverlap_and_Add_Buffer_1 = &Time_data[ W_L_STOP_1];
                    pOverlap_and_Add_Buffer_2 = pOverlap_and_Add_Buffer_1
                                                + HALF_SHORT_WINDOW;


                    pInterleaved_output   = &Interleaved_output[2*W_L_STOP_1];
                    pInterleaved_output_2 = pInterleaved_output + (2 * HALF_SHORT_WINDOW);

                    exp += SCALING;  /* +8 back to what it was */
                    shift = exp + 15 - SCALING;


                    for (i = HALF_SHORT_WINDOW; i != 0; i--)
                    {

                        Int16 win1;
                        Int16 dat1;

                        dat1 = *(pFreq_2_Time_data_1++);
                        win1 = *(pShort_Window_1++);
                        temp = *(pOverlap_and_Add_Buffer_1++);

                        test  = fxp_mul_16_by_16(dat1, win1);

                        limiter(*(pInterleaved_output), (temp + (test >> shift)));

                        pInterleaved_output += 2;

                        dat1 = *(pFreq_2_Time_data_2++);
                        win1 = *(pShort_Window_2++);
                        temp = *(pOverlap_and_Add_Buffer_2++);
                        test =  fxp_mul_16_by_16(dat1, win1);

                        limiter(*(pInterleaved_output_2), (temp + (test >> shift)));

                        pInterleaved_output_2 += 2;

                    }


                    pFreq_2_Time_data_2 = &pFreqInfo[LONG_WINDOW];

                    pOverlap_and_Add_Buffer_1 = Time_data;


                    pInterleaved_output = Interleaved_output;

                    pLong_Window_2   =
                        &Long_Window_fxp[wnd_shape_this_bk][LONG_WINDOW_m_1];


                    /*
                     *  Copy previous time in current buffer, also copy overlap
                     *  and add buffer
                     */

                    for (i = W_L_STOP_1; i != 0; i--)
                    {

                        Int16 win1;
                        Int16 dat1;

                        win1 = *(pLong_Window_2--);
                        dat1 = *pFreq_2_Time_data_2++;

                        limiter(*(pInterleaved_output), *(pOverlap_and_Add_Buffer_1));

                        pInterleaved_output += 2;

                        temp = fxp_mul_16_by_16(dat1, win1) >> shift;
                        *(pOverlap_and_Add_Buffer_1++) = temp ;

                    }

                    for (i = (LONG_WINDOW - W_L_STOP_1); i != 0; i--)
                    {

                        temp = fxp_mul_16_by_16(*pFreq_2_Time_data_2++, *(pLong_Window_2--)) >> shift;
                        *(pOverlap_and_Add_Buffer_1++) = temp ;

                    }

                    break;


            } /* switch (wnd_seq) */

        }   /*  if (exp < 16)  */

        else
        {
            /* all zeros buffer or excessive down shift */

            /* Overlap and add, setup buffer for next iteration */
            pOverlap_and_Add_Buffer_1 = &Time_data[0];

            pInterleaved_output = Interleaved_output;


            temp  = (*pOverlap_and_Add_Buffer_1++);
            for (i = LONG_WINDOW; i != 0; i--)
            {

                limiter(*(pInterleaved_output), temp);

                pInterleaved_output += 2;
                temp  = (*pOverlap_and_Add_Buffer_1++);
            }
            pv_memset(Time_data, 0, LONG_WINDOW*sizeof(Time_data[0]));
        }

    }
    else
    {

        Int32 *pScrath_mem;
        Int32 *pScrath_mem_entry;
        Int32  *pFrequency_data = Frequency_data;

        Int32 * pOverlap_and_Add_Buffer_1;
        Int32 * pOverlap_and_Add_Buffer_2;
        Int32 * pOverlap_and_Add_Buffer_1x;
        Int32 * pOverlap_and_Add_Buffer_2x;


        /*
         *  Frequency_data is 2*LONG_WINDOW length but only
         *  the first LONG_WINDOW elements are filled in,
         *  then the second part can be used as scratch mem,
         *  then grab data from one window at a time in
         *  reverse order.
         *  The upper LONG_WINDOW Int32 are used to hold the
         *  computed overlap and add, used in the next call to
         *  this function, and also as sctrach memory
         */

        /*
         *  Frequency_data usage for the case EIGHT_SHORT_SEQUENCE

          |<----- Input Freq. data ----->|< Overlap & Add ->| Unused |-Scratch-|
          |                              |  Store for next  |        |  memory |
          |                              |  call            |        |         |
          |                              |                  |        |         |
          |//////////////////////////////|\\\\\\\\\\\\\\\\\\|--------|+++++++++|
          |                              |                  |        |         |
          0                         LONG_WINDOW        LONG_WINDOW   |   2*LONG_WINDOW
                                                            +        |         |
                                                       W_L_STOP_2    |         |
                                                                     |<--   -->|
                                                                      SHORT_WINDOW +
                                                                    HALF_SHORT_WINDOW
          *
          */

        pOverlap_and_Add_Buffer_1  = &pFrequency_data[
                                         LONG_WINDOW + 3*SHORT_WINDOW + HALF_SHORT_WINDOW];

        /*
         *  Initialize to zero, only the firt short window used in overlap
         *  and add
         */
        pv_memset(
            pOverlap_and_Add_Buffer_1,
            0,
            SHORT_WINDOW*sizeof(*pOverlap_and_Add_Buffer_1));

        /*
         *  Showt windows are evaluated in decresing order. Windows from 7
         *  to 0 are break down in four cases: window numbers 7 to 5, 4, 3,
         *  and 2 to 0.
         *  The data from short windows 3 and 4 is situated at the boundary
         *  between the 'overlap and add' buffer and the output buffer.
         */
        for (wnd = NUM_SHORT_WINDOWS - 1; wnd >= NUM_SHORT_WINDOWS / 2 + 1; wnd--)
        {

            pFreqInfo = (Int16 *) & pFrequency_data[ wnd*SHORT_WINDOW];

            exp = imdct_fxp(
                      (Int32 *)pFreqInfo,
                      freq_2_time_buffer,
                      SHORT_BLOCK1,
                      Q_format,
                      abs_max_per_window[wnd]);

            /*  W_L_STOP_1 == (LONG_WINDOW - SHORT_WINDOW)>>1 */
            pOverlap_and_Add_Buffer_1 =
                &pFrequency_data[ W_L_STOP_1 + SHORT_WINDOW*wnd];


            pOverlap_and_Add_Buffer_2 =
                pOverlap_and_Add_Buffer_1 + SHORT_WINDOW;

            /*
             *  If all element are zero or if the exponent is bigger than
             *  16 ( it becomes an undefined shift) ->  skip
             */

            if (exp < 16)
            {


                pFreq_2_Time_data_1 = &pFreqInfo[0];
                pFreq_2_Time_data_2 = &pFreqInfo[SHORT_WINDOW];


                /*
                 *  Each of the eight short blocks is windowed separately.
                 *  Window shape decisions are made on a frame-by-frame
                 *  basis.
                 */

                pShort_Window_1 = &Short_Window_fxp[wnd_shape_this_bk][0];

                pShort_Window_2   =
                    &Short_Window_fxp[wnd_shape_this_bk][SHORT_WINDOW_m_1];


                /*
                 * For short windows from 7 to 5
                 *                                      |   =========================
                 *                                      |   |     5     6     7
                 *               _--_  _--_  _--_  _--_ | _-|-_  _--_  _--_  _--_
                 *              /    \/    \/    \/    \|/  |  \/    \/    \/    \
                 *             /     /\    /\    /\    /|\  |  /\    /\    /\     \
                 *            /     /  \  /  \  /  \  / | \ | /  \  /  \  /  \     \
                 *           /     /    \/    \/    \/  |  \|/    \/    \     \     \
                 *      --------------------------------|---[///////////////////////]--------
                 *
                 */


                shift = exp + 15 - SCALING;


                for (i = SHORT_WINDOW; i != 0; i--)
                {
                    Int16 win1, win2;
                    Int16  dat1, dat2;

                    dat2 = *(pFreq_2_Time_data_2++);
                    win2 = *(pShort_Window_2--);
                    temp = *pOverlap_and_Add_Buffer_2;
                    dat1 = *(pFreq_2_Time_data_1++);
                    win1 = *(pShort_Window_1++);

                    *(pOverlap_and_Add_Buffer_2++) =  temp + (fxp_mul_16_by_16(dat2, win2) >> shift);

                    *(pOverlap_and_Add_Buffer_1++)  =  fxp_mul_16_by_16(dat1, win1) >> shift;

                }

            }   /* if (exp < 16) */
            else
            {
                pv_memset(
                    pOverlap_and_Add_Buffer_1,
                    0,
                    SHORT_WINDOW*sizeof(*pOverlap_and_Add_Buffer_1));
            }


        }/* for ( wnd=NUM_SHORT_WINDOWS-1; wnd>=NUM_SHORT_WINDOWS/2; wnd--) */


        wnd = NUM_SHORT_WINDOWS / 2;

        pFreqInfo = (Int16 *) & pFrequency_data[ wnd*SHORT_WINDOW];

        /*
         *  scratch memory is allocated in an unused part of memory
         */


        pScrath_mem = &pFrequency_data[ 2*LONG_WINDOW - HALF_SHORT_WINDOW];

        pOverlap_and_Add_Buffer_1 = &pFrequency_data[ LONG_WINDOW];

        pOverlap_and_Add_Buffer_2 = pOverlap_and_Add_Buffer_1
                                    + HALF_SHORT_WINDOW;


        exp = imdct_fxp(
                  (Int32 *)pFreqInfo,
                  freq_2_time_buffer,
                  SHORT_BLOCK1,
                  Q_format,
                  abs_max_per_window[wnd]);

        /*
         *  If all element are zero or if the exponent is bigger than
         *  16 ( it becomes an undefined shift) ->  skip
         */


        if (exp < 16)
        {

            pFreq_2_Time_data_1 = &pFreqInfo[0];
            pFreq_2_Time_data_2 = &pFreqInfo[SHORT_WINDOW];

            pShort_Window_1 = &Short_Window_fxp[wnd_shape_this_bk][0];

            pShort_Window_2 =
                &Short_Window_fxp[wnd_shape_this_bk][SHORT_WINDOW_m_1];


            /*
             * For short window 4
             *                                    ====|===========
             *                                        |   4
             *                                    |   |   |      |
             *                _--_  _--_  _--_  _-|-_ | _-|-_  _-|-_  _--_  _--_
             *               /    \/    \/    \/  |  \|/  |  \/  |  \/    \/    \
             *              /     /\    /\    /\  |  /|\  |  /\  |  /\    /\     \
             *             /     /  \  /  \  /  \ | / | \ | /  \ | /  \  /  \     \
             *            /     /    \/    \/    \|/  |  \|/    \|/    \/    \     \
             *      ------------------------------[\\\|\\\|//////]-------------------
             *           |                        | A | B |   C  |
             *           |
             *        W_L_STOP_1
             */

            shift = exp + 15 - SCALING;
            {
                Int16 win1;
                Int16  dat1;
                /* -------- segment A ---------------*/
                dat1 = *(pFreq_2_Time_data_1++);
                win1 = *(pShort_Window_1++);
                for (i = HALF_SHORT_WINDOW; i != 0; i--)
                {
                    *(pScrath_mem++)  =  fxp_mul_16_by_16(dat1, win1) >> shift;
                    dat1 = *(pFreq_2_Time_data_1++);
                    win1 = *(pShort_Window_1++);
                }

                /* -------- segment B ---------------*/
                for (i = HALF_SHORT_WINDOW; i != 0; i--)
                {
                    *(pOverlap_and_Add_Buffer_1++)  =  fxp_mul_16_by_16(dat1, win1) >> shift;

                    dat1 = *(pFreq_2_Time_data_1++);
                    win1 = *(pShort_Window_1++);
                }

                /* -------- segment C ---------------*/
                temp = *pOverlap_and_Add_Buffer_2;
                dat1 = *(pFreq_2_Time_data_2++);
                win1 = *(pShort_Window_2--);

                for (i = SHORT_WINDOW; i != 0; i--)
                {
                    *(pOverlap_and_Add_Buffer_2++)  =  temp + (fxp_mul_16_by_16(dat1, win1) >> shift);

                    temp = *pOverlap_and_Add_Buffer_2;
                    dat1 = *(pFreq_2_Time_data_2++);
                    win1 = *(pShort_Window_2--);
                }
            }

        }   /* if (exp < 16) */
        else
        {
            pv_memset(
                pScrath_mem,
                0,
                HALF_SHORT_WINDOW*sizeof(*pScrath_mem));

            pv_memset(
                pOverlap_and_Add_Buffer_1,
                0,
                HALF_SHORT_WINDOW*sizeof(*pOverlap_and_Add_Buffer_1));
        }


        wnd = NUM_SHORT_WINDOWS / 2 - 1;

        pFreqInfo = (Int16 *) & pFrequency_data[ wnd*SHORT_WINDOW];

        pScrath_mem_entry =
            &pFrequency_data[2*LONG_WINDOW - HALF_SHORT_WINDOW - SHORT_WINDOW];


        pScrath_mem = pScrath_mem_entry;

        pOverlap_and_Add_Buffer_1 = &pFrequency_data[ LONG_WINDOW];

        /* point to end of buffer less HALF_SHORT_WINDOW */

        pInterleaved_output_2 = &Interleaved_output[2*(LONG_WINDOW - HALF_SHORT_WINDOW)];
        pInterleaved_output = pInterleaved_output_2;

        pOverlap_and_Add_Buffer_1x = &Time_data[W_L_STOP_1 + SHORT_WINDOW*(wnd+1)];


        exp = imdct_fxp(
                  (Int32 *)pFreqInfo,
                  freq_2_time_buffer,
                  SHORT_BLOCK1,
                  Q_format,
                  abs_max_per_window[wnd]);

        /*
         *  If all element are zero or if the exponent is bigger than
         *  16 ( it becomes an undefined shift) ->  skip
         */

        if (exp < 16)
        {

            pFreq_2_Time_data_1 = &pFreqInfo[0];
            pFreq_2_Time_data_2 = &pFreqInfo[SHORT_WINDOW];


            /*
             * For short window 3
             *                             ===========|====
             *                                    3   |
             *                             |      |   |   |
             *               _--_  _--_  _-|-_  _-|-_ | _-|-_  _--_  _--_  _--_
             *              /    \/    \/  |  \/  |  \|/  |  \/    \/    \/    \
             *             /     /\    /\  |  /\  |  /|\  |  /\    /\    /\     \
             *            /     /  \  /  \ | /  \ | / | \ | /  \  /  \  /  \     \
             *           /     /    \/    \|/    \|/  |  \|/    \/    \     \     \
             *     -----|------------------[\\\\\\|///|///]--------------------------
             *          |                  |   A  | B | C |
             *
             *      W_L_STOP_1
             */


            pShort_Window_1 = &Short_Window_fxp[wnd_shape_this_bk][0];

            pShort_Window_2 =
                &Short_Window_fxp[wnd_shape_this_bk][SHORT_WINDOW_m_1];

            shift = exp + 15 - SCALING;

            Int16 win1;
            Int16  dat1;
            /* -------- segment A ---------------*/
            dat1 = *(pFreq_2_Time_data_1++);
            win1 = *(pShort_Window_1++);
            for (i = SHORT_WINDOW; i != 0; i--)
            {
                *(pScrath_mem++)  =  fxp_mul_16_by_16(dat1, win1) >> shift;
                dat1 = *(pFreq_2_Time_data_1++);
                win1 = *(pShort_Window_1++);
            }

            dat1 = *(pFreq_2_Time_data_2++);
            win1 = *(pShort_Window_2--);


            /* -------- segment B ---------------*/
            for (i = HALF_SHORT_WINDOW; i != 0; i--)
            {
                test = fxp_mul_16_by_16(dat1, win1) >> shift;

                temp =  *(pScrath_mem++) + test;

                test = *(pOverlap_and_Add_Buffer_1x++);
                limiter(*(pInterleaved_output), (temp + test));


                pInterleaved_output += 2;
                dat1 = *(pFreq_2_Time_data_2++);
                win1 = *(pShort_Window_2--);

            }

            /* -------- segment C ---------------*/
            for (i = HALF_SHORT_WINDOW; i != 0; i--)
            {

                temp = fxp_mul_16_by_16(dat1, win1) >> shift;

                *(pOverlap_and_Add_Buffer_1++) += temp;

                dat1 = *(pFreq_2_Time_data_2++);
                win1 = *(pShort_Window_2--);
            }


        }   /* if (exp < 16) */
        else
        {

            pv_memset(
                pScrath_mem,
                0,
                SHORT_WINDOW*sizeof(*pScrath_mem));

            pScrath_mem += SHORT_WINDOW;

            temp = *(pScrath_mem++);
            for (i = HALF_SHORT_WINDOW; i != 0; i--)
            {
                limiter(*(pInterleaved_output), (temp));

                pInterleaved_output += 2;
                temp = *(pScrath_mem++);

            }
        }


        for (wnd = NUM_SHORT_WINDOWS / 2 - 2; wnd >= 0; wnd--)
        {


            pInterleaved_output_2 -= (SHORT_WINDOW * 2);
            pInterleaved_output = pInterleaved_output_2;

            /*
             * The same memory is used as scratch in every iteration
             */
            pScrath_mem = pScrath_mem_entry;

            pOverlap_and_Add_Buffer_2x =
                &Time_data[W_L_STOP_1 + SHORT_WINDOW*(wnd+1)];

            pFreqInfo = (Int16 *) & pFrequency_data[ wnd*SHORT_WINDOW];


            exp = imdct_fxp(
                      (Int32 *)pFreqInfo,
                      freq_2_time_buffer,
                      SHORT_BLOCK1,
                      Q_format,
                      abs_max_per_window[wnd]);

            /*
             *  If all element are zero or if the exponent is bigger than
             *  16 ( it becomes an undefined shift) ->  skip
             */

            if (exp < 16)
            {

                pFreq_2_Time_data_1 = &pFreqInfo[0];
                pFreq_2_Time_data_2 = &pFreqInfo[SHORT_WINDOW];


                /*
                 *  Each of the eight short blocks is windowed separately.
                 *  Window shape decisions are made on a frame-by-frame
                 *  basis.
                 */

                pShort_Window_1 = &Short_Window_fxp[wnd_shape_this_bk][0];

                if (wnd == 0)
                {
                    pShort_Window_1 =
                        &Short_Window_fxp[wnd_shape_prev_bk][0];
                }

                pShort_Window_2   =
                    &Short_Window_fxp[wnd_shape_this_bk][SHORT_WINDOW_m_1];


                /*
                 * For short windows from 2 to 0
                 *
                 *          =========================
                 *                                       |
                 *                0     1     2      |   |
                 *               _--_  _--_  _--_  _-|-_ | _--_  _--_  _--_  _--_
                 *              /    \/    \/    \/  |  \|/    \/    \/    \/    \
                 *             /     /\    /\    /\  |  /|\    /\    /\    /\     \
                 *            /     /  \  /  \  /  \ | / | \  /  \  /  \  /  \     \
                 *           /     /    \/    \/    \|/  |  \/    \/    \     \     \
                 *      ----[\\\\\\\\\\\\\\\\\\\\\\\\]---|-----------------------------
                 *          |
                 *
                 *      W_L_STOP_1
                 */

                shift = exp + 15 - SCALING;

                Int16 dat1 = *(pFreq_2_Time_data_2++);
                Int16 win1 = *(pShort_Window_2--);

                temp  =  *(pScrath_mem);
                for (i = SHORT_WINDOW; i != 0; i--)
                {
                    test  =  fxp_mul_16_by_16(dat1, win1) >> shift;

                    temp += test;
                    dat1 = *(pFreq_2_Time_data_1++);
                    win1 = *(pShort_Window_1++);

                    limiter(*(pInterleaved_output), (temp + *(pOverlap_and_Add_Buffer_2x++)));

                    pInterleaved_output += 2;

                    *(pScrath_mem++) = fxp_mul_16_by_16(dat1, win1) >> shift;
                    dat1 = *(pFreq_2_Time_data_2++);
                    win1 = *(pShort_Window_2--);
                    temp  =  *(pScrath_mem);

                }

            }   /* if (exp < 16) */
            else
            {
                test  = *(pScrath_mem);
                temp  = *(pOverlap_and_Add_Buffer_2x++);

                for (i = SHORT_WINDOW; i != 0; i--)
                {
                    limiter(*(pInterleaved_output), (temp + test));

                    pInterleaved_output += 2;

                    *(pScrath_mem++) = 0;
                    test  =  *(pScrath_mem);
                    temp  = *(pOverlap_and_Add_Buffer_2x++);
                }
            }

        }   /* for ( wnd=NUM_SHORT_WINDOWS/2-1; wnd>=0; wnd--) */

        pOverlap_and_Add_Buffer_2x =  &Time_data[W_L_STOP_1];

        pScrath_mem = pScrath_mem_entry;

        pInterleaved_output_2 -= (SHORT_WINDOW * 2);
        pInterleaved_output    = pInterleaved_output_2;

        test  = *(pScrath_mem++);
        temp  = *(pOverlap_and_Add_Buffer_2x++);

        for (i = SHORT_WINDOW; i != 0; i--)
        {
            limiter(*(pInterleaved_output), (temp + test));

            pInterleaved_output += 2;
            test  = *(pScrath_mem++);
            temp  = *(pOverlap_and_Add_Buffer_2x++);

        }

        pOverlap_and_Add_Buffer_1x = Time_data;

        pInterleaved_output = Interleaved_output;


        temp = *(pOverlap_and_Add_Buffer_1x++);
        for (i = W_L_STOP_1; i != 0; i--)
        {
            limiter(*(pInterleaved_output), temp);

            pInterleaved_output += 2;
            temp = *(pOverlap_and_Add_Buffer_1x++);

        }

        pOverlap_and_Add_Buffer_1x = &Time_data[0];

        pOverlap_and_Add_Buffer_2 = &pFrequency_data[LONG_WINDOW];

        /*
         *  update overlap and add buffer,
         *  so is ready for next iteration
         */

        for (int i = 0; i < W_L_STOP_2; i++)
        {
            temp = *(pOverlap_and_Add_Buffer_2++);
            *(pOverlap_and_Add_Buffer_1x++) = temp;
        }

        pv_memset(
            pOverlap_and_Add_Buffer_1x,
            0,
            W_L_STOP_1*sizeof(*pOverlap_and_Add_Buffer_1x));

    } /* if ( wnd_seq != EIGHT_SHORT_SEQUENCE) */


}   /* trans4m_freq_2_time_fxp */