import streamit.*;
import java.lang.*;

import java.lang.reflect.*;
import streamit.io.*;
        
class RPEDecodeFilter extends Filter 
{
    short[] mXmc;
    short[] FAC; 
    short[] xmp;
    short[] ep;

 

 
 
short shortify(int a)
{
    if (a >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (a <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) a;
		}
	}
}
    
short gsm_add(short a, short b)

{
    long ltmp = (long) a + (long) b;
    if (ltmp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (ltmp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) ltmp;
		}
	}
}

short gsm_sub(short a, short b)
{
    long ltmp = (long) a - (long) b;
    if (ltmp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (ltmp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) ltmp;
		}
	}
}

short gsm_mult(short a, short b)
{
    long temp = (long) a * (long) b >> 15;
    if (temp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (temp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) temp;
		}
	}       
}

short gsm_mult_r(short a, short b)
{
    long temp = ((long) a * (long) b) + 16384;
    short answer = (short) (temp >> 15);
    return answer;
}

short gsm_abs(short a)
{
    short answer;
    int temp;
    if (a < 0)
	{
	    if (a == -32768)
		{
		    answer = 32767;
		}
	    else
		{
		    temp = a * -1;
		    if (temp >= 32767)
			{
			    answer = 32767;
			}
		    else
			{
			    if (temp <= -32768)
				{
				    answer = -32768;
				}
			    else
				{
				    answer = (short) temp;
				}
			}
		}
	}
    else
	{
	    answer = a;
	}
    return answer;
}
 









    public void init() 
    {
	input = new Channel(Short.TYPE, 15);
	output = new Channel(Short.TYPE, 40);
	mXmc = new short[13];    
	 
	xmp = new short[13];  
	ep = new short[40 ];   

	 
	 
	FAC = new short[8];
	FAC[0] = 29218;
	FAC[1] = 26215;
	FAC[2] = 23832;
	FAC[3] = 21846;
	FAC[4] = 20165;
	FAC[5] = 18725;
	FAC[6] = 17476;
	FAC[7] = 16384;
	 
    }

    public void work() 
    {
	short i, k, xmaxc, mc, exp, mant, temp, temp1, temp2, temp3;
	 




	
	for (i = 0; i < 13; i++)
	    {
		mXmc[i] = input.popShort();
	    }
	xmaxc = input.popShort();     
	mc = input.popShort();        

	 
	 
       
	exp = 0;
	if (xmaxc > 15)
	    {
		exp = gsm_sub(shortify(xmaxc >> 3), (short) 1);
	    }
	mant = gsm_sub(xmaxc, shortify(exp << 3));
	
	 
	
	if (mant == 0)
	    {
		exp = -4;
		mant = 7;
	    }
	else
	    {
		while (mant <= 7) 
		    {
			mant = shortify(mant << 1 | 1);
			exp--;
		    }
		mant = gsm_sub(mant, (short) 8);
	    }
	
	 




	
	temp1 = FAC[mant];
	temp2 = gsm_sub((short) 6, exp);
	temp3 = shortify(1 << gsm_sub(temp2, (short) 1));

	for (i = 0; i < 13; i++)
	    {
		temp = gsm_sub(shortify(mXmc[i] << 1), (short) 7);     
		temp <<= 12;                  
		temp = gsm_mult_r(temp1, temp);
		temp = gsm_add(temp, temp3);
		xmp[i] = shortify(temp >> temp2);
	    }

	 






	 

	for(k = 0; k < 40; k++)
	    {
		ep[k] = 0;
	    }
	for(i = 0; i < 12; i++)
	    {
		 
		ep[mc + (3 * i)] = xmp[i];
	    } 
	 
	for (i = 0; i < 40 ; i++)
	    {
		output.pushShort(ep[i]);
	    }
	 
    }
}

class LTPFilter extends Filter 
{
    short[] QLB;
    short[] drp;
    short nrp;

 

 
 
short shortify(int a)
{
    if (a >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (a <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) a;
		}
	}
}
    
short gsm_add(short a, short b)

{
    long ltmp = (long) a + (long) b;
    if (ltmp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (ltmp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) ltmp;
		}
	}
}

short gsm_sub(short a, short b)
{
    long ltmp = (long) a - (long) b;
    if (ltmp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (ltmp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) ltmp;
		}
	}
}

short gsm_mult(short a, short b)
{
    long temp = (long) a * (long) b >> 15;
    if (temp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (temp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) temp;
		}
	}       
}

