rdbmp.c

JPEG压缩和解压程序和一些相关的说明文档 内容比较全

/*
 *rdbmp.c is reedited from the IJG code by Fujian Shi([e-mail]).
 *This programe is desinged to transform the color bmp file to gray bmp file.Notice ,
 *here we only hold the commmon bmp format in windows.rdbmp.c need to be compiled with 
 *jccolor.c.
 */

#include "commondecls.h"		/* Common decls for cjpeg/djpeg applications */

/*arrage a row buffer*/
void  *
alloc_one_row(size_t size_object)
{
  
  return (void *) malloc(size_object);
}

/*arrage several rows buffer,that is a array*/
LOCAL(JSAMPARRAY)
alloc_sarray (JDIMENSION samplesperrow, JDIMENSION numrows)
/* Allocate a 2-D sample array */
{
  JSAMPARRAY result;
  JSAMPROW workspace;
  int currow;

  /* Get space for row pointers (small object) */
  result = (JSAMPARRAY) alloc_one_row((size_t) (numrows * SIZEOF(JSAMPROW)));

  /* Get the rows themselves (large objects) */
  currow = 0;
  while (currow < numrows) {
    workspace = (JSAMPROW) alloc_one_row((size_t) (samplesperrow
		  * SIZEOF(JSAMPLE)));
    result[currow++] = workspace;
    
  }

  return result;
}


LOCAL(int)
read_byte (bmp_source_ptr sinfo)
/* Read next byte from BMP file */
{
  register FILE *infile =sinfo->inputfile; 
  register int c=0;

  if ((c = getc(infile)) == EOF){
    printf("The wholefile has been input");
    exit (0);
  }
  return c;
}


LOCAL(void)
read_colormap (bmp_source_ptr sinfo, int cmaplen, int mapentrysize)
/* Read the colormap from a BMP file */
/*cmalen is the number of color in the bmp image*/
{
  int i;

  switch (mapentrysize) {
  case 3:
    /* BGR format (occurs in OS/2 files) */
    for (i = 0; i < cmaplen; i++) {
      sinfo->colormap[2][i] = (JSAMPLE) read_byte(sinfo);
      sinfo->colormap[1][i] = (JSAMPLE) read_byte(sinfo);
      sinfo->colormap[0][i] = (JSAMPLE) read_byte(sinfo);
    }
    break;
  case 4:
    /* BGR0 format (occurs in MS Windows files) */
    for (i = 0; i < cmaplen; i++) {
      sinfo->colormap[2][i] = (JSAMPLE) read_byte(sinfo);
      sinfo->colormap[1][i] = (JSAMPLE) read_byte(sinfo);
      sinfo->colormap[0][i] = (JSAMPLE) read_byte(sinfo);
      (void) read_byte(sinfo);
    }
    break;
  default:
    exit (0);
    break;
  }
}


/*
 * Read one row of pixels.
 * The image has been read into the whole_image array, but is otherwise
 * unprocessed.  We must read it out in top-to-bottom row order, and if
 * it is an 8-bit image, we must expand colormapped pixels to 24bit format.
 */

LOCAL(void)
adjust_8bit_row (bmp_source_ptr sinfo)
/*This version is for reading 8-bit colormap indexes*/ 
{
  register JSAMPARRAY colormap = sinfo->colormap;
  register int t;
  register JSAMPROW inptr=sinfo->buffer, outptr=sinfo->rgb_buffer;
  register JDIMENSION col;

  for (col = sinfo->image_width; col > 0; col--) {
    t = (INT32) (*inptr++);
    *outptr++ = colormap[0][t];	
    *outptr++ = colormap[1][t];
    *outptr++ = colormap[2][t];
  }
}


LOCAL(void)
adjust_24bit_row (bmp_source_ptr sinfo)
/* This version is for reading 24-bit pixels */
{
 
  register JSAMPROW inptr=sinfo->buffer, outptr=sinfo->rgb_buffer;
  register JDIMENSION col;

  
  /* Transfer data.  Note source values are in BGR order
   * (even though Microsoft's own documents say the opposite).
   */
  for (col = sinfo->image_width; col > 0; col--) {
    outptr[2] = *inptr++;
    outptr[1] = *inptr++;	
    outptr[0] = *inptr++;
    outptr += 3;
  }

}


