cprdct.c

JPEG Image compression using IJG standards followed

/*
 ********************************************************************
 *
 * File Name:		cprdct.c
 *
 * Designed by:		
 *					Jie Liang
 *
 * Created Date:	June 30, 2000
 *
 * Contents:
 *					Implement the forward lossless binDCT,
 *                  which enables perfect reconstruction.
 *
 * Usage:	cprdct infile outfile hsize vsize
 *		"Arguments:\n"
 *		"	infile: 	image file to be transformed(pgm or raw),\n"
 *		"	dctfile:	output file that will contain the transformed result,\n"
 *		"	hsize:		Horizontal size of the image,\n"
 *		"	vsize:		Vertical size of the image.\n"
 *		"Examples:\n"
 *		"	./cprdct lena.raw lena.dct 512 512\n"
 *			
 * Limitations:
 *			
 * Copyright (C) 2000 Department of Electrical and Computer Engineering 
 * The Johns Hopkins University. All right reserved. 
 *
 *********************************************************************
 */

/*
 *********************************************************************
 *
 *   Modification History:
 *
 *   Date	Programmer	Description
 *-------------------------------------------------------------------
 *
 * $Log$
 *
 *
 *
 *********************************************************************
 */

static const char rcsid[] = 
	"$Id$";

/*
 ********************************************************************
 *
 *	Include Files
 *
 ********************************************************************
 */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <time.h>

#include "utility.h"

/*
 *******************************************************************
 *
 *	Variables
 *
 *******************************************************************
 */

/*
 *******************************************************************
 *
 * 	Local Constants
 *
 *******************************************************************
 */

/*
 *******************************************************************
 *
 *	Local Macros
 *
 *******************************************************************
 */

/*
 *******************************************************************
 *
 *	Local Enumerated Types
 *
 *******************************************************************
 */

/*
 *******************************************************************
 *
 *	Local Data Types
 *
 *******************************************************************
 */
#define DCTSIZE   8
typedef signed short int DCTELEM;
/*
 *******************************************************************
 *
 *	Local Function Prototypes
 *
 *******************************************************************
 */

void jpeg_fdct_bin_a1_pr(DCTELEM *data);

/*
 ***********************************************************************
 *
 * Function Name:		main
 *
 * Descriptions:
 *				open input image, perform DCT transformation
 *		
 *
 * Input Parameters:
 *				argc: argument count;
 *				argv: array of input arguments.
 * Output Parameters:		0:    successful,
 *				-1:   error.
 * Limitations:
 *
 ************************************************************************
 */
int main(int argc, char *argv[])
{
  FILE 				*infile, *outfile, *recfile;
  unsigned char		row, col, rblks, cblks, rbidx, cbidx;	    /* horizontal, vertical blocks and indexes */
  int				i, j, hsize, vsize, offset;	/* source symbols */ 
  unsigned char		*imgptr_chr;
  short 			*imgptr, *hdptr, *fltidx, dct_1d_buf[8];
  clock_t			timer0, timer1;
  int               tmp1, tmp2, tmp3;

  printf("\nForward Lossless binDCT:\n");

  if (argc != 5) {
	printf(
		"\nUsage:\n cprdct infile dctfile hsize vsize\n"
		"Arguments:\n"
		"	infile: 	image file to be transformed,\n"
 		"	dctfile:	output file that will contain the transformed result,\n"
		"	hsize:		Horizontal size of the image,\n"
		"	vsize:		Vertical size of the image.\n"
		"Examples:\n"
		"	./cprdct lena.raw lena.dct 512 512\n"
	);	
	return(-1);
  }
 

  /* Open Input files */
  infile = fopen(argv[1], "r"); 
  if (infile == NULL)  {
	fprintf(stderr, "Input file not found.\n");
	return(-1);
  }
  
  /*create output file */
  outfile = fopen(argv[2], "w");
  if( outfile == NULL ) {
  	fprintf(stderr, "Error in generating output file.\n");
	return(-1);
  }

  /* read image size */
  hsize = atoi(argv[3]);
  vsize = atoi(argv[4]);

  if ( (hsize & 7) || (vsize & 7) ) {
	fprintf(stderr, "Image size paramemters should be multiples of 8.\n");
	return(-1);
  }
	
  /* block indexes in two directions */ 
  cblks = hsize / 8 ;
  rblks = vsize / 8 ;

  /* allocate memory for the img array */
  if( !(imgptr_chr = (unsigned char *) malloc(hsize * vsize)) ||
	  !(imgptr = (short *) malloc(hsize * vsize * sizeof(short))) ) {
	printf("Memory allocation error.\n");
	return(-1);
  }  

  /* read the file header of pgm or ppm, do nothing for raw. */
  get_image_info(infile, (int *) &tmp1, (int *) &tmp2, (int *) &tmp3);

  /* read image data */
  fread(imgptr_chr, sizeof(unsigned char), hsize * vsize, infile);
  fclose(infile);

  /* convert to short */
  for (i = 0; i < hsize * vsize; i++) {
	  *(imgptr + i) = (short) *(imgptr_chr + i);
  }

  /*
   *******************
   *
   * Forward DCT transform  
   *
   *******************
   */

  /* record the beginning of the processing */
  timer0 = clock();

  for(rbidx = 0; rbidx < rblks; rbidx++) {
	for (cbidx = 0; cbidx < cblks; cbidx++) {
		
	  hdptr = imgptr +  (rbidx * hsize * 8 + cbidx * 8); // this is short type.

		jpeg_fdct_bin_a1_pr(hdptr);

	} 
  }	
  
  timer1 = clock();

  printf("Time used by Forward binDCT is: %10.6f sec.\n", ((float) (timer1 - timer0)) / (float )CLOCKS_PER_SEC);

  fwrite(imgptr, sizeof(short), hsize * vsize, outfile);
  fclose(outfile);
  printf("DCT result file generated.\n");

  for (rbidx=0; rbidx<64;rbidx++)
	printf("%5d", *(imgptr+rbidx));

   return(0);
}