short gsm_mult_r(short a, short b)
{
    long temp = ((long) a * (long) b) + 16384;
    short answer = (short) (temp >> 15);
    return answer;
}

short gsm_abs(short a)
{
    short answer;
    int temp;
    if (a < 0)
	{
	    if (a == -32768)
		{
		    answer = 32767;
		}
	    else
		{
		    temp = a * -1;
		    if (temp >= 32767)
			{
			    answer = 32767;
			}
		    else
			{
			    if (temp <= -32768)
				{
				    answer = -32768;
				}
			    else
				{
				    answer = (short) temp;
				}
			}
		}
	}
    else
	{
	    answer = a;
	}
    return answer;
}
 







   
    public void init() 
    {
	input = new Channel(Short.TYPE, 162);
	output = new Channel(Short.TYPE, 1);
	drp = new short[160];
	nrp = 40;    

	 
	 
	QLB = new short[4];
	QLB[0] = 3277;
	QLB[1] = 11469;
	QLB[2] = 21299;
	QLB[3] = 32767;
	 
    }

    public void work()   
    {
	short i, nr, brp, drpp;
	short mBcr = input.popShort();   
	short mNcr = input.popShort();   
	 
	for (i = 0; i < 160; i++)
	    {
		drp[i] = input.popShort();  
	    }
	nr = mNcr;
	if ((mNcr < 40) || (mNcr > 120))
	    {
		nr = nrp;
	    }
	nrp = nr;

	 
	brp = QLB[mBcr];
	drpp = 1;
	for (i = 121; i < 161; i++)
	    {
		drpp = gsm_mult_r(brp, drp[i - nr]);    
	    } 
	
	output.pushShort(drpp);   
	 
    }
}

class AdditionUpdateFilter extends Filter 
{       
    short[] ep;
    short[] drp;

 

 
 
short shortify(int a)
{
    if (a >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (a <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) a;
		}
	}
}
    
short gsm_add(short a, short b)

{
    long ltmp = (long) a + (long) b;
    if (ltmp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (ltmp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) ltmp;
		}
	}
}

short gsm_sub(short a, short b)
{
    long ltmp = (long) a - (long) b;
    if (ltmp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (ltmp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) ltmp;
		}
	}
}

short gsm_mult(short a, short b)
{
    long temp = (long) a * (long) b >> 15;
    if (temp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (temp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) temp;
		}
	}       
}

short gsm_mult_r(short a, short b)
{
    long temp = ((long) a * (long) b) + 16384;
    short answer = (short) (temp >> 15);
    return answer;
}

short gsm_abs(short a)
{
    short answer;
    int temp;
    if (a < 0)
	{
	    if (a == -32768)
		{
		    answer = 32767;
		}
	    else
		{
		    temp = a * -1;
		    if (temp >= 32767)
			{
			    answer = 32767;
			}
		    else
			{
			    if (temp <= -32768)
				{
				    answer = -32768;
				}
			    else
				{
				    answer = (short) temp;
				}
			}
		}
	}
    else
	{
	    answer = a;
	}
    return answer;
}
 









    public void init() 
    {
	short i;
	input = new Channel(Short.TYPE, 41);
	output = new Channel(Short.TYPE, 160);
	ep = new short[40];  
	drp = new short[160 ];   
	for (i = 0; i < 160 ; i++)
	    {
		drp[i] = 0;    
	    }
    }

    public void work() 
    {
	short i, j, k, drpp;
	 
	for (i = 0; i < 40; i++)
	    {
		ep[i] = input.popShort();
	    }
	drpp = input.popShort();

	for (j = 121; j < 160; j++)   
	    {
		drp[j] = gsm_add(ep[j - 121], drpp);
	    }
	for (k = 0; k < 120; k++)     
	    {
		drp[k] = drp[k + 40];
	    }
	
	for (i = 0; i < 160 ; i++)   
	    {
		output.pushShort(drp[i]);
	    }
	 
    }
}

class ReflectionCoeffLARppInternal extends Filter
{
 

 
 
short shortify(int a)
{
    if (a >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (a <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) a;
		}
	}
}
    
short gsm_add(short a, short b)

{
    long ltmp = (long) a + (long) b;
    if (ltmp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (ltmp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) ltmp;
		}
	}
}

short gsm_sub(short a, short b)
{
    long ltmp = (long) a - (long) b;
    if (ltmp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (ltmp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) ltmp;
		}
	}
}

short gsm_mult(short a, short b)
{
    long temp = (long) a * (long) b >> 15;
    if (temp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (temp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) temp;
		}
	}       
}

