DCT.cs

    public class DCT
    {
        private double[,,,] Coeff;

        public byte N;
        public int TwoN => N * N;

        private short u, v, x, y;

        public DCT(byte N = 8)
        {
            this.N = N;
            Coeff = new double[N, N, N, N];

            double[] C = new double[N];
            C[0] = 0.70710678118654746;
            for (u = 1; u < N; u++) C[u] = 1;

            double coeff = 2.0 / N;
            double PiN = Math.PI / (TwoN * coeff);
            for (v = 0; v < N; v++)
                for (u = 0; u < N; u++)
                    for (y = 0; y < N; y++)
                        for (x = 0; x < N; x++)
                            Coeff[v, y, u, x] = coeff
                                * C[v] * Math.Cos(((y << 1) | 1) * v * PiN)
                                * C[u] * Math.Cos(((x << 1) | 1) * u * PiN);
        }

        private double t;

        public void Straight(sbyte[] In, double[] Out)
        {
            for (v = 0; v < N; v++)
                for (u = 0; u < N; u++)
                    for (y = 0; y < N; y++)
                        for (x = 0; x < N; x++)
                            Out[v * N + u] += In[y * N + x] * Coeff[v, y, u, x];
        }

        public void Inverse(double[] In, sbyte[] Out)
        {
            for (v = 0; v < N; v++)
                for (u = 0; u < N; u++)
                {
                    t = 0;
                    for (y = 0; y < N; y++)
                        for (x = 0; x < N; x++)
                            t += In[y * N + x] * Coeff[y, v, x, u];
                    Out[v * N + u] = t.CFTSB();
                }
        }

        public void Straight(byte[] In, double[] Out)
        {
            for (v = 0; v < N; v++)
                for (u = 0; u < N; u++)
                    for (y = 0; y < N; y++)
                        for (x = 0; x < N; x++)
                            Out[v * N + u] += (In[y * N + x] - 128) * Coeff[v, y, u, x];
        }

        public void Inverse(double[] In, byte[] Out)
        {
            for (v = 0; v < N; v++)
                for (u = 0; u < N; u++)
                {
                    t = 0;
                    for (y = 0; y < N; y++)
                        for (x = 0; x < N; x++)
                            t += In[y * N + x] * Coeff[y, v, x, u];
                    Out[v * N + u] = (byte)(t.CFTSB() + 128);
                }
        }

        private void _DCT(double[] In, double[] Out)
        {
            for (v = 0; v < N; v++)
                for (u = 0; u < N; u++)
                    for (y = 0; y < N; y++)
                        for (x = 0; x < N; x++)
                            Out[v * N + u] += In[y * N + x] * Coeff[v, y, u, x];
        }

        private void _IDCT(double[] In, double[] Out)
        {
            for (v = 0; v < N; v++)
                for (u = 0; u < N; u++)
                    for (y = 0; y < N; y++)
                        for (x = 0; x < N; x++)
                            Out[v * N + u] += In[y * N + x] * Coeff[y, v, x, u];
        }
    }

    public static class Extensions
    {
        public static sbyte CFTSB(this double c)
        {
            c = (float)Math.Round(c);
                 if (c >  0x7F) c =  0x7F;
            else if (c < -0x80) c = -0x80;
            return (sbyte)c;
        }
    }