/*
 ***********************************************************************
 *
 * Function Name:		jpeg_fdct_bin_a1_pr
 *
 * Descriptions:
 *		
 * Input Parameters:
 *				data:  pointer to a 8x8 block.
 * Return Parameters:	none.
 *
 * Notice:
 *  DCTELEM is now short int.
 ************************************************************************
 */

void jpeg_fdct_bin_a1_pr (DCTELEM * data)
{
  DCTELEM tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
  DCTELEM tmp10, tmp11, tmp12, tmp13;
  DCTELEM z1, z2, z3, z4, z5;
  DCTELEM *dataptr;
  int ctr;

  /* Pass 1: process rows. */
  /* Note results are scaled up by sqrt(8) compared to a true DCT; */
  /* furthermore, we scale the results by 2**PASS1_BITS. */

  dataptr = data;
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {


/*******************/
/* Jie: test code */
	//	for (tmp0 = 0; tmp0 < 8; tmp0 ++) {
	//	  fprintf(stderr, "%10d", dataptr[tmp0]+128);
	//	}
	//	fprintf(stderr, "\n");

    tmp0 = dataptr[0] + dataptr[7];
    tmp7 = dataptr[0] - dataptr[7];
    tmp1 = dataptr[1] + dataptr[6];
    tmp6 = dataptr[1] - dataptr[6];
    tmp2 = dataptr[2] + dataptr[5];
    tmp5 = dataptr[2] - dataptr[5];
    tmp3 = dataptr[3] + dataptr[4];
    tmp4 = dataptr[3] - dataptr[4];
    
    /* Even part */
    tmp10 = (tmp0 + tmp3) ;	/* phase 2 */
    tmp13 = tmp0 - tmp3;
    tmp11 = (tmp1 + tmp2) ;
    tmp12 = tmp1 - tmp2;
    
    dataptr[0] = (tmp10 + tmp11);             /* phase 3 */
	dataptr[4] = ((dataptr[0] + 1) >> 1) - tmp11;   /* Jie 05/18/00 */
	//dataptr[4] = tmp10 - tmp11;

	/*3/8, -3/8: alter the sign to get positive scaling factor */   
	/* new version: 7/16 and -3/8 */
    dataptr[6] = ((tmp13 + 1) >> 1) - ((tmp13 + 8) >> 4) - tmp12;     /* 1/2 - 1/16 */
    dataptr[2] = tmp13 - (((dataptr[6] << 1) + dataptr[6] + 4) >> 3);
    
    /* Odd part */

/* pi/4 = -7/16u 11/16d -3/8u*/
	tmp10 = tmp5 - (( (tmp6 << 3) - tmp6 + 8) >> 4);
	tmp6 = tmp6 + tmp10 - ((tmp10 + 2) >> 2) -((tmp10 + 8) >> 4);
	tmp5 = (((tmp6 << 1) + tmp6 + 4) >> 3) - tmp10;

    tmp10 = tmp4 + tmp5;
    tmp11 = tmp4 - tmp5;
    tmp12 = tmp7 - tmp6;
    tmp13 = tmp7 + tmp6;

    /* 7pi/16 = 3/16u -3/16d: alter the sign to get positive scaling factor */
    dataptr[7] = (((tmp13 << 1) + tmp13 + 8) >> 4) - tmp10;
	dataptr[1] = tmp13 - (((dataptr[7] << 1) + dataptr[7] + 8) >> 4);

    /* 3pi/16 = 7/8u -1/2d */
	/* new version: 5/8, -7/16 */
    dataptr[5] = tmp11 + ((tmp12 + 1) >> 1) + ((tmp12 + 4) >> 3);
    dataptr[3] = tmp12 - ((dataptr[5] + 1) >> 1) + ((dataptr[5] + 8) >> 4);
    
    dataptr += DCTSIZE;		/* advance pointer to next row */
  }

  /* Pass 2: process columns.
   * We remove the PASS1_BITS scaling, but leave the results scaled up
   * by an overall factor of 8.
   */

  dataptr = data;
  for (ctr = DCTSIZE-1; ctr >= 0; ctr--) {
    tmp0 = (dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7]);
    tmp7 = (dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7]);
    tmp1 = (dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6]);
    tmp6 = (dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6]);
    tmp2 = (dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5]);
    tmp5 = (dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5]);
    tmp3 = (dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4]);
    tmp4 = (dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4]);
    
    /* Even part */
    
    tmp10 = (tmp0 + tmp3);	/* phase 2 */
    tmp13 = tmp0 - tmp3;
    tmp11 = (tmp1 + tmp2);
    tmp12 = tmp1 - tmp2;
    
    dataptr[DCTSIZE*0] = (tmp10 + tmp11); /* phase 3 */
	dataptr[DCTSIZE*4] = ((dataptr[DCTSIZE*0] + 1) >> 1) - tmp11;   /* Jie 05/18/00 */
    //dataptr[DCTSIZE*4] = (tmp10 - tmp11); /* phase 3 */


    dataptr[DCTSIZE*6] = ((tmp13 + 1) >> 1) - ((tmp13 + 8) >> 4) - tmp12;
    dataptr[DCTSIZE*2] = tmp13 - (((dataptr[DCTSIZE*6] << 1) + dataptr[DCTSIZE*6] + 4) >> 3);
  
    /* Odd part */