short gsm_mult_r(short a, short b)
{
    long temp = ((long) a * (long) b) + 16384;
    short answer = (short) (temp >> 15);
    return answer;
}

short gsm_abs(short a)
{
    short answer;
    int temp;
    if (a < 0)
	{
	    if (a == -32768)
		{
		    answer = 32767;
		}
	    else
		{
		    temp = a * -1;
		    if (temp >= 32767)
			{
			    answer = 32767;
			}
		    else
			{
			    if (temp <= -32768)
				{
				    answer = -32768;
				}
			    else
				{
				    answer = (short) temp;
				}
			}
		}
	}
    else
	{
	    answer = a;
	}
    return answer;
}
 








    short INVA, MIC, B;

    public ReflectionCoeffLARppInternal(short INVA, short MIC, short B)
    {
        super(INVA, MIC, B);
    }
    
    public void init(final short INVA, final short MIC, final short B)
    {
        input = new Channel(Short.TYPE, 1);
        output = new Channel(Short.TYPE, 1);
        this.INVA = INVA;
        this.MIC = MIC;
        this.B = B;
    }

    public void work()
    {
        short LARc, LARpp, temp1, temp2;
        
        LARc = input.popShort();
        temp1 = shortify((gsm_add(LARc, MIC)) << 10);
        temp2 = shortify(B << 10);
        temp1 = gsm_sub(temp1, temp2);
        temp1 = gsm_mult_r(INVA, temp1);
        LARpp = gsm_add(temp1, temp1);
        output.pushShort(LARpp);
    }
}   

class ReflectionCoeffLARpp extends SplitJoin
{
    public void init()
    {
        setSplitter(ROUND_ROBIN());
         
        add(new ReflectionCoeffLARppInternal((short)13107, (short)-32, (short)0));
        add(new ReflectionCoeffLARppInternal((short)13107, (short)-32, (short)0));
        add(new ReflectionCoeffLARppInternal((short)13107, (short)-16, (short)2048));
        add(new ReflectionCoeffLARppInternal((short)13107, (short)-16, (short)-2560));
        add(new ReflectionCoeffLARppInternal((short)19223, (short)-8, (short)94));
        add(new ReflectionCoeffLARppInternal((short)17476, (short)-8, (short)-1792));
        add(new ReflectionCoeffLARppInternal((short)31454, (short)-4, (short)-341));
        add(new ReflectionCoeffLARppInternal((short)29708, (short)-4, (short)-1144));
        setJoiner(ROUND_ROBIN());
    }
}

class ReflectionCoeffLARpInternal extends Filter
{
 

 
 
short shortify(int a)
{
    if (a >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (a <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) a;
		}
	}
}
    
short gsm_add(short a, short b)

{
    long ltmp = (long) a + (long) b;
    if (ltmp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (ltmp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) ltmp;
		}
	}
}

short gsm_sub(short a, short b)
{
    long ltmp = (long) a - (long) b;
    if (ltmp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (ltmp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) ltmp;
		}
	}
}

short gsm_mult(short a, short b)
{
    long temp = (long) a * (long) b >> 15;
    if (temp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (temp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) temp;
		}
	}       
}

short gsm_mult_r(short a, short b)
{
    long temp = ((long) a * (long) b) + 16384;
    short answer = (short) (temp >> 15);
    return answer;
}

short gsm_abs(short a)
{
    short answer;
    int temp;
    if (a < 0)
	{
	    if (a == -32768)
		{
		    answer = 32767;
		}
	    else
		{
		    temp = a * -1;
		    if (temp >= 32767)
			{
			    answer = 32767;
			}
		    else
			{
			    if (temp <= -32768)
				{
				    answer = -32768;
				}
			    else
				{
				    answer = (short) temp;
				}
			}
		}
	}
    else
	{
	    answer = a;
	}
    return answer;
}
 








    short mprevLARpp;

    public void init()
    {
        input = new Channel(Short.TYPE, 1);
        output = new Channel(Short.TYPE, 1);
        mprevLARpp = 0;
    }
    
    public void work()
    {
        int i, j, k;
        short mLARp, mLARpp;
        
        mLARpp = input.popShort();
         
        mLARp = 0;

         
         
         

	 
	for (k = 0; k < 13; k++)
        {
            mLARp = gsm_add(shortify(mprevLARpp >> 2), shortify(mLARpp >> 2));
            mLARp = gsm_add(mLARp,  shortify(mprevLARpp >> 1));
        }

	for (k = 13; k < 27; k++)
            mLARp = gsm_add(shortify(mprevLARpp >> 1), shortify(mLARpp >> 1));

	for (k = 27; k < 39; k++)
        {
            mLARp = gsm_add(shortify(mprevLARpp >> 2), shortify(mLARpp >> 2));
            mLARp = gsm_add(mLARp, shortify(mLARpp >> 1));
        }

         





        mprevLARpp = mLARpp;
        output.pushShort(mLARp);
    }
}

