synfilt.cpp

MP3解压程序源代码

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

				buffer->append (channel, pcm_sample);
			} // for
		} break; // case 4:

		case 5: {
			// fat chance of having this loop unroll
			for( register const real *dp = d;
					 dp < d + (32 * 16);
					 dp += 16, vp += 16 ) {
				register real pcm_sample;

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

				buffer->append (channel, pcm_sample);
			} // for
		} break; // case 5:

		case 6: {
			// fat chance of having this loop unroll
			for( register const real *dp = d;
					 dp < d + (32 * 16);
					 dp += 16, vp += 16 ) {
				register real pcm_sample;

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

            buffer->append (channel, pcm_sample);
			} // for
		} break; // case 6:

		case 7: {
			// fat chance of having this loop unroll
			for( register const real *dp = d;
					 dp < d + (32 * 16);
					 dp += 16, vp += 16 ) {
				register real pcm_sample;

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

            buffer->append (channel, pcm_sample);
			} // for
		} break; // case 7:

		case 8: {
			// fat chance of having this loop unroll
			for( register const real *dp = d;
					 dp < d + (32 * 16);
					 dp += 16, vp += 16 ) {
				register real pcm_sample;

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

            buffer->append (channel, pcm_sample);
			} // for
		} break; // case 8:

		case 9: {
			// fat chance of having this loop unroll
			for( register const real *dp = d;
					 dp < d + (32 * 16);
					 dp += 16, vp += 16 ) {
				register real pcm_sample;

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

            buffer->append (channel, pcm_sample);
			} // for
		} break; // case 9:

		case 10: {
			// fat chance of having this loop unroll
			for( register const real *dp = d;
					 dp < d + (32 * 16);
					 dp += 16, vp += 16 ) {
				register real pcm_sample;

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

            buffer->append (channel, pcm_sample);
			} // for
		} break; // case 10:

		case 11: {
			// fat chance of having this loop unroll
			for( register const real *dp = d;
					 dp < d + (32 * 16);
					 dp += 16, vp += 16 ) {
				register real pcm_sample;

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

            buffer->append (channel, pcm_sample);
			} // for
		} break; // case 11:

		case 12: {
			// fat chance of having this loop unroll
			for( register const real *dp = d;
					 dp < d + (32 * 16);
					 dp += 16, vp += 16 ) {
				register real pcm_sample;

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

            buffer->append (channel, pcm_sample);
			} // for
		} break; // case 12:

		case 13: {
			// fat chance of having this loop unroll
			for( register const real *dp = d;
					 dp < d + (32 * 16);
					 dp += 16, vp += 16 ) {
				register real pcm_sample;

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

            buffer->append (channel, pcm_sample);
			} // for
		} break; // case 13:

		case 14: {
			// fat chance of having this loop unroll
			for( register const real *dp = d;
					 dp < d + (32 * 16);
					 dp += 16, vp += 16 ) {
				register real pcm_sample;

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

            buffer->append (channel, pcm_sample);
			} // for
		} break; // case 14:

		case 15: {
			// fat chance of having this loop unroll
			for( register const real *dp = d;
					 dp < d + (32 * 16);
					 dp += 16, vp += 16 ) {
				register real pcm_sample;

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

            buffer->append (channel, pcm_sample);
			} // for
		} break; // case 15:
	}; // switch (actual_write_pos)

	//buffer->appendblock (channel, a, 32);

}

void SynthesisFilter::calculate_pcm_samples(Obuffer *buffer)
{
	compute_new_v();
	compute_pcm_samples(buffer);

   actual_write_pos = (actual_write_pos + 1) & 0xf;
	actual_v = (actual_v == v1) ? v2 : v1;

	// initialize samples[]:
  for (register real *floatp = samples + 32; floatp > samples; )
	 *--floatp = 0.0f;
}