/*
 * This method loads the image line by line
 * get_pixel_rows.  The get_pixel_rows pointer is then adjusted to call
 * get_8bit_row or get_24bit_row on subsequent calls.
 */

LOCAL(void)
transform_image (bmp_source_ptr sinfo,bmp_destination_ptr dinfo)
{
  register FILE *infile = sinfo->inputfile;
  register FILE *outfile=dinfo->outputfile;
  register int c;
  register JSAMPROW in_buffer_ptr,out_buffer_ptr,\
                                         in_rgb_buffer;  /*buffer pointer,the buffer is only one row*/
  JDIMENSION row, col;
  long position_adju;

  /* read and write data. */
  for (row = 0; row < (sinfo->image_height); row++) {
    
    in_buffer_ptr=sinfo->buffer;
    in_rgb_buffer=sinfo->rgb_buffer;
    out_buffer_ptr=dinfo->buffer;
    
    
    for (col = sinfo->row_width; col > 0; col--) {  /*by the cycle input one row sample into the buffer*/
      /* inline copy of read_byte() for speed */
      if ((c = getc(infile)) == EOF)
	exit(0);
      *in_buffer_ptr++ = (JSAMPLE) c;
    }
      
    /* adjust bgr to rgb  */
    (*sinfo->adjust_pixel_rows) (sinfo);
    
    /*rgb to gray*/
    rgb_gray_convert(sinfo,dinfo);  
    
    /*write one row to the new gray bmp file*/
    if (!WriteOK(dinfo->outputfile,dinfo->buffer,dinfo->row_width)){
      printf("the data cann't be write into the new image.\n");  
      exit(0);
    }
  }
  


}


/*
 * Read the file header; return image size and component count.
 */