class ReflectionCoeffLARp extends SplitJoin
{
    public void init()
    {
        setSplitter(ROUND_ROBIN());
         
        for (int i = 0; i < 8; i++)
            add(new ReflectionCoeffLARpInternal());
        setJoiner(ROUND_ROBIN());
    }
}

class ReflectionCoeffmrrp extends Filter
{
 

 
 
short shortify(int a)
{
    if (a >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (a <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) a;
		}
	}
}
    
short gsm_add(short a, short b)

{
    long ltmp = (long) a + (long) b;
    if (ltmp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (ltmp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) ltmp;
		}
	}
}

short gsm_sub(short a, short b)
{
    long ltmp = (long) a - (long) b;
    if (ltmp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (ltmp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) ltmp;
		}
	}
}

short gsm_mult(short a, short b)
{
    long temp = (long) a * (long) b >> 15;
    if (temp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (temp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) temp;
		}
	}       
}

short gsm_mult_r(short a, short b)
{
    long temp = ((long) a * (long) b) + 16384;
    short answer = (short) (temp >> 15);
    return answer;
}

short gsm_abs(short a)
{
    short answer;
    int temp;
    if (a < 0)
	{
	    if (a == -32768)
		{
		    answer = 32767;
		}
	    else
		{
		    temp = a * -1;
		    if (temp >= 32767)
			{
			    answer = 32767;
			}
		    else
			{
			    if (temp <= -32768)
				{
				    answer = -32768;
				}
			    else
				{
				    answer = (short) temp;
				}
			}
		}
	}
    else
	{
	    answer = a;
	}
    return answer;
}
 








    public void init()
    {
        input = new Channel(Short.TYPE, 1);
        output = new Channel(Short.TYPE, 1);
    }

    public void work()
    {
        short mLARp, temp, mrrp;
        mLARp = input.popShort();
        temp = gsm_abs(mLARp);
        if (temp < 11059)
            temp = shortify(temp << 1);
        else if (temp < 20070)
            temp = gsm_add(temp, (short) 11059);
        else
            temp = gsm_add((short) (temp >> 2), (short) 26112);
        mrrp = temp;
        if (mLARp < 0)
            mrrp = gsm_sub((short)0, mrrp);
        output.pushShort(mrrp);
    }
}

class ReflectionCoeffCalc extends Pipeline
{
    public void init()
    {
        add(new ReflectionCoeffLARpp());
        add(new ReflectionCoeffLARp());
        add(new ReflectionCoeffmrrp());
    }
}

class ReflectionCoeff extends SplitJoin
{
    public void init()
    {
        setSplitter(WEIGHTED_ROUND_ROBIN(160, 8));
         
        add(new Filter() {
                public void init() 
                {
                    this.input = new Channel(Short.TYPE, 160);
                    this.output = new Channel(Short.TYPE, 40);
                }
                public void work()
                {
                    int i;
                    for (i = 0; i < 120; i++)
                        this.input.popShort();
                    for (i = 0; i < 40; i++)
                        this.output.pushShort(this.input.popShort());
                }
            });
         
        add(new ReflectionCoeffCalc());
        setJoiner(WEIGHTED_ROUND_ROBIN(40, 8));
    }
}

class ShortTermReorder extends Filter
{
    short mdrp[];
    short mrrp[];
    
    public void init()
    {
        input = new Channel(Short.TYPE, 8 + 40);
        output = new Channel(Short.TYPE, (8 + 1) * 40);
        mdrp = new short[40];
        mrrp = new short[8];
    }
    
    public void work()
    {
        short val;
        int i, j;
        
         
        for (j = 0; j < 40; j++)
            mdrp[j] = input.popShort();
        for (j = 0; j < 8; j++)
            mrrp[j] = input.popShort();

         
        for (i = 0; i < 40; i++)
        {
            for (j = 0; j < 8; j++)
                output.pushShort(mrrp[j]);
            output.pushShort(mdrp[i]);
        }
    }
}

