SHARE
TWEET

DCT.cs

kujikita Mar 20th, 2019 75 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.     public unsafe class DCT
  2.     {
  3.         private double[]  Coeff;
  4.         private double[] ICoeff;
  5.         private double*  CoeffPtr;
  6.         private double* ICoeffPtr;
  7.  
  8.         private int     N;
  9.         private int  TwoN;
  10.         private int QuadN;
  11.  
  12.         private short u, v, x, y;
  13.  
  14.         public DCT()
  15.         {
  16.             int n = 8;
  17.                 N = n;
  18.              TwoN = n * n;
  19.             QuadN = n * n * n * n;
  20.  
  21.              Coeff = new double[QuadN];
  22.             ICoeff = new double[QuadN];
  23.             fixed (double* tempPtr =  Coeff)  CoeffPtr = tempPtr;
  24.             fixed (double* tempPtr = ICoeff) ICoeffPtr = tempPtr;
  25.  
  26.             double[] C = new double[N];
  27.             C[0] = 0.70710678118654746;
  28.             for (u = 1; u < N; u++) C[u] = 1;
  29.  
  30.             double coeff = 2.0 / N;
  31.             double PiN = Math.PI / (TwoN * coeff);
  32.             for (u = 0; u < N; u++)
  33.                 for (v = 0; v < N; v++)
  34.                     for (y = 0; y < N; y++)
  35.                         for (x = 0; x < N; x++)
  36.                             ICoeffPtr[((y * N + x) * N + u) * N + v] =
  37.                              CoeffPtr[((u * N + v) * N + y) * N + x] = coeff
  38.                                 * C[v] * Math.Cos(((y << 1) | 1) * v * PiN)
  39.                                 * C[u] * Math.Cos(((x << 1) | 1) * u * PiN);
  40.         }
  41.  
  42.         private double t;
  43.  
  44.         public void Straight(sbyte* In, double* Out)
  45.         {
  46.             for (v = 0; v < N; v++)
  47.                 for (u = 0; u < N; u++, Out++)
  48.                 {
  49.                     for (*Out = 0, y = 0; y < N; y++)
  50.                     {
  51.                         t += In[0] * CoeffPtr[0];
  52.                         t += In[1] * CoeffPtr[1];
  53.                         t += In[2] * CoeffPtr[2];
  54.                         t += In[3] * CoeffPtr[3];
  55.                         t += In[4] * CoeffPtr[4];
  56.                         t += In[5] * CoeffPtr[5];
  57.                         t += In[6] * CoeffPtr[6];
  58.                         t += In[7] * CoeffPtr[7];
  59.  
  60.                         In += 8; ICoeffPtr += 8;
  61.                     }
  62.                     In -= TwoN;
  63.                 }
  64.             Out -= TwoN;
  65.             CoeffPtr -= QuadN;
  66.         }
  67.  
  68.         public void Inverse(double* In, sbyte* Out)
  69.         {
  70.             for (v = 0; v < N; v++)
  71.                 for (u = 0; u < N; u++, Out++)
  72.                 {
  73.                     for (t = 0, y = 0; y < N; y++)
  74.                     {
  75.                         t += In[0] * ICoeffPtr[0];
  76.                         t += In[1] * ICoeffPtr[1];
  77.                         t += In[2] * ICoeffPtr[2];
  78.                         t += In[3] * ICoeffPtr[3];
  79.                         t += In[4] * ICoeffPtr[4];
  80.                         t += In[5] * ICoeffPtr[5];
  81.                         t += In[6] * ICoeffPtr[6];
  82.                         t += In[7] * ICoeffPtr[7];
  83.  
  84.                         In += 8; ICoeffPtr += 8;
  85.                     }
  86.                     *Out = t.CFTSB();
  87.                     In -= TwoN;
  88.                 }
  89.             Out -= TwoN;
  90.             ICoeffPtr -= QuadN;
  91.         }
  92.  
  93.         public void Straight(byte* In, double* Out)
  94.         {
  95.             for (v = 0; v < N; v++)
  96.                 for (u = 0; u < N; u++, Out++)
  97.                 {
  98.                     for (*Out = 0, y = 0; y < N; y++)
  99.                     {
  100.                         t += (In[0] - 128) * CoeffPtr[0];
  101.                         t += (In[1] - 128) * CoeffPtr[1];
  102.                         t += (In[2] - 128) * CoeffPtr[2];
  103.                         t += (In[3] - 128) * CoeffPtr[3];
  104.                         t += (In[4] - 128) * CoeffPtr[4];
  105.                         t += (In[5] - 128) * CoeffPtr[5];
  106.                         t += (In[6] - 128) * CoeffPtr[6];
  107.                         t += (In[7] - 128) * CoeffPtr[7];
  108.  
  109.                         In += 8; ICoeffPtr += 8;
  110.                     }
  111.                     In -= TwoN;
  112.                 }
  113.             Out -= TwoN;
  114.             CoeffPtr -= QuadN;
  115.         }
  116.  
  117.         public void Inverse(double* In, byte* Out)
  118.         {
  119.             for (v = 0; v < N; v++)
  120.                 for (u = 0; u < N; u++, Out++)
  121.                 {
  122.                     for (t = 0, y = 0; y < N; y++)
  123.                     {
  124.                         t += In[0] * ICoeffPtr[0];
  125.                         t += In[1] * ICoeffPtr[1];
  126.                         t += In[2] * ICoeffPtr[2];
  127.                         t += In[3] * ICoeffPtr[3];
  128.                         t += In[4] * ICoeffPtr[4];
  129.                         t += In[5] * ICoeffPtr[5];
  130.                         t += In[6] * ICoeffPtr[6];
  131.                         t += In[7] * ICoeffPtr[7];
  132.  
  133.                         In += 8; ICoeffPtr += 8;
  134.                     }
  135.                     *Out = (byte)(t.CFTSB() + 128);
  136.                     In -= TwoN;
  137.                 }
  138.             Out -= TwoN;
  139.             ICoeffPtr -= QuadN;
  140.         }
  141.  
  142.         public void Straight(double* In, double* Out)
  143.         {
  144.             for (v = 0; v < N; v++)
  145.                 for (u = 0; u < N; u++, Out++)
  146.                 {
  147.                     for (*Out = 0, y = 0; y < N; y++)
  148.                     {
  149.                         *Out += In[0] * CoeffPtr[0];
  150.                         *Out += In[1] * CoeffPtr[1];
  151.                         *Out += In[2] * CoeffPtr[2];
  152.                         *Out += In[3] * CoeffPtr[3];
  153.                         *Out += In[4] * CoeffPtr[4];
  154.                         *Out += In[5] * CoeffPtr[5];
  155.                         *Out += In[6] * CoeffPtr[6];
  156.                         *Out += In[7] * CoeffPtr[7];
  157.  
  158.                         In += 8; CoeffPtr += 8;
  159.                     }
  160.                     In -= TwoN;
  161.                 }
  162.             Out -= TwoN;
  163.             CoeffPtr -= QuadN;
  164.         }
  165.  
  166.         public void Inverse(double* In, double* Out)
  167.         {
  168.             for (v = 0; v < N; v++)
  169.                 for (u = 0; u < N; u++, Out++)
  170.                 {
  171.                     for (*Out = 0, y = 0; y < N; y++)
  172.                     {
  173.                         *Out += In[0] * ICoeffPtr[0];
  174.                         *Out += In[1] * ICoeffPtr[1];
  175.                         *Out += In[2] * ICoeffPtr[2];
  176.                         *Out += In[3] * ICoeffPtr[3];
  177.                         *Out += In[4] * ICoeffPtr[4];
  178.                         *Out += In[5] * ICoeffPtr[5];
  179.                         *Out += In[6] * ICoeffPtr[6];
  180.                         *Out += In[7] * ICoeffPtr[7];
  181.  
  182.                         In += 8; ICoeffPtr += 8;
  183.                     }
  184.                     In -= TwoN;
  185.                 }
  186.             Out -= TwoN;
  187.             ICoeffPtr -= QuadN;
  188.         }
  189.     }
  190.    
  191.     public static class Exter
  192.     {
  193.         public static sbyte CFTSB(this double c)
  194.         {
  195.             c = (float)Math.Round(c);
  196.                  if (c >  0x7F) c =  0x7F;
  197.             else if (c < -0x80) c = -0x80;
  198.             return (sbyte)c;
  199.         }
  200.     }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top