synthesisfilter.java

JLayer is a library that decodes/plays/converts MPEG 1/2/2.5 Layer 1/2/3 (i.e. MP3) in real time fo

					(vp[14 + dvp] * dp[3]) +
					(vp[13 + dvp] * dp[4]) +
					(vp[12 + dvp] * dp[5]) +
					(vp[11 + dvp] * dp[6]) +
					(vp[10 + dvp] * dp[7]) +
					(vp[9 + dvp] * dp[8]) +
					(vp[8 + dvp] * dp[9]) +
					(vp[7 + dvp] * dp[10]) +
					(vp[6 + dvp] * dp[11]) +
					(vp[5 + dvp] * dp[12]) +
					(vp[4 + dvp] * dp[13]) +
					(vp[3 + dvp] * dp[14]) +
					(vp[2 + dvp] * dp[15])
					) * scalefactor);

            tmpOut[i] = pcm_sample;
			
			dvp += 16;
         } // for
  }
    private void compute_pcm_samples2(Obuffer buffer)
  {
	final float[] vp = actual_v;
	
	//int inc = v_inc;
	final float[] tmpOut = _tmpOut;
	 int dvp =0;
	
			// fat chance of having this loop unroll
			for( int i=0; i<32; i++)
			{
				final float[] dp = d16[i];
				float pcm_sample;

				pcm_sample = (float)(((vp[2 + dvp] * dp[0]) +
					(vp[1 + dvp] * dp[1]) +
					(vp[0 + dvp] * dp[2]) +
					(vp[15 + dvp] * dp[3]) +
					(vp[14 + dvp] * dp[4]) +
					(vp[13 + dvp] * dp[5]) +
					(vp[12 + dvp] * dp[6]) +
					(vp[11 + dvp] * dp[7]) +
					(vp[10 + dvp] * dp[8]) +
					(vp[9 + dvp] * dp[9]) +
					(vp[8 + dvp] * dp[10]) +
					(vp[7 + dvp] * dp[11]) +
					(vp[6 + dvp] * dp[12]) +
					(vp[5 + dvp] * dp[13]) +
					(vp[4 + dvp] * dp[14]) +
					(vp[3 + dvp] * dp[15])
					) * scalefactor);

            tmpOut[i] = pcm_sample;
			
			dvp += 16;
			} // for
	}
	
	  private void compute_pcm_samples3(Obuffer buffer)
  {
	final float[] vp = actual_v;
	
	int idx = 0;
	//int inc = v_inc;
	final float[] tmpOut = _tmpOut;
	 int dvp =0;
	
			// fat chance of having this loop unroll
			for( int i=0; i<32; i++)
			{
				final float[] dp = d16[i];
				float pcm_sample;

				pcm_sample = (float)(((vp[3 + dvp] * dp[0]) +
					(vp[2 + dvp] * dp[1]) +
					(vp[1 + dvp] * dp[2]) +
					(vp[0 + dvp] * dp[3]) +
					(vp[15 + dvp] * dp[4]) +
					(vp[14 + dvp] * dp[5]) +
					(vp[13 + dvp] * dp[6]) +
					(vp[12 + dvp] * dp[7]) +
					(vp[11 + dvp] * dp[8]) +
					(vp[10 + dvp] * dp[9]) +
					(vp[9 + dvp] * dp[10]) +
					(vp[8 + dvp] * dp[11]) +
					(vp[7 + dvp] * dp[12]) +
					(vp[6 + dvp] * dp[13]) +
					(vp[5 + dvp] * dp[14]) +
					(vp[4 + dvp] * dp[15])
					) * scalefactor);

            tmpOut[i] = pcm_sample;
			
			dvp += 16;
			} // for
	  }
			
  private void compute_pcm_samples4(Obuffer buffer)
  {
	final float[] vp = actual_v;
	
	//int inc = v_inc;
	final float[] tmpOut = _tmpOut;
	 int dvp =0;
	
			// fat chance of having this loop unroll
			for( int i=0; i<32; i++)
			{
				final float[] dp = d16[i];
				float pcm_sample;

				pcm_sample = (float)(((vp[4 + dvp] * dp[0]) +
					(vp[3 + dvp] * dp[1]) +
					(vp[2 + dvp] * dp[2]) +
					(vp[1 + dvp] * dp[3]) +
					(vp[0 + dvp] * dp[4]) +
					(vp[15 + dvp] * dp[5]) +
					(vp[14 + dvp] * dp[6]) +
					(vp[13 + dvp] * dp[7]) +
					(vp[12 + dvp] * dp[8]) +
					(vp[11 + dvp] * dp[9]) +
					(vp[10 + dvp] * dp[10]) +
					(vp[9 + dvp] * dp[11]) +
					(vp[8 + dvp] * dp[12]) +
					(vp[7 + dvp] * dp[13]) +
					(vp[6 + dvp] * dp[14]) +
					(vp[5 + dvp] * dp[15])
					) * scalefactor);

            tmpOut[i] = pcm_sample;
			
			dvp += 16;
			} // for
  }
  
  private void compute_pcm_samples5(Obuffer buffer)
  {
	final float[] vp = actual_v;
	
	//int inc = v_inc;
	final float[] tmpOut = _tmpOut;
	 int dvp =0;
	
			// fat chance of having this loop unroll
			for( int i=0; i<32; i++)
			{
				final float[] dp = d16[i];
				float pcm_sample;

				pcm_sample = (float)(((vp[5 + dvp] * dp[0]) +
					(vp[4 + dvp] * dp[1]) +
					(vp[3 + dvp] * dp[2]) +
					(vp[2 + dvp] * dp[3]) +
					(vp[1 + dvp] * dp[4]) +
					(vp[0 + dvp] * dp[5]) +
					(vp[15 + dvp] * dp[6]) +
					(vp[14 + dvp] * dp[7]) +
					(vp[13 + dvp] * dp[8]) +
					(vp[12 + dvp] * dp[9]) +
					(vp[11 + dvp] * dp[10]) +
					(vp[10 + dvp] * dp[11]) +
					(vp[9 + dvp] * dp[12]) +
					(vp[8 + dvp] * dp[13]) +
					(vp[7 + dvp] * dp[14]) +
					(vp[6 + dvp] * dp[15])
					) * scalefactor);

            tmpOut[i] = pcm_sample;
			
			dvp += 16;
			} // for
  }
  
  private void compute_pcm_samples6(Obuffer buffer)
  {
	final float[] vp = actual_v;	
	//int inc = v_inc;
	final float[] tmpOut = _tmpOut;
	 int dvp =0;
	
			// fat chance of having this loop unroll
			for( int i=0; i<32; i++)
			{
				final float[] dp = d16[i];
				float pcm_sample;

				pcm_sample = (float)(((vp[6 + dvp] * dp[0]) +
					(vp[5 + dvp] * dp[1]) +
					(vp[4 + dvp] * dp[2]) +
					(vp[3 + dvp] * dp[3]) +
					(vp[2 + dvp] * dp[4]) +
					(vp[1 + dvp] * dp[5]) +
					(vp[0 + dvp] * dp[6]) +
					(vp[15 + dvp] * dp[7]) +
					(vp[14 + dvp] * dp[8]) +
					(vp[13 + dvp] * dp[9]) +
					(vp[12 + dvp] * dp[10]) +
					(vp[11 + dvp] * dp[11]) +
					(vp[10 + dvp] * dp[12]) +
					(vp[9 + dvp] * dp[13]) +
					(vp[8 + dvp] * dp[14]) +
					(vp[7 + dvp] * dp[15])
					) * scalefactor);

            tmpOut[i] = pcm_sample;
			
			dvp += 16;
			} // for
  }
  
    private void compute_pcm_samples7(Obuffer buffer)
  {
	final float[] vp = actual_v;
	
	//int inc = v_inc;
	final float[] tmpOut = _tmpOut;
	 int dvp =0;
	
			// fat chance of having this loop unroll
			for( int i=0; i<32; i++)
			{
				final float[] dp = d16[i];
				float pcm_sample;

				pcm_sample = (float)(((vp[7 + dvp] * dp[0]) +
					(vp[6 + dvp] * dp[1]) +
					(vp[5 + dvp] * dp[2]) +
					(vp[4 + dvp] * dp[3]) +
					(vp[3 + dvp] * dp[4]) +
					(vp[2 + dvp] * dp[5]) +
					(vp[1 + dvp] * dp[6]) +
					(vp[0 + dvp] * dp[7]) +
					(vp[15 + dvp] * dp[8]) +
					(vp[14 + dvp] * dp[9]) +
					(vp[13 + dvp] * dp[10]) +
					(vp[12 + dvp] * dp[11]) +
					(vp[11 + dvp] * dp[12]) +
					(vp[10 + dvp] * dp[13]) +
					(vp[9 + dvp] * dp[14]) +
					(vp[8 + dvp] * dp[15])
					) * scalefactor);

            tmpOut[i] = pcm_sample;
			
			dvp += 16;
			} // for
	}
  private void compute_pcm_samples8(Obuffer buffer)
  {
	final float[] vp = actual_v;
	
	//int inc = v_inc;
	final float[] tmpOut = _tmpOut;
	 int dvp =0;
	
			// fat chance of having this loop unroll
			for( int i=0; i<32; i++)
			{
				final float[] dp = d16[i];
				float pcm_sample;

				pcm_sample = (float)(((vp[8 + dvp] * dp[0]) +
					(vp[7 + dvp] * dp[1]) +
					(vp[6 + dvp] * dp[2]) +
					(vp[5 + dvp] * dp[3]) +
					(vp[4 + dvp] * dp[4]) +
					(vp[3 + dvp] * dp[5]) +
					(vp[2 + dvp] * dp[6]) +
					(vp[1 + dvp] * dp[7]) +
					(vp[0 + dvp] * dp[8]) +
					(vp[15 + dvp] * dp[9]) +
					(vp[14 + dvp] * dp[10]) +
					(vp[13 + dvp] * dp[11]) +
					(vp[12 + dvp] * dp[12]) +
					(vp[11 + dvp] * dp[13]) +
					(vp[10 + dvp] * dp[14]) +
					(vp[9 + dvp] * dp[15])
					) * scalefactor);

            tmpOut[i] = pcm_sample;
			
			dvp += 16;
			} // for
  }
  
  private void compute_pcm_samples9(Obuffer buffer)
  {
	final float[] vp = actual_v;
	
	//int inc = v_inc;
	final float[] tmpOut = _tmpOut;
	 int dvp =0;
	
			// fat chance of having this loop unroll
			for( int i=0; i<32; i++)
			{
				final float[] dp = d16[i];
				float pcm_sample;

				pcm_sample = (float)(((vp[9 + dvp] * dp[0]) +
					(vp[8 + dvp] * dp[1]) +
					(vp[7 + dvp] * dp[2]) +
					(vp[6 + dvp] * dp[3]) +
					(vp[5 + dvp] * dp[4]) +
					(vp[4 + dvp] * dp[5]) +
					(vp[3 + dvp] * dp[6]) +
					(vp[2 + dvp] * dp[7]) +
					(vp[1 + dvp] * dp[8]) +
					(vp[0 + dvp] * dp[9]) +
					(vp[15 + dvp] * dp[10]) +
					(vp[14 + dvp] * dp[11]) +
					(vp[13 + dvp] * dp[12]) +
					(vp[12 + dvp] * dp[13]) +
					(vp[11 + dvp] * dp[14]) +
					(vp[10 + dvp] * dp[15])
					) * scalefactor);

            tmpOut[i] = pcm_sample;
			
			dvp += 16;
			} // for
  }
  
  private void compute_pcm_samples10(Obuffer buffer)
  {
	final float[] vp = actual_v;	
	//int inc = v_inc;
	final float[] tmpOut = _tmpOut;
	 int dvp =0;
	
			// fat chance of having this loop unroll
			for( int i=0; i<32; i++)
			{
				final float[] dp = d16[i];
				float pcm_sample;

				pcm_sample = (float)(((vp[10 + dvp] * dp[0]) +
					(vp[9 + dvp] * dp[1]) +
					(vp[8 + dvp] * dp[2]) +
					(vp[7 + dvp] * dp[3]) +
					(vp[6 + dvp] * dp[4]) +
					(vp[5 + dvp] * dp[5]) +
					(vp[4 + dvp] * dp[6]) +
					(vp[3 + dvp] * dp[7]) +
					(vp[2 + dvp] * dp[8]) +
					(vp[1 + dvp] * dp[9]) +
					(vp[0 + dvp] * dp[10]) +
					(vp[15 + dvp] * dp[11]) +
					(vp[14 + dvp] * dp[12]) +
					(vp[13 + dvp] * dp[13]) +
					(vp[12 + dvp] * dp[14]) +
					(vp[11 + dvp] * dp[15])
					) * scalefactor);

            tmpOut[i] = pcm_sample;
			
			dvp += 16;
			} // for
  }
  private void compute_pcm_samples11(Obuffer buffer)
  {
	final float[] vp = actual_v;
	
	//int inc = v_inc;
	final float[] tmpOut = _tmpOut;
	 int dvp =0;
	
			// fat chance of having this loop unroll
			for( int i=0; i<32; i++)
			{
				final float[] dp = d16[i];
				float pcm_sample;

				pcm_sample = (float)(((vp[11 + dvp] * dp[0]) +
					(vp[10 + dvp] * dp[1]) +
					(vp[9 + dvp] * dp[2]) +
					(vp[8 + dvp] * dp[3]) +
					(vp[7 + dvp] * dp[4]) +
					(vp[6 + dvp] * dp[5]) +
					(vp[5 + dvp] * dp[6]) +
					(vp[4 + dvp] * dp[7]) +
					(vp[3 + dvp] * dp[8]) +
					(vp[2 + dvp] * dp[9]) +
					(vp[1 + dvp] * dp[10]) +
					(vp[0 + dvp] * dp[11]) +
					(vp[15 + dvp] * dp[12]) +
					(vp[14 + dvp] * dp[13]) +
					(vp[13 + dvp] * dp[14]) +
					(vp[12 + dvp] * dp[15])
					) * scalefactor);

            tmpOut[i] = pcm_sample;
			
			dvp += 16;
			} // for
  }
    private void compute_pcm_samples12(Obuffer buffer)
  {
	final float[] vp = actual_v;	
	//int inc = v_inc;
	final float[] tmpOut = _tmpOut;
	 int dvp =0;
	
			// fat chance of having this loop unroll
			for( int i=0; i<32; i++)
			{
			    final float[] dp = d16[i];
				float pcm_sample;

				pcm_sample = (float)(((vp[12 + dvp] * dp[0]) +
					(vp[11 + dvp] * dp[1]) +
					(vp[10 + dvp] * dp[2]) +
					(vp[9 + dvp] * dp[3]) +
					(vp[8 + dvp] * dp[4]) +
					(vp[7 + dvp] * dp[5]) +
					(vp[6 + dvp] * dp[6]) +
					(vp[5 + dvp] * dp[7]) +
					(vp[4 + dvp] * dp[8]) +
					(vp[3 + dvp] * dp[9]) +
					(vp[2 + dvp] * dp[10]) +
					(vp[1 + dvp] * dp[11]) +
					(vp[0 + dvp] * dp[12]) +
					(vp[15 + dvp] * dp[13]) +
					(vp[14 + dvp] * dp[14]) +
					(vp[13 + dvp] * dp[15])
					) * scalefactor);

            tmpOut[i] = pcm_sample;
			
			dvp += 16;
			} // for
	}
  private void compute_pcm_samples13(Obuffer buffer)
  {
	final float[] vp = actual_v;
	
	//int inc = v_inc;
	final float[] tmpOut = _tmpOut;
	 int dvp =0;
	
			// fat chance of having this loop unroll
			for( int i=0; i<32; i++)
			{
				final float[] dp = d16[i];
				float pcm_sample;

				pcm_sample = (float)(((vp[13 + dvp] * dp[0]) +
					(vp[12 + dvp] * dp[1]) +
					(vp[11 + dvp] * dp[2]) +
					(vp[10 + dvp] * dp[3]) +
					(vp[9 + dvp] * dp[4]) +
					(vp[8 + dvp] * dp[5]) +
					(vp[7 + dvp] * dp[6]) +
					(vp[6 + dvp] * dp[7]) +
					(vp[5 + dvp] * dp[8]) +