class ShortTermSynthCalc extends Filter
{
    short[] mrrp;
    short[] v;
 
 

 
 
short shortify(int a)
{
    if (a >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (a <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) a;
		}
	}
}
    
short gsm_add(short a, short b)

{
    long ltmp = (long) a + (long) b;
    if (ltmp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (ltmp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) ltmp;
		}
	}
}

short gsm_sub(short a, short b)
{
    long ltmp = (long) a - (long) b;
    if (ltmp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (ltmp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) ltmp;
		}
	}
}

short gsm_mult(short a, short b)
{
    long temp = (long) a * (long) b >> 15;
    if (temp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (temp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) temp;
		}
	}       
}

short gsm_mult_r(short a, short b)
{
    long temp = ((long) a * (long) b) + 16384;
    short answer = (short) (temp >> 15);
    return answer;
}

short gsm_abs(short a)
{
    short answer;
    int temp;
    if (a < 0)
	{
	    if (a == -32768)
		{
		    answer = 32767;
		}
	    else
		{
		    temp = a * -1;
		    if (temp >= 32767)
			{
			    answer = 32767;
			}
		    else
			{
			    if (temp <= -32768)
				{
				    answer = -32768;
				}
			    else
				{
				    answer = (short) temp;
				}
			}
		}
	}
    else
	{
	    answer = a;
	}
    return answer;
}
 









   
    public void init()
    {
        input = new Channel(Short.TYPE, 8  + 1);
        output = new Channel(Short.TYPE, 1);
        mrrp = new short[8 ];
	v = new short[9 ];
	for (int i = 0; i < 9 ; i++)
	    v[i] = 0;
    }

    public void work()
    {
        int i;
        short sri;
        
        for (i = 0; i < 8 ; i++)
            mrrp[i] = input.popShort();
        sri = input.popShort();
        for (i = 1; i < 8; i++)
        {
            sri = gsm_sub(sri, gsm_mult(mrrp[8-i], v[8-i]));
            v[9-i] = gsm_add(v[8-i], gsm_mult_r(mrrp[8-i], sri));
        }
        v[0] = sri;
        output.pushShort(sri);
    }
}

class ShortTermSynth extends Pipeline
{
    public void init()
    {
        add(new ShortTermReorder());
        add(new ShortTermSynthCalc());
    }
}

class LARInputFilter extends Filter
{
     
    short[] mdata;
    short[] single_frame;
    boolean donepushing;

 
 

 
 

 
public short[] mLarParameters;
public short[] mLtpOffset;
public short[] mLtpGain;
public short[] mRpeGridPosition;
public short[] mRpeMagnitude;
public short[] mSequence;

public void initInputArrays() {
    mLarParameters = new short[8];
    mLtpOffset = new short[4];
    mLtpGain = new short[4];
    mRpeGridPosition = new short[4];
    mRpeMagnitude = new short[4];
    mSequence = new short[4*13];
}

public void getParameters(short[] input)
{
    int i, j, k, l, m;
    int input_index = 0;
    int num_bits = 0;

    initInputArrays();
    for(i = 0; i < 8; i++)
	{
	
	    switch(i)
		{
		case 0:
		case 1:      num_bits = 6;
		    break;
		case 2:      
		case 3:      num_bits = 5;
		    break;
		case 4:      
		case 5:      num_bits = 4;
		    break;
		case 6:      
		case 7:      num_bits = 3;
		    break;
		}
	
	  
	    mLarParameters[i] = 0;
	    for (j = 0; j < num_bits; j++, input_index++)
		{
		    mLarParameters[i] |= input[input_index] << (num_bits - 1 - i);
		}
	}
    
     
    for (k = 0; k < 4; k++)
	{
	    mLtpOffset[k] = 0;
	    for (l = 0; l < 7; l++)
		{
		    mLtpOffset[k] |= input[input_index] << (6 - l);
		    input_index++;
		}
	    mLtpGain[k] = 0;
	    for (l = 0; l < 2; l++)
		{
		    mLtpGain[k] |= input[input_index] << (1 - l);
		    input_index++;
		}
	    mRpeGridPosition[k] = 0;
	    for (l = 0; l < 2; l++)
		{
		    mRpeGridPosition[k] |= input[input_index] << (1 - l);
		    input_index++;
		}
	    mRpeMagnitude[k] = 0;
	    for (l = 0; l < 6; l++)
		{
		    mRpeMagnitude[k] |= input[input_index] << (5 - l);
		    input_index++;
		}
	    for(l = 0; l < 13; l++)
		{
		    mSequence[k+4*l] = 0;
		    for (m = 0; m < 3; m++)
			{
			    mSequence[k+4*l] |= input[input_index] << (2 - m);
			    input_index++;
			}
	    
		}
	}
     
     
    
}

 






