idct.c

Spartan3_virtualplatform_8_1

#define DESCALE(x,n)    (((x) + ((long)1 << ((n) - 1))) >> n)

#include <math.h>

const int idct_constants[8][8] =
{
  {
    16384,22725,21407,19266,16384,12873,8867,4520
  },
  {
    16384,19266,8867,-4521,-16384,-22726,-21407,-12873
  },
  {
    16384,12873,-8867,-22726,-16385,4520,21407,19266
  },
  {
    16384,4520,-21407,-12873,16384,19266,-8867,-22726
  },
  {
    16384,-4521,-21407,12873,16384,-19266,-8867,22725
  },
  {
    16384,-12873,-8867,22725,-16384,-4521,21407,-19266
  },
  {
    16384,-19266,8867,4520,-16385,22725,-21407,12873
  },
  {
    16384,-22726,21407,-19266,16384,-12873,8867,-4521
  }
};

      
// Performs Idct on an input array of size 8 and returns an
// output array of size 8.
void do_1didct (int *wsptr, int *outptr) {
   
   int i, j;
   int sum;
   for (j = 0; j < 8; j++) {
      sum = 0;
      for (i = 0; i < 8; i++)
         sum += (wsptr[i] * idct_constants[j][i]);
      
      outptr[j] = (sum >> 2);
      outptr[j] = (int) DESCALE (outptr[j], 10);      
   }
}

/* do_idct:
 *  Calculates the inverse discrete cosine transform; based on code by the
 *  Independent JPEG Group. This method uses integer fixed point math.
 */
void do_idct(int *data, int *dequant)
{
   long tmp0, tmp1, tmp2, tmp3,
        tmp10, tmp11, tmp12, tmp13,
        z1, z2, z3, z4, z5;
   int *inptr, *wsptr, *dqptr, *outptr;
   int i, workspace[64], temp;

   int indataptr[8];
   int outdataptr[8];
   /* Pass 1 */

   inptr = data;
   dqptr = dequant;
   wsptr = workspace;
   for (i=8; i>0; i--) {
      if (inptr[8] == 0 && inptr[16] == 0 && inptr[24] == 0 &&
          inptr[32] == 0 && inptr[40] == 0 && inptr[48] == 0 &&
          inptr[56] == 0) {
         /* AC terms all zero */
         temp = (inptr[0] * dqptr[0]) << 2;

         wsptr[0] = temp;
         wsptr[8] = temp;
         wsptr[16] = temp;
         wsptr[24] = temp;
         wsptr[32] = temp;
         wsptr[40] = temp;
         wsptr[48] = temp;
         wsptr[56] = temp;

         inptr++;
         wsptr++;
         dqptr++;
         continue;
      }

//       indataptr = (int *) malloc (8*sizeof(int));
//       outdataptr = (int *) malloc (8*sizeof(int));
      
      indataptr[2] = inptr[16] * dqptr[16];
      indataptr[6] = inptr[48] * dqptr[48];
      indataptr[0] = inptr[0] * dqptr[0];
      indataptr[4] = inptr[32] * dqptr[32];

      indataptr[7] = inptr[56] * dqptr[56];
      indataptr[5] = inptr[40] * dqptr[40];
      indataptr[3] = inptr[24] * dqptr[24];
      indataptr[1] = inptr[8] * dqptr[8];

      do_1didct(indataptr, outdataptr);
      
      /* Temp output */
      wsptr[0]  = outdataptr[0];
      wsptr[56] = outdataptr[7];
      wsptr[8]  = outdataptr[1];
      wsptr[48] = outdataptr[6];
      wsptr[16] = outdataptr[2];
      wsptr[40] = outdataptr[5];
      wsptr[24] = outdataptr[3];
      wsptr[32] = outdataptr[4];

//       free (indataptr);
//       free (outdataptr);
      
      inptr++;
      dqptr++;
      wsptr++;
   }
   
   /* Pass 2 */

   wsptr = workspace;
   outptr = data;
   for (i=0; i<8; i++) {
//       indataptr = (int *) malloc (8*sizeof(int));
//       outdataptr = (int *) malloc (8*sizeof(int));
      
      indataptr[2] = wsptr[2];
      indataptr[6] = wsptr[6];
      indataptr[0] = wsptr[0];
      indataptr[4] = wsptr[4];

      indataptr[7] = wsptr[7];
      indataptr[5] = wsptr[5];
      indataptr[3] = wsptr[3];
      indataptr[1] = wsptr[1];

      do_1didct(indataptr, outdataptr);
      
      /* Final output */
      outptr[0] = outdataptr[0];
      outptr[7] = outdataptr[7];
      outptr[1] = outdataptr[1];
      outptr[6] = outdataptr[6];
      outptr[2] = outdataptr[2];
      outptr[5] = outdataptr[5];
      outptr[3] = outdataptr[3];
      outptr[4] = outdataptr[4];
      
//       free (indataptr);
//       free (outdataptr);

      outptr[0] = (int) DESCALE(outptr[0], 7) + 128;
      outptr[1] = (int) DESCALE(outptr[1], 7) + 128;
      outptr[2] = (int) DESCALE(outptr[2], 7) + 128;
      outptr[3] = (int) DESCALE(outptr[3], 7) + 128;
      outptr[4] = (int) DESCALE(outptr[4], 7) + 128;
      outptr[5] = (int) DESCALE(outptr[5], 7) + 128;
      outptr[6] = (int) DESCALE(outptr[6], 7) + 128;
      outptr[7] = (int) DESCALE(outptr[7], 7) + 128;
      
      outptr += 8;
      wsptr += 8;
   }
}