grp4comp.c

来自「NIST Handwriting OCR Testbed」· C语言 代码 · 共 1,421 行 · 第 1/4 页

/*
# 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	1
int 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 ***************************