/*# proc: grp4comp - CCITT Group 4 compresses an image.# proc:*//*********************************************************************   File Name:  grp4comp.c					    **   Modified:   Darlene E. Frederick				    **               Michael D. Garris                                   **   Date:	January 25, 1990				    **   Package:    CCITT4 compression routines			    **                                                                   **   Modified 12/90 by Stan Janet                                    **		flush_buffer() was adding an extra byte to data     **		whether it was already byte-aligned or not          **   Modified 12/94 by Patrick Grother                               **               Reclared the all variables of type "short" to be    **               "int", using a macro SHORT defined in the include   **               file grp4comp.h.                                    **               On images with more than 2^15 rows the              **               result was garbage because of an overflowed line    **               counter. The new declaration has a limit of 2^31    **				   				    **   Contents:   ccitt4_compress()				    **		read_uncompressed_file_into_memory()		    **		control_compression()				    **		prepare_to_compress()				    **		compress_image()				    **		make_array_of_changing_elements()		    **		set_up_first_and_last_changing_elements_c()	    **		prepare_to_compress_next_line()			    **		set_up_first_line()				    **		crash_c()				  	    **								    *	********************************************************************/#ifdef TIME#include <sys/time.h>#endif#include <memory.h>#include <grp4comp.h>/* Added by MDG in order have option of passing alloc responsibilities to caller */#define NOALLOC 0#define ALLOC	1int comp_alloc_flag = ALLOC;int comp_write_init_flag;#ifdef TIME  struct timeval  t1, t2;  struct timezone tz;#endif/************************************************************************   grp4comp is the main routine of this file.  It does pre-           **   liminary setup, calls routines, and does final processing.         *************************************************************************//************************************************************************  Arguments          						       **  ---------                					       **	Passed in:         					       **		   indata - buffer containing the uncompressed data.   **		   inbytes - the number of bytes in indata.            **  		   width - Width in pixels of scan line in indata.     **  		   height - Number of lines in indata.                 **	Returned:          					       **		   outdata - buffer containing the compressed data.    **		   outbytes - the number of bytes in outdata.          *************************************************************************/grp4comp(indata,inbytes,width,height,outdata,outbytes)unsigned char *indata, *outdata;int inbytes, width, height, *outbytes;{   struct uncompressed_descriptor uncompressed;   struct compressed_descriptor compressed;       	uncompressed.pixels_per_line = width;       	uncompressed.number_of_lines = height;        uncompressed.data = indata;        comp_alloc_flag = NOALLOC;        comp_write_init_flag = True;	read_uncompressed_file_into_memory( &uncompressed);        compressed.data = outdata;	control_compression( &uncompressed, &compressed );        *outbytes = compressed.length_in_bytes;/*	printf("\ncompressed:lines: %d, pixels:%d, length:%d\n",	 compressed.number_of_lines, compressed.pixels_per_line, 	 compressed.length_in_bytes); */}/***************************** control_compression **************************			calls the functions that compress the image			*****************************************************************************//************************************************************************  Arguments          						       **  ---------                					       **	Passed in:         					       **  		   uncompressed	- structure containing the # of pixels **				  per line, the number of lines, and   **				  the uncompressed data.               **	Returned:          					       **  		   compressed	- structure containing the # of pixels **				  per line, the number of lines, and   **				  the compressed data.                 *************************************************************************/void control_compression( uncompressed, compressed )struct uncompressed_descriptor *uncompressed;struct compressed_descriptor *compressed;{struct parameters 				 sole_parameters;struct parameters 				*params = &sole_parameters;#ifdef TIME  SHORT i;            tz.tz_minuteswest = 0;            tz.tz_dsttime     = 0;            gettimeofday(&t1, &tz); #endif        	prepare_to_compress( uncompressed, compressed, params );	compress_image( uncompressed, compressed, params );        /* memory deallocation added by Michael D. Garris 2/26/90 */        free(params->reference_line);        free(params->coding_line);#ifdef TIME           gettimeofday(&t2, &tz);            printf("\ntime difference: %ld:%ld\n", t2.tv_sec - t1.tv_sec,           t2.tv_usec - t1.tv_usec);           for(i=0; i<5; i++) printf("%c",'\07');*/#endif}/************************ read_uncompressed_file_into_memory *******************			allocates memory for the uncompressed image.					*****************************************************************************//************************************************************************  Arguments          						       **  ---------                					       **	Passed in:         					       **  		   uncompressed	- structure containing the # of pixels **				  per line, the number of lines, and   **				  the uncompressed data.               **	Returned:          					       **  		   uncompressed	- structure containing the # of pixels **				  per line, the number of lines, and   **				  the compressed data.                 *************************************************************************/void read_uncompressed_file_into_memory( uncompressed )struct uncompressed_descriptor *uncompressed;{int file_size;     if(comp_alloc_flag){	file_size = uncompressed->pixels_per_line * uncompressed->number_of_lines	 / Pixels_per_byte;	 	if((uncompressed->data = (char *)calloc( file_size, sizeof(char) )) == NULL) { 	    printf("\nCannot allocate enough memory for uncomp file.\n"); 	    crash_c(); 	}     }     else        if(uncompressed->data == NULL){           printf("\nNo memory allocated for input data!\n");           crash_c();        }} /* end read_uncompressed_file_into_memory() *//*************************** prepare_to_compress ****************************			initializes variables in preperation for compression					*****************************************************************************//************************************************************************  Arguments          						       **  ---------                					       **	Passed in:         					       **  		   uncompressed	- structure containing the # of pixels **				  per line, the number of lines, and   **				  the uncompressed data.               **	Returned:          					       **  		   compressed	- structure containing the # of pixels **				  per line, the number of lines, and   **				  the compressed data.                 **		   params - structure storing information needed for   **		   	    comparison and other tasks.		       *************************************************************************/void prepare_to_compress( uncompressed, compressed, params )struct uncompressed_descriptor  *uncompressed;struct compressed_descriptor 	*compressed;struct parameters 				*params;{	        		params->max_pixel   	    = uncompressed->pixels_per_line;	compressed->pixels_per_line = uncompressed->pixels_per_line;	compressed->number_of_lines = uncompressed->number_of_lines;		set_up_first_line_c( params ); 	prepare_to_write_bits_c( compressed );		 } /* end prepare_to_compress() *//****************************** compress_image *******************************					compresses the image						*****************************************************************************//************************************************************************  Arguments          						       **  ---------                					       **	Passed in:         					       **  		   uncompressed	- structure containing the # of pixels **				  per line, the number of lines, and   **				  the uncompressed data.               **	Returned:          					       **  		   compressed	- structure containing the # of pixels **				  per line, the number of lines, and   **				  the compressed data.                 **		   params - structure storing information need for     **		   	    comparison and other tasks.		       *************************************************************************/void compress_image( uncompressed, compressed, params )struct uncompressed_descriptor 	*uncompressed;struct compressed_descriptor 	*compressed;struct parameters *params;{SHORT  line;	for(line = 0; line < uncompressed->number_of_lines; line++) {			     make_array_of_changing_elements( params, uncompressed, line );	     set_up_first_and_last_changing_elements_c( params );	     compress_line( params );	     prepare_to_compress_next_line( params );	} /* end for each line loop */		write_bits_c("000000000001000000000001");	compressed->length_in_bytes = flush_buffer();}/************************ make_array_of_changing_elements *********************		stores in a list pointed to by "params->coding_line" the pixel numbers	of all the changing elements in the coding line	 						*****************************************************************************//************************************************************************  Arguments          						       **  ---------                					       **	Passed in:         					       **  		   uncompressed	- structure containing the # of pixels **				  per line, the number of lines, and   **				  the uncompressed data.               **		   line_number -  the number of the line in the image  **	Returned:          					       **		   params - structure storing information need for     **		   	    comparison and other tasks.		       *************************************************************************/void make_array_of_changing_elements( params, uncompressed, line_number )struct parameters *params;struct uncompressed_descriptor 	*uncompressed;SHORT line_number;{SHORT 	bytes_per_line;int	line_offset;SHORT 	byte_offset;	bytes_per_line = params->max_pixel / Pixels_per_byte;	line_offset = bytes_per_line * line_number;	for(byte_offset=0; byte_offset < bytes_per_line; byte_offset++) {	    process_char(*(uncompressed->data+line_offset+byte_offset),params);	} 	}	/* end make_array_of_changing_elements() *//******************* set_up_first_and_last_changing_elements_c *****************		initializes the first and last changing elements in the coding line						******************************************************************************//************************************************************************  Arguments          						       **  ---------                					       **	Passed in:         					       **		   params - structure storing information need for     **		   	    comparison and other tasks.		       **	Returned:          					       **		   params - structure storing information need for     **		   	    comparison and other tasks.		       *************************************************************************/void set_up_first_and_last_changing_elements_c(params)struct parameters *params;{	*(params->coding_line) = Invalid;	*(params->coding_line + ++params->index) = params->max_pixel;	*(params->coding_line + ++params->index) = params->max_pixel;	*(params->coding_line + ++params->index) = params->max_pixel;		/* the previous lines may be necessary if when searching for b1, you	skip some elements because you know that they are the wrong color */}/************************ prepare_to_compress_next_line ***********************		initializes variables in preperation for compressing another line				******************************************************************************//************************************************************************  Arguments          						       **  ---------                					       **	Passed in:         					       **		   params - structure storing information need for     **		   	    comparison and other tasks.		       **	Returned:          					       **		   params - structure storing information need for     **		   	    comparison and other tasks.		       *************************************************************************/void prepare_to_compress_next_line(params)struct parameters *params;{SHORT *temp;	/* swap the reference and unchanged coding lines */		temp = params->reference_line;	params->reference_line = params->coding_line;	params->coding_line = temp;		params->pixel = 0;	params->index = 0;	params->previous_color = White;	} /* end prepare_to_read_next_line() */	/******************************* set_up_first_line_c ***************************