LOCAL(void)
jinit_transform (bmp_source_ptr sinfo,bmp_destination_ptr dinfo)
{
  static void  write_byte_to_buffer(JSAMPROW new_bmp_header,int offset,int data);
  U_CHAR bmpfileheader[14];
  U_CHAR bmpinfoheader[64];
  U_CHAR new_bmp_header[54];       /*Iclude the fileheader and infoheader*/
  U_CHAR _gray_colormap[256*4];
  #define GET_2B(array,offset)  ((unsigned int) UCH(array[offset]) + \
			       (((unsigned int) UCH(array[offset+1])) << 8))
  #define GET_4B(array,offset)  ((INT32) UCH(array[offset]) + \
			       (((INT32) UCH(array[offset+1])) << 8) + \
			       (((INT32) UCH(array[offset+2])) << 16) + \
			       (((INT32) UCH(array[offset+3])) << 24))
 
  INT32 map_data;
  JSAMPROW gray_colormap;
  INT32 bfOffBits;
  INT32 headerSize;
  INT32 biWidth = 0;		/* initialize to avoid compiler warning */
  INT32 biHeight = 0;
  unsigned int biPlanes;
  INT32 biCompression;
  INT32 biXPelsPerMeter,biYPelsPerMeter;
  INT32 biClrUsed = 0;
  int mapentrysize = 0;		/* 0 indicates no colormap */
  INT32 bPad;
  JDIMENSION row_width;
  INT32 new_filesize;
  INT32 new_bfOffBits;

  /* Read and verify the bitmap file header */
  if (! ReadOK(sinfo->inputfile, bmpfileheader, 14)){
    printf("error when read the head of file");
    exit(0);
  }
  
  if (GET_2B(bmpfileheader,0) != 0x4D42) /* 'BM' */{
    printf("the file is not bmp format file");
    exit(0);
  }

  bfOffBits = (INT32) GET_4B(bmpfileheader,10);
  /* We ignore the remaining fileheader fields */

  /* The infoheader might be 12 bytes (OS/2 1.x), 40 bytes (Windows),
   * or 64 bytes (OS/2 2.x).  Check the first 4 bytes to find out which.
   */
  if (! ReadOK(sinfo->inputfile, bmpinfoheader, 4)){
    printf("Error when read infohead");
    exit(0);
  }
  

  headerSize = (INT32) GET_4B(bmpinfoheader,0);
  if (headerSize < 12 || headerSize > 64){
    printf("the infohead is damaged");
    exit(0);
  }
  printf("the bmpinfoheader is \%d\n",headerSize); 
 
  if (! ReadOK(sinfo->inputfile, bmpinfoheader+4, headerSize-4)){

    printf("the infohead is damaged");
    exit(0);
  }

  switch ((int) headerSize) {
    
  case 40:
  case 64:
    /* Decode Windows 3.x header (Microsoft calls this a BITMAPINFOHEADER) */
    /* or OS/2 2.x header, which has additional fields that we ignore */
    biWidth = GET_4B(bmpinfoheader,4);
    printf("the width of image is%d\n",biWidth);
    biHeight = GET_4B(bmpinfoheader,8);
    printf("the height of image is%d\n",biHeight);
    biPlanes = GET_2B(bmpinfoheader,12);
    sinfo->bits_per_pixel = (int) GET_2B(bmpinfoheader,14);
    printf("the bits_per_pixel of image is%d\n",sinfo->bits_per_pixel);
    biCompression = GET_4B(bmpinfoheader,16);
    biXPelsPerMeter = GET_4B(bmpinfoheader,24);
    biYPelsPerMeter = GET_4B(bmpinfoheader,28);
    biClrUsed = GET_4B(bmpinfoheader,32);
    /* biSizeImage, biClrImportant fields are ignored */

    switch (sinfo->bits_per_pixel) {
    case 8:			/* colormapped image */
      mapentrysize = 4;		/* Windows uses RGBQUAD colormap */
      sinfo->adjust_pixel_rows = adjust_8bit_row;
      break;
    case 24:			/* RGB image */
      sinfo->adjust_pixel_rows = adjust_24bit_row;
      break;
    default:
      printf("the bis of every pixel is not 8 or 24,I can't deal with it now");
      break;
    }
    if (biPlanes != 1)
      exit(0);
    if (biCompression != 0)
      exit(0);

    if (biXPelsPerMeter > 0 && biYPelsPerMeter > 0) {
      /* Set JFIF density parameters from the BMP data */
      sinfo->X_density = (UINT16) (biXPelsPerMeter/100); /* 100 cm per meter */
      sinfo->Y_density = (UINT16) (biYPelsPerMeter/100);
      sinfo->density_unit = 2;	/* dots/cm */
    }
    break;
    default:
      printf("the infohead is not 40 or 64 bytes");
      exit(0);
      break;
  }

  /* Compute distance to bitmap data --- will adjust for colormap below */
  bPad = bfOffBits - (headerSize + 14);

  printf("the bpad before colormap is %d\n",bPad);
  /* Read the colormap, if any */
  if (mapentrysize > 0) {
    if (biClrUsed <= 0)
      biClrUsed = 256;		/* assume it's 256 */
    else if (biClrUsed > 256)
      printf("the color used is not real_color and 256");
    /* Allocate space to store the colormap */
    sinfo->colormap=(JSAMPARRAY) (alloc_sarray
      ((JDIMENSION) biClrUsed, (JDIMENSION) 3));
    sinfo->colormap_used=1;
    printf("the image use colormap\n");
    /* and read it from the file */
    read_colormap(sinfo, (int) biClrUsed, mapentrysize);
    /* account for size of colormap */
    bPad -= biClrUsed * mapentrysize;
  }

  /* Skip any remaining pad bytes */
  if (bPad < 0)	{
    printf("incorrect bfooffbits");		/* incorrect bfOffBits value? */
    exit(0);
  }

  while (--bPad >= 0) {
    (void) read_byte(sinfo);
  }

  printf("The bpad=%d\n",bPad);
  /* Compute row width in file, including padding to 4-byte boundary */
  if (sinfo->bits_per_pixel == 24)
    row_width = (JDIMENSION) (biWidth * 3);
  else
    row_width = (JDIMENSION) biWidth;
  while ((row_width & 3) != 0) row_width++;
    sinfo->row_width = row_width;
    printf("the row_width  is%d\n",row_width);
  

  /* Allocate one-row buffer for returned data */
  sinfo->buffer =(JSAMPROW) (alloc_one_row                    /*prepare for input origion image data*/
    ((size_t) ((size_t) (row_width))*sizeof(JSAMPLE)));
  
  sinfo->rgb_buffer =(JSAMPROW) (alloc_one_row                    /*prepare for rgb sequence origion image data*/
    ((size_t) ((size_t) (biWidth*3))*sizeof(JSAMPLE))); 
  
  sinfo->image_width = dinfo->image_width=(JDIMENSION) biWidth;
  sinfo->image_height=dinfo->image_height=(JDIMENSION) biHeight;
  
  row_width=(JDIMENSION) biWidth;
  while ((row_width & 3) != 0) row_width++;
  dinfo->row_width = row_width;
  
  dinfo->buffer =(JSAMPROW) (alloc_one_row
			     ((size_t) ((size_t) (row_width))*sizeof(JSAMPLE)));      /*output buffer*/
  
  
  /*now it is the time to deal with the new_bmp_header and write it into the file*/
  
  new_bfOffBits=54+256*4;
  new_filesize=new_bfOffBits+biWidth*biHeight;
  *(new_bmp_header)=0x42;
  *(new_bmp_header+1)=0x4D;
  
  write_byte_to_buffer(new_bmp_header,2,new_filesize);
  write_byte_to_buffer(new_bmp_header,10,new_bfOffBits);
  write_byte_to_buffer(new_bmp_header,14,40);
  write_byte_to_buffer(new_bmp_header,18,dinfo->image_width);
  write_byte_to_buffer(new_bmp_header,22,dinfo->image_height);
  write_byte_to_buffer(new_bmp_header,26,0x00080001);              /*biplane is 1,8 bits per pixel*/
  write_byte_to_buffer(new_bmp_header,30,0);
  write_byte_to_buffer(new_bmp_header,34,dinfo->image_height*dinfo->row_width);
  write_byte_to_buffer(new_bmp_header,38,biXPelsPerMeter);
  write_byte_to_buffer(new_bmp_header,42,biYPelsPerMeter);
  write_byte_to_buffer(new_bmp_header,44,0);
  write_byte_to_buffer(new_bmp_header,48,0);  
  
  /*write the header into the file*/
  if (!WriteOK(dinfo->outputfile,new_bmp_header,54)){
     printf("the data cann't be write into the new image.\n");  
      exit(0);
  }
 
  /*now we need to output the colormap*/
  gray_colormap=_gray_colormap;
  for (map_data=0;map_data<256;map_data++){
    *gray_colormap++=(U_CHAR)map_data;
    *gray_colormap++=(U_CHAR)map_data;
    *gray_colormap++=(U_CHAR)map_data;
    *gray_colormap++=0;
  }
  /*write the gray_colormap into the file*/
  if (!WriteOK(dinfo->outputfile,_gray_colormap,256*4)){
     printf("the data cann't be write into the new image.\n");  
      exit(0);
  }
 
}