    public void init()
    {
	mdata = new short[260 ];
	single_frame = new short[260 ];
	input = new Channel(Short.TYPE, 260);
	output = new Channel(Short.TYPE, 8); 
	donepushing = false;
    }

    public void work()
    {
	int i, j, k;
	 
	for (i = 0; i < 260 ; i++)
	    {
		mdata[i] = input.popShort();
	    }

	if (donepushing)
	    {
		 
	    }
	 
	 
		for (k = 0; k < 260 ; k++)
		    {
			single_frame[k] = mdata[k];
		    }
		getParameters(single_frame);
		 
	  
	
		 
		for (i = 0; i < 8; i++)
		    {
			output.pushShort(mLarParameters[i]);
		    }
		donepushing = true;
		 
	 

    }
}
class PostProcessingFilter extends Filter 
{
    short msr;

 

 
 
short shortify(int a)
{
    if (a >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (a <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) a;
		}
	}
}
    
short gsm_add(short a, short b)

{
    long ltmp = (long) a + (long) b;
    if (ltmp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (ltmp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) ltmp;
		}
	}
}

short gsm_sub(short a, short b)
{
    long ltmp = (long) a - (long) b;
    if (ltmp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (ltmp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) ltmp;
		}
	}
}

short gsm_mult(short a, short b)
{
    long temp = (long) a * (long) b >> 15;
    if (temp >= 32767)
	{
	    return 32767;
	}
    else
	{
	    if (temp <= -32768)
		{
		    return -32768;
		}
	    else
		{
		    return (short) temp;
		}
	}       
}

short gsm_mult_r(short a, short b)
{
    long temp = ((long) a * (long) b) + 16384;
    short answer = (short) (temp >> 15);
    return answer;
}

short gsm_abs(short a)
{
    short answer;
    int temp;
    if (a < 0)
	{
	    if (a == -32768)
		{
		    answer = 32767;
		}
	    else
		{
		    temp = a * -1;
		    if (temp >= 32767)
			{
			    answer = 32767;
			}
		    else
			{
			    if (temp <= -32768)
				{
				    answer = -32768;
				}
			    else
				{
				    answer = (short) temp;
				}
			}
		}
	}
    else
	{
	    answer = a;
	}
    return answer;
}
 








    public void init() 
    {
	input = new Channel(Short.TYPE, 1);
	output = new Channel(Short.TYPE, 1);
	msr = 0;  
    }

    public void work() 
    {
	int a;
	short i, k, temp;
        
        temp = input.popShort();

	 
        temp = gsm_add(temp, gsm_mult_r(msr, (short) 28180));
        msr = temp;  

	 
        temp = gsm_add(temp, temp);
        
	 
        temp = shortify(temp / 8);
        temp = gsm_mult(temp, (short)8);
        
        output.pushShort(temp);
    }
}

class LTPInputFilter extends Filter
{
     
    short[] mdata;
    short[] single_frame;
    boolean donepushing;

 
 

 
 

 
public short[] mLarParameters;
public short[] mLtpOffset;
public short[] mLtpGain;
public short[] mRpeGridPosition;
public short[] mRpeMagnitude;
public short[] mSequence;

public void initInputArrays() {
    mLarParameters = new short[8];
    mLtpOffset = new short[4];
    mLtpGain = new short[4];
    mRpeGridPosition = new short[4];
    mRpeMagnitude = new short[4];
    mSequence = new short[4*13];
}

public void getParameters(short[] input)
{
    int i, j, k, l, m;
    int input_index = 0;
    int num_bits = 0;

    initInputArrays();
    for(i = 0; i < 8; i++)
	{
	
	    switch(i)
		{
		case 0:
		case 1:      num_bits = 6;
		    break;
		case 2:      
		case 3:      num_bits = 5;
		    break;
		case 4:      
		case 5:      num_bits = 4;
		    break;
		case 6:      
		case 7:      num_bits = 3;
		    break;
		}
	
	  
	    mLarParameters[i] = 0;
	    for (j = 0; j < num_bits; j++, input_index++)
		{
		    mLarParameters[i] |= input[input_index] << (num_bits - 1 - i);
		}
	}
    
     
    for (k = 0; k < 4; k++)
	{
	    mLtpOffset[k] = 0;
	    for (l = 0; l < 7; l++)
		{
		    mLtpOffset[k] |= input[input_index] << (6 - l);
		    input_index++;
		}
	    mLtpGain[k] = 0;
	    for (l = 0; l < 2; l++)
		{
		    mLtpGain[k] |= input[input_index] << (1 - l);
		    input_index++;
		}
	    mRpeGridPosition[k] = 0;
	    for (l = 0; l < 2; l++)
		{
		    mRpeGridPosition[k] |= input[input_index] << (1 - l);
		    input_index++;
		}
	    mRpeMagnitude[k] = 0;
	    for (l = 0; l < 6; l++)
		{
		    mRpeMagnitude[k] |= input[input_index] << (5 - l);
		    input_index++;
		}
	    for(l = 0; l < 13; l++)
		{
		    mSequence[k+4*l] = 0;
		    for (m = 0; m < 3; m++)
			{
			    mSequence[k+4*l] |= input[input_index] << (2 - m);
			    input_index++;
			}
	    
		}
	}
     
     
    
}

 