/* pi/4 = -7/16u 11/16d -3/8u*/
	tmp10 = tmp5 - (((tmp6 << 3) - tmp6 + 8) >> 4);
	tmp6 = tmp6 + tmp10 - ((tmp10 + 2) >> 2) - ((tmp10 + 8) >> 4);
	tmp5 = (((tmp6 << 1) + tmp6 + 4) >> 3) - tmp10;

    tmp10 = tmp4 + tmp5;
    tmp11 = tmp4 - tmp5;
    tmp12 = tmp7 - tmp6;
    tmp13 = tmp7 + tmp6;

    /* 7pi/16 = 3/16u -3/16d: alter sign to get positive scaling factor */
    dataptr[DCTSIZE*7] = (((tmp13 << 1) + tmp13 + 8) >> 4) - tmp10;
	dataptr[DCTSIZE*1] = tmp13 - (((dataptr[DCTSIZE*7] << 1) + dataptr[DCTSIZE*7] + 8) >> 4);

    /* 3pi/16 = 7/8u -1/2d */
	/* new : 5/8 and -7/16 */
    dataptr[DCTSIZE*5] = tmp11 + ((tmp12 + 1) >> 1) + ((tmp12 + 4) >> 3);
    dataptr[DCTSIZE*3] = tmp12 - ((dataptr[DCTSIZE*5] + 1) >> 1) + ((dataptr[DCTSIZE*5] + 8) >> 4);

    dataptr++;			/* advance pointer to next column */
  }

}


/*
 *******************************************************
 *
 * End of $Source$
 *
 *******************************************************
 */