/*write_byte_to_buffer can input a 32bits data byte by byte to the buffer*/
LOCAL(void)
write_byte_to_buffer(JSAMPROW new_bmp_header,int offset,int data)
{

  int j;
  unsigned char c;
  for (j=0;j<=3;j++){
    *(new_bmp_header+offset+j)=( U_CHAR) (data);
    data>>=8;
  }
}



/*free the memory*/
LOCAL(void)
free_mem(bmp_source_ptr sinfo)
{
  int i;
  free((void *)(sinfo->buffer));
  free((void *)(sinfo->rgb_buffer));
  free((void *)(sinfo->rgb_gray_tab));
  if (sinfo->colormap_used){
    for (i=0;i<=2;i++)
      free((void *) (sinfo->colormap[i]));
    free((void *) (sinfo->colormap));
  }

 }

  main(int argc,char *argv[])
    {
      
      bmp_source_struct main_sinfo;
      bmp_source_ptr sinfo=&main_sinfo;
      bmp_destination_struct main_dinfo;
      bmp_destination_ptr dinfo=&main_dinfo;
      sinfo->colormap_used=0;               /*We asume the image is real-color image*/

      if((sinfo->inputfile=fopen(argv[1],"rb"))==NULL){
	printf("The %s can't be opended\n",argv[1]);
	exit(0);
      }
      if((dinfo->outputfile=fopen(argv[2],"wb+"))==NULL){
	printf("The %s can't be created\n",argv[2]);
	exit(0);
      }
      jinit_color_transform(sinfo);      


      jinit_transform(sinfo,dinfo);
      
      transform_image(sinfo,dinfo);
      free_mem(sinfo);
      free((void *)(dinfo->buffer));
      fclose(sinfo->inputfile);
      fclose(dinfo->outputfile);
     }