    public void init()
    {
	mdata = new short[260 ];
	single_frame = new short[260 ];
	input = new Channel(Short.TYPE, 260);
	output = new Channel(Short.TYPE, 8);
	donepushing = false;
    }

    public void work()
    {
	int i, j, k;
	 
	for (i = 0; i < 260 ; i++)
	    {
		mdata[i] = input.popShort();
	    }

	if (donepushing)
	    {
		 
	    }
	 
	 
		for (k = 0; k < 260 ; k++)
		    {
			single_frame[k] = mdata[k];
		    }
		getParameters(single_frame);
		 
	  	  
	  
		 
		for (i = 0; i < 4; i++)
		    {
			output.pushShort(mLtpGain[i]);
			output.pushShort(mLtpOffset[i]);
		    }
		 
	donepushing = true;
	 
    }
}
class LTPPipeline extends Pipeline
{
    public void init()
    {
	this.add(new FileReader("BinarySmallEndianDecoderInput1", Short.TYPE));
	this.add(new LTPInputFilter());
	 
    }
}
class LARPipeline extends Pipeline
{
    public void init()
    {
	this.add(new FileReader("BinarySmallEndianDecoderInput1", Short.TYPE));
	this.add(new LARInputFilter());
	 
    }
}

class LTPInputSplitJoin extends SplitJoin
{
    public void init()
    {
	this.setSplitter(WEIGHTED_ROUND_ROBIN (0, 1));
	this.add(new LTPPipeline());
	this.add(new Identity(Short.TYPE));
	 
	this.setJoiner(WEIGHTED_ROUND_ROBIN(2, 160));  
    }
}

class LTPLoopStream extends Pipeline
{
    public void init()
    {
	this.add(new LTPInputSplitJoin());
         
        this.add(new LTPFilter());
         
    }
}
class DecoderFeedback extends FeedbackLoop
{
    public void init()
    {
	this.setDelay(1);
	this.setJoiner(WEIGHTED_ROUND_ROBIN (40, 1));   
  	 
	this.setBody(new StupidStream());  
	this.setSplitter(DUPLICATE ());   
	 
	 
	 
 	this.setLoop(new LTPLoopStream());
    }

    public short initPathShort(int index)
    {
	return 0;
    }
	
}


class StupidStream extends Pipeline
{
    public void init()
    {
	 
	this.add(new AdditionUpdateFilter());
	 
    }
}

class LARInputSplitJoin extends SplitJoin
{
    public void init()
    {
	this.setSplitter(WEIGHTED_ROUND_ROBIN (1, 0));   
	this.add(new Identity(Short.TYPE));
	this.add(new LARPipeline());	
	this.setJoiner(WEIGHTED_ROUND_ROBIN(160, 8));   
    }
}

class RPEInputFilter extends Filter
{
     
