Implementing or porting an accurate, SIMD optimized IDCT algorithm #306

We are constantly (re)evaluating the design and implementation plans for our Jpeg decoder, but one thing is sure: we can't go without a SIMD-optimized and accurate IDCT (Inverse Discrete Cosine Transform) implementation.

The issue description is in WIP state. I'm trying to add notes here while doing research.

What we currently have:

• A floating point method ported from an SSE C++ implementation.
  • This one is very fast but seems to be inaccurate
• A standard + unoptimized integer method ported from libjpeg.
  • This one seems to be accurate and standard-comforming

What we need

A standard conformant, accurate implementation, that's fast enough. Most likely a floating point one.
Good candidates:

• A SIMD-optimized variant of the standard floating-point method
  • Based on: Arai, Agui, and Nakajima: "A fast DCT-SQ scheme for images"
  • Ported to assembly in libjpeg-turbo
• The default integer methods used by libjpeg-turbo

We need to SIMD-optimize our color conversion code as well, and we should use Vector<float> or Vector4 for that. I think, we should expect better accuracy and performance, if our entire post processing chain is done with floats, so I would prefer floating point IDCT implementations over integer ones.

On .NET SIMD API-s

• I don't know when do the new .NET SIMD API-s land. Even if ETA is not that much, I'm afraid using them will hurt the portability and cross-platform nature of ImageSharp. So, unless someone has a good reason, I prefer not using them.
• In my experience, even Vector<T> is not mature enough at the moment. SIMD support for different methods is not well documented. It's easy to loose it, eg. by using Vector<T> as a struct member. Some reverse-engineering hints on this topic could be found here.
• In short: I think having an implementation that uses nothing more than the plain-old Vector4 should be good enough, but correct me if I am wrong! :)

Testing conformance and accuracy

We should unit-test our algorithms against reference implentations in the following way:

We have accurate, mathematically correct FDCT/IDCT reference implementations in our test code base. We should always test the new ones against them.