---

dct_trf.c

Go to the documentation of this file.

//
// Copyright Onur G. Guleryuz
//
//
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include "support_routines.h"

#if !defined(PI)

#define PI 3.14159265358979
#endif


/* generate a 1-d dct
   rows of H are the 1-dct basis */

float **gen_1d_dct(int N)

{
   int i,j;
   float **H;

   H=allocate_2d_float(N,N,0);
   for(i=0;i<N;i++)
      for(j=0;j<N;j++)
         H[i][j]=(float)(sqrt(2.0/N)*cos(PI*i*(2.0*j+1)/(2.0*N)));
   for(j=0;j<N;j++)
      H[0][j]/=(float)sqrt(2.0);
   return(H);
   }

#define BUFFER_SIZE (256)

// Forward 2-d dct of one (bx X bx) block in the matrix starting at (pi,pj). 
// Results are returned in trf starting at (si,sj).
// bx is the block DCT size. H is the 1d DCT basis matrix 
// (can be generated via gen_1d_dct()).
void trf_one_block_dct_2d(float **matrix,int pi,int pj,float **trf,int si,int sj,
                        int bx,float **H)

{
        int k,l,m;
        float tmp,buf[BUFFER_SIZE];


        if(bx>BUFFER_SIZE) {

                printf("Large DCT_SIZE, please increase BUFFER_SIZE in code to match\n");
                exit(1);
        }

        // Transform columns first.
        for(k=0;k<bx;k++)
                for(l=0;l<bx;l++) {

                        tmp=0;
                        for(m=0;m<bx;m++)
                                tmp+=H[k][m]*matrix[pi+m][pj+l];
                        trf[si+k][sj+l]=tmp;
                        }

        // Now transform rows.
        for(k=0;k<bx;k++) {

                for(l=0;l<bx;l++) {

                        tmp=0;
                        for(m=0;m<bx;m++)
                                tmp+=H[l][m]*trf[si+k][sj+m];
                        buf[l]=tmp;
                }
                                
                for(l=0;l<bx;l++)
                        trf[si+k][sj+l]=buf[l];
        }

}


// Inverse 2-d dct of one (bx X bx) block in trf starting at (si,sj). 
// Results are returned in matrix starting at (pi,pj).
// bx is the block DCT size. H is the 1d DCT basis matrix 
// (can be generated via gen_1d_dct()).

void inv_trf_one_block_dct_2d(float **trf,int si,int sj,float **matrix,int pi,int pj,
                        int bx,float **H)

{
        int k,l,m;
        float tmp,buf[BUFFER_SIZE];


        if(bx>BUFFER_SIZE) {

                printf("Large DCT_SIZE, please increase BUFFER_SIZE in code to match\n");
                exit(1);
        }

        // Inverse transform rows first.
        for(k=0;k<bx;k++)
                for(l=0;l<bx;l++) {

                        tmp=0;
                        for(m=0;m<bx;m++)
                                tmp+=H[m][l]*trf[si+k][sj+m];
                        matrix[pi+k][pj+l]=tmp;
                        }

        // Now inverse transform columns.
        for(l=0;l<bx;l++) {
                        
                for(k=0;k<bx;k++) {

                        tmp=0;
                        for(m=0;m<bx;m++)
                                tmp+=H[m][k]*matrix[pi+m][pj+l];
                        buf[k]=tmp;
                }
                for(k=0;k<bx;k++)
                        matrix[pi+k][pj+l]=buf[k];
        }
}

---