    short[] mdata;
    short[] single_frame;
    boolean donepushing;

 
 

 
 

 
public short[] mLarParameters;
public short[] mLtpOffset;
public short[] mLtpGain;
public short[] mRpeGridPosition;
public short[] mRpeMagnitude;
public short[] mSequence;

public void initInputArrays() {
    mLarParameters = new short[8];
    mLtpOffset = new short[4];
    mLtpGain = new short[4];
    mRpeGridPosition = new short[4];
    mRpeMagnitude = new short[4];
    mSequence = new short[4*13];
}

public void getParameters(short[] input)
{
    int i, j, k, l, m;
    int input_index = 0;
    int num_bits = 0;

    initInputArrays();
    for(i = 0; i < 8; i++)
	{
	
	    switch(i)
		{
		case 0:
		case 1:      num_bits = 6;
		    break;
		case 2:      
		case 3:      num_bits = 5;
		    break;
		case 4:      
		case 5:      num_bits = 4;
		    break;
		case 6:      
		case 7:      num_bits = 3;
		    break;
		}
	
	  
	    mLarParameters[i] = 0;
	    for (j = 0; j < num_bits; j++, input_index++)
		{
		    mLarParameters[i] |= input[input_index] << (num_bits - 1 - i);
		}
	}
    
     
    for (k = 0; k < 4; k++)
	{
	    mLtpOffset[k] = 0;
	    for (l = 0; l < 7; l++)
		{
		    mLtpOffset[k] |= input[input_index] << (6 - l);
		    input_index++;
		}
	    mLtpGain[k] = 0;
	    for (l = 0; l < 2; l++)
		{
		    mLtpGain[k] |= input[input_index] << (1 - l);
		    input_index++;
		}
	    mRpeGridPosition[k] = 0;
	    for (l = 0; l < 2; l++)
		{
		    mRpeGridPosition[k] |= input[input_index] << (1 - l);
		    input_index++;
		}
	    mRpeMagnitude[k] = 0;
	    for (l = 0; l < 6; l++)
		{
		    mRpeMagnitude[k] |= input[input_index] << (5 - l);
		    input_index++;
		}
	    for(l = 0; l < 13; l++)
		{
		    mSequence[k+4*l] = 0;
		    for (m = 0; m < 3; m++)
			{
			    mSequence[k+4*l] |= input[input_index] << (2 - m);
			    input_index++;
			}
	    
		}
	}
     
     
    
}

 



    
    public void init()
    {
	mdata = new short[260 ];
	single_frame = new short[260 ];
	input = new Channel(Short.TYPE, 260);
	output = new Channel(Short.TYPE, 60); 
	donepushing = false;
    }

    public void work()
    {
	int i, j, k, a;
	 
	 
	for (i = 0; i < 260 ; i++)
	    {
		mdata[i] = input.popShort();
	    }

	if (donepushing)
	    {
		 
	    }

	 
	 
		for (k = 0; k < 260 ; k++)
		    {
			single_frame[k] = mdata[k];
		    }
		getParameters(single_frame);
		 
	  
	  
		 
		for (i = 0; i < 4; i++)
		    {
			for (a = 0; a < 13; a++)
			    {
				output.pushShort(mSequence[i+4*a]);
			    }
			output.pushShort(mRpeMagnitude[i]);
			output.pushShort(mRpeGridPosition[i]);
		    }
		donepushing = true;
		 
	 
    }
}

 





class HoldFilter extends Filter
{
    short[] mDrp;



    public void init()
    {
	input = new Channel(Short.TYPE, 160);
	output = new Channel(Short.TYPE, 40);
	mDrp = new short[160 ];
    }

    public void work()
    {
	int i, j;
	for (i = 0; i < 160 ; i++)
	    {
		mDrp[i] = input.popShort();
	    }
	for (j = 0; j < 40; j++)
	    {
		output.pushShort(mDrp[j + 120]);
	    }
	 
    }
    
}

class ShortPrinter extends Filter
{
    char c;
    ShortPrinter (char c2)
    {
	super (c2);
    }
    public void init(char c2)
    {  
	input = new Channel(Short.TYPE, 1);
	output = new Channel(Short.TYPE, 1);
	this.c = c2;
    }

    public void work()
    {
	short a = input.popShort();
	output.pushShort(a);
	System.out.println(c);
	System.out.println(a);
    }
}

public class Gsm extends StreamIt 
{
     
    public static void main(String args[]) 
    {
	new Gsm().run(args); 
	
    }

    public void init() {
	
	this.add(new FileReader("BinarySmallEndianDecoderInput1", Short.TYPE));
	 
	this.add(new RPEInputFilter());
	 
	this.add(new RPEDecodeFilter());
	this.add(new DecoderFeedback());
	 
	this.add(new HoldFilter());
	this.add(new LARInputSplitJoin());
	this.add(new ReflectionCoeff());
	this.add(new ShortTermSynth());
	this.add(new PostProcessingFilter());
	 
	this.add(new streamit.io.FileWriter("BinarySmallEndianDecoderOutput1", Short.TYPE));	
    }
}