DCT.cs

    public unsafe class DCT
    {
        private double[]  Coeff;
        private double[] ICoeff;
        private double*  CoeffPtr;
        private double* ICoeffPtr;

        private int     N;
        private int  TwoN;
        private int QuadN;

        private short u, v, x, y;

        public DCT()
        {
            int n = 8;
                N = n;
             TwoN = n * n;
            QuadN = n * n * n * n;

             Coeff = new double[QuadN];
            ICoeff = new double[QuadN];
            fixed (double* tempPtr =  Coeff)  CoeffPtr = tempPtr;
            fixed (double* tempPtr = ICoeff) ICoeffPtr = tempPtr;

            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 (u = 0; u < N; u++)
                for (v = 0; v < N; v++)
                    for (y = 0; y < N; y++)
                        for (x = 0; x < N; x++)
                            ICoeffPtr[((y * N + x) * N + u) * N + v] =
                             CoeffPtr[((u * N + v) * N + y) * N + 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++, Out++)
                {
                    for (*Out = 0, y = 0; y < N; y++)
                    {
                        t += In[0] * CoeffPtr[0];
                        t += In[1] * CoeffPtr[1];
                        t += In[2] * CoeffPtr[2];
                        t += In[3] * CoeffPtr[3];
                        t += In[4] * CoeffPtr[4];
                        t += In[5] * CoeffPtr[5];
                        t += In[6] * CoeffPtr[6];
                        t += In[7] * CoeffPtr[7];

                        In += 8; ICoeffPtr += 8;
                    }
                    In -= TwoN;
                }
            Out -= TwoN;
            CoeffPtr -= QuadN;
        }

        public void Inverse(double* In, sbyte* Out)
        {
            for (v = 0; v < N; v++)
                for (u = 0; u < N; u++, Out++)
                {
                    for (t = 0, y = 0; y < N; y++)
                    {
                        t += In[0] * ICoeffPtr[0];
                        t += In[1] * ICoeffPtr[1];
                        t += In[2] * ICoeffPtr[2];
                        t += In[3] * ICoeffPtr[3];
                        t += In[4] * ICoeffPtr[4];
                        t += In[5] * ICoeffPtr[5];
                        t += In[6] * ICoeffPtr[6];
                        t += In[7] * ICoeffPtr[7];

                        In += 8; ICoeffPtr += 8;
                    }
                    *Out = t.CFTSB();
                    In -= TwoN;
                }
            Out -= TwoN;
            ICoeffPtr -= QuadN;
        }

        public void Straight(byte* In, double* Out)
        {
            for (v = 0; v < N; v++)
                for (u = 0; u < N; u++, Out++)
                {
                    for (*Out = 0, y = 0; y < N; y++)
                    {
                        t += (In[0] - 128) * CoeffPtr[0];
                        t += (In[1] - 128) * CoeffPtr[1];
                        t += (In[2] - 128) * CoeffPtr[2];
                        t += (In[3] - 128) * CoeffPtr[3];
                        t += (In[4] - 128) * CoeffPtr[4];
                        t += (In[5] - 128) * CoeffPtr[5];
                        t += (In[6] - 128) * CoeffPtr[6];
                        t += (In[7] - 128) * CoeffPtr[7];

                        In += 8; ICoeffPtr += 8;
                    }
                    In -= TwoN;
                }
            Out -= TwoN;
            CoeffPtr -= QuadN;
        }

        public void Inverse(double* In, byte* Out)
        {
            for (v = 0; v < N; v++)
                for (u = 0; u < N; u++, Out++)
                {
                    for (t = 0, y = 0; y < N; y++)
                    {
                        t += In[0] * ICoeffPtr[0];
                        t += In[1] * ICoeffPtr[1];
                        t += In[2] * ICoeffPtr[2];
                        t += In[3] * ICoeffPtr[3];
                        t += In[4] * ICoeffPtr[4];
                        t += In[5] * ICoeffPtr[5];
                        t += In[6] * ICoeffPtr[6];
                        t += In[7] * ICoeffPtr[7];

                        In += 8; ICoeffPtr += 8;
                    }
                    *Out = (byte)(t.CFTSB() + 128);
                    In -= TwoN;
                }
            Out -= TwoN;
            ICoeffPtr -= QuadN;
        }

        public void Straight(double* In, double* Out)
        {
            for (v = 0; v < N; v++)
                for (u = 0; u < N; u++, Out++)
                {
                    for (*Out = 0, y = 0; y < N; y++)
                    {
                        *Out += In[0] * CoeffPtr[0];
                        *Out += In[1] * CoeffPtr[1];
                        *Out += In[2] * CoeffPtr[2];
                        *Out += In[3] * CoeffPtr[3];
                        *Out += In[4] * CoeffPtr[4];
                        *Out += In[5] * CoeffPtr[5];
                        *Out += In[6] * CoeffPtr[6];
                        *Out += In[7] * CoeffPtr[7];

                        In += 8; CoeffPtr += 8;
                    }
                    In -= TwoN;
                }
            Out -= TwoN;
            CoeffPtr -= QuadN;
        }

        public void Inverse(double* In, double* Out)
        {
            for (v = 0; v < N; v++)
                for (u = 0; u < N; u++, Out++)
                {
                    for (*Out = 0, y = 0; y < N; y++)
                    {
                        *Out += In[0] * ICoeffPtr[0];
                        *Out += In[1] * ICoeffPtr[1];
                        *Out += In[2] * ICoeffPtr[2];
                        *Out += In[3] * ICoeffPtr[3];
                        *Out += In[4] * ICoeffPtr[4];
                        *Out += In[5] * ICoeffPtr[5];
                        *Out += In[6] * ICoeffPtr[6];
                        *Out += In[7] * ICoeffPtr[7];

                        In += 8; ICoeffPtr += 8;
                    }
                    In -= TwoN;
                }
            Out -= TwoN;
            ICoeffPtr -= QuadN;
        }
    }

    public static class Exter
    {
        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;
        }
    }