source: abuse/trunk/src/imlib/xwdread.cpp @ 28 Tweet

/* readxwd.c */
/* This program is limited to X11 format XWD files */
#include "filter.hpp"
#include "system.h"
#include "image.hpp"
#include "palette.hpp"
#include "event.hpp"
#include "video.hpp"
#include "dos.h"
#include "main.hpp"
#include <stdio.h>
#include "macs.hpp"
#include "image24.hpp"

#define MAXCOLORS 256  
//#define MC(x) (((x)<3)==0)
#define MC(x) (x!=0)

// the following table converts rgb to cym.
int ca[8]={1,1,1,1,0,0,0,0},
    ma[8]={1,0,1,0,1,0,1,0},
    ya[8]={1,1,0,0,1,1,0,0};
// the following defines make a color threshold
#define RGB2C(r,g,b) (char)(ca[MC(b)|MC(g)<<1|MC(r)<<2])
#define RGB2Y(r,g,b) (char)(ya[MC(b)|MC(g)<<1|MC(r)<<2])
#define RGB2M(r,g,b) (char)(ma[MC(b)|MC(g)<<1|MC(r)<<2])

#define LSBFirst        0
#define MSBFirst        1

#define XYBitmap        0
#define XYPixmap        1
#define ZPixmap         2

#define StaticGray      0
#define GrayScale       1
#define StaticColor     2
#define PseudoColor     3
#define TrueColor       4
#define DirectColor     5

typedef unsigned long xwdval;
#define X11WD_FILE_VERSION 7
typedef struct {
    xwdval header_size;         /* Size of the entire file header (bytes). */
    xwdval file_version;        /* X11WD_FILE_VERSION */
    xwdval pixmap_format;       /* Pixmap format */
    xwdval pixmap_depth;        /* Pixmap depth */
    xwdval pixmap_width;        /* Pixmap width */
    xwdval pixmap_height;       /* Pixmap height */
    xwdval xoffset;             /* Bitmap x offset */
    xwdval byte_order;          /* MSBFirst, LSBFirst */
    xwdval bitmap_unit;         /* Bitmap unit */
    xwdval bitmap_bit_order;    /* MSBFirst, LSBFirst */
    xwdval bitmap_pad;          /* Bitmap scanline pad */
    xwdval bits_per_pixel;      /* Bits per pixel */
    xwdval bytes_per_line;      /* Bytes per scanline */
    xwdval visual_class;        /* Class of colormap */
    xwdval red_mask;            /* Z red mask */
    xwdval green_mask;          /* Z green mask */
    xwdval blue_mask;           /* Z blue mask */
    xwdval bits_per_rgb;        /* Log base 2 of distinct color values */
    xwdval colormap_entries;    /* Number of entries in colormap */
    xwdval ncolors;             /* Number of Color structures */
    xwdval window_width;        /* Window width */
    xwdval window_height;       /* Window height */
    long window_x;              /* Window upper left X coordinate */
    long window_y;              /* Window upper left Y coordinate */
    xwdval window_bdrwidth;     /* Window border width */
    } X11WDFileHeader;

typedef struct {
    unsigned long pixel;
    unsigned short red, green, blue;
    char flags;                 /* do_red, do_green, do_blue */
    char pad;
    } X11XColor;

image *getinit(FILE *file, palette *&pal, int *padrightP);
void getimage(FILE *file,image *image, int pad);
int getpixnum(FILE *file);


image *readxwd(char *input_file,palette *&pal)
//char *hdfpal,int *palsize,int *cols,int *rows)
{
  FILE *ifd;
  int padright;
  image *im;
#ifdef __WINDOWS
   HCURSOR OldCur;
   OldCur=SetCursor(LoadCursor(0,IDC_WAIT)); // set the cursor to the hour glass
#endif
  /* open input file */
  if (strcmp(input_file,"-") == 0)
    ifd = stdin;
  else
    ifd = fopen(input_file,"rb");
  /* get X info from file */
  if (!ifd)
  {
#ifndef __WINDOWS    
    printf("Unable to open %s\n"
           "Get your story strait and try again.\n",input_file);
    exit(0);
#endif
  }
  im=getinit( ifd, pal, &padright);
//cols, rows, &padright, palsize, hdfpal);

  /* alloc image array */

  /* fill image array */
  getimage(ifd, im, padright);
#ifdef __WINDOWS
   SetCursor(OldCur); // set the cursor to the hour glass
#endif

  return(im);
}

int bits_per_item, bits_used, bit_shift, bits_per_pixel, pixel_mask;
int bit_order, byte_swap;
char buf[4];
uint8_t *byteP;
uint16_t *shortP;
uint32_t *longP;


uint32_t bs_uint32(uint32_t s);
uint16_t bs_uint16(uint16_t s );


image *getinit(FILE *file, palette *&pal, int *padrightP)
{
  /* Assume X11 headers are larger than X10 ones. */
  uint8_t header[sizeof(X11WDFileHeader)];
  image *im;
  X11WDFileHeader *h11P;
  char junk[800];
  unsigned int i;
  int dummy1, dummy2, dummy3;
  uint16_t minred, maxred;
  X11XColor x11col;

  h11P = (X11WDFileHeader *) header;

  if (fread(header,sizeof(*h11P),1,file) != 1 )
    {
      fprintf(stderr,"couldn't read X11 XWD file header");
      exit(-1);
    }
  if ( h11P->file_version != X11WD_FILE_VERSION )
    {
      byte_swap = 1;
      h11P->file_version = bltl(h11P->file_version);
      if (h11P->file_version != X11WD_FILE_VERSION)
      {
        set_error(imINCORRECT_FILETYPE);
        return NULL;
      }

      h11P->header_size = bltl(h11P->header_size);
      h11P->file_version = bltl(h11P->file_version);
      h11P->pixmap_format = bltl(h11P->pixmap_format);
      h11P->pixmap_depth = bltl(h11P->pixmap_depth);
      h11P->pixmap_width = bltl(h11P->pixmap_width);
      h11P->pixmap_height = bltl(h11P->pixmap_height);
      h11P->xoffset =  bltl(h11P->xoffset);
      h11P->byte_order =  bltl(h11P->byte_order);
      h11P->bitmap_unit = bltl(h11P->bitmap_unit);
      h11P->bitmap_bit_order = bltl(h11P->bitmap_bit_order);
      h11P->bitmap_pad = bltl(h11P->bitmap_pad);
      h11P->bits_per_pixel = bltl(h11P->bits_per_pixel);
      h11P->bytes_per_line = bltl(h11P->bytes_per_line);
      h11P->visual_class = bltl(h11P->visual_class);
      h11P->red_mask = bltl(h11P->red_mask);
      h11P->green_mask = bltl(h11P->green_mask);
      h11P->blue_mask = bltl(h11P->blue_mask);
      h11P->bits_per_rgb = bltl(h11P->bits_per_rgb);
      h11P->colormap_entries = bltl(h11P->colormap_entries);
      h11P->ncolors = bltl(h11P->ncolors);
      h11P->window_width = bltl(h11P->window_width);
      h11P->window_height = bltl(h11P->window_height);
      h11P->window_x = bltl(h11P->window_x);
      h11P->window_y = bltl(h11P->window_y);
      h11P->window_bdrwidth = bltl(h11P->window_bdrwidth);
    }

  if ( fread( junk, 1, h11P->header_size - sizeof(*h11P), file ) !=
      h11P->header_size - sizeof(*h11P) )
    {
      fclose(file);
      set_error(imFILE_CORRUPTED);
      return NULL;
    }

  /* Check whether we can handle this dump. */
  if ( h11P->pixmap_depth > 8 )
    {
      fclose(file);
      set_error(imNOT_SUPPORTED);
      return NULL;
    }
  if ( h11P->bits_per_rgb > 8 )
    {
      fclose(file);
      set_error(imNOT_SUPPORTED);
      return NULL;
    }
  if ( h11P->ncolors > MAXCOLORS )
    {
      fclose(file);
      set_error(imNOT_SUPPORTED);
      return NULL;
    }
  if ( h11P->pixmap_format != ZPixmap )
    {
      fclose(file);
      set_error(imNOT_SUPPORTED);
      return NULL;
    }
  if ( h11P->bitmap_unit != 8 && h11P->bitmap_unit != 16 &&
      h11P->bitmap_unit != 32 )
    {
      fclose(file);
      set_error(imNOT_SUPPORTED);
      return NULL;
    }
  im=new image(h11P->pixmap_width,h11P->pixmap_height);
  pal=new palette(h11P->colormap_entries);
  *padrightP = h11P->bytes_per_line * 8 / h11P->bits_per_pixel - im->width();

/*****************************************************************************/
  /* Read X11 colormap. */
minred = 65535;
maxred = 0;
  for ( i = 0; i < h11P->colormap_entries; i++ )
    {
      if ( fread( &x11col, sizeof(X11XColor), 1, file ) != 1 )
        {
          fclose(file);
          set_error(imFILE_CORRUPTED);
          delete pal;
          return NULL;
        }
        else
        {
          x11col.pixel=bltl(x11col.pixel);
          x11col.red=bstl(x11col.red);
          x11col.green=bstl(x11col.green);
          x11col.blue=bstl(x11col.blue);
        }
      if (x11col.pixel < 256)
        {
          if (minred > x11col.red) minred = x11col.red;
          if (maxred < x11col.red) maxred = x11col.red;
          dummy1 = (unsigned) x11col.red>>8;
          dummy2 = (unsigned) x11col.green>>8;
          dummy3 = (unsigned) x11col.blue>>8;
          pal->set(i,dummy1,dummy2,dummy3);
        }
      else
        {
          fprintf(stderr,"pixel value outside of valid HDF palette\n");
          exit(-1);
        }
    }
  /* rest of stuff for getpixnum */
  bits_per_item = h11P->bitmap_unit;
  bits_used = bits_per_item;
  bits_per_pixel = h11P->bits_per_pixel;
  bit_order = h11P->bitmap_bit_order;
  pixel_mask = ( 1 << bits_per_pixel ) - 1;

  byteP = (uint8_t *) buf;
  shortP = (uint16_t *) buf;
  longP = (uint32_t *) buf;
  return im;
}

void getimage(FILE *file,image *im,int pad)
{
  int i,j;
  uint8_t *sl;
#if BYTE_ORDER!=BIG_ENDIAN
  printf("little guys\n");
#endif
  printf("getting image, bits_per_item = %d %d %d\n",bits_per_item,bits_used,bit_order==MSBFirst);
  for (i=0; i<im->height(); i++)
    {
      sl=im->scan_line(i);
      for (j=0; j<im->width(); j++)
        sl[j]= getpixnum(file);

      for ( j = 0; j < pad; j++ )
        getpixnum( file );
    }
}


int getpixnum(FILE *file)
{
  int p=0;
  if ( bits_used == bits_per_item )
    {
      if ( fread( buf, bits_per_item / 8, 1, file ) != 1 )
        fprintf(stderr, "couldn't read bits" );
      if ( byte_swap )
        switch ( bits_per_item )
          {
          case 8:
            break;

          case 16: *shortP=uint16_swap(*shortP); break;

          case 32: *longP=uint32_swap(*longP); break;

          default:
            fprintf(stderr, "can't happen" );
          }
      bits_used = 0;

//      if ( bit_order == MSBFirst )
        bit_shift = bits_per_item - bits_per_pixel;
//      else
//      bit_shift = 0;
    }

  switch ( bits_per_item )
    {
    case 8:
      p = ( *byteP >> bit_shift) & pixel_mask;
      break;

    case 16:
      p = ( *shortP >> bit_shift) & pixel_mask;
      break;

    case 32:
      p = ( *longP >> bit_shift) & pixel_mask;
      break;

    default:
      fprintf(stderr, "can't happen" );
    }

//  if ( bit_order == MSBFirst )
    bit_shift -= bits_per_pixel;
//  else
//    bit_shift += bits_per_pixel;
  bits_used += bits_per_pixel;

  return p;
}


uint16_t bs_uint16(uint16_t s )
{
  uint16_t ss;
  uint8_t *bp, t;

  ss = s;
  bp = (uint8_t *) &ss;
  t = bp[0];
  bp[0] = bp[1];
  bp[1] = t;
  return ss;
}

uint32_t bs_uint32(uint32_t l )
{
  uint32_t ii;
  uint8_t *bp, t;

  ii = l;
  bp = (uint8_t *) &ii;
  t = bp[0];
  bp[0] = bp[3];
  bp[3] = t;
  t = bp[1];
  bp[1] = bp[2];
  bp[2] = t;
  return ii;
}

struct BMP_header
{
  char id[2];
  long filesize;
  int16_t reserved[2];
  long headersize,infosize,width,height;
  int16_t biplanes,bits;
  long bicompression, bisizeimage, bixpelspermeter, biypelspermeter,
       biclrused,biclrimportant;
} bmp;

int read_BMP_header(FILE *fp)
{
  if (!fread(&bmp.id,1,2,fp)) return 0;         // 2 0
  bmp.filesize=read_uint32(fp);                   // 4 4
  if (!fread(bmp.reserved,1,4,fp)) return 0;    // 4 8
  bmp.headersize=read_uint32(fp);                 // 4 12
  bmp.infosize=read_uint32(fp);                   // 4 16
  bmp.width=read_uint32(fp);                      // 4 20
  bmp.height=read_uint32(fp);                     // 4 24
  bmp.biplanes=read_uint16(fp);                  // 2 26
  bmp.bits=read_uint16(fp);                      // 2 28
  bmp.bicompression=read_uint32(fp);              // 4 32
  bmp.bisizeimage=read_uint32(fp);                // 4 36
  bmp.bixpelspermeter=read_uint32(fp);            // 4 40
  bmp.biypelspermeter=read_uint32(fp);            // 4 44
  bmp.biclrused=read_uint32(fp);                  // 4 48
  bmp.biclrimportant=read_uint32(fp);             // 4 52
  return 1;
  
}




int bmp_bits(char *filename)
{
  FILE *fp;
  fp=fopen(filename,"rb");
  if (!fp) return 0;
  if (!read_BMP_header(fp)) return 0; 
  fclose(fp);

  if (bmp.id[0]!='B' || bmp.id[1]!='M')  
    return 0;
  else return bmp.bits;
}

image24 *read_bmp24(char *filename)
{
  image24 *im;
  FILE *fp;
  int i,j;
  fp=fopen(filename,"rb");
  if (!fp)
    return NULL;
  if (!read_BMP_header(fp)) return NULL;
  
  if (bmp.id[0]!='B' || bmp.id[1]!='M')  
    return NULL;

  if (bmp.bits!=24)
    return NULL;
  
  im=new image24((bmp.width+3)&(0xffffffff-3),
                 (bmp.height+3)&0xffffffff-3);
  if (!im)
    return NULL;
  
  uint8_t *sl;
  int trailer=im->width()%4;
  if (trailer==1) trailer=3;
  else if (trailer==3) trailer=1;
  uint8_t buf[9];
  for (i=im->height();i;i--)
  {
    sl=im->scan_line(i-1);
    for (j=0;j<im->width();j++)    
    { 
      fread(sl+2,1,1,fp);
      fread(sl+1,1,1,fp);      
      fread(sl,1,1,fp); 
      sl+=3;  
    }    
    if (trailer)
      fread(buf,trailer*3,1,fp);
  }
  fclose(fp);

  return im; 
}

image *read_bmp(palette *&pal, char *filename)
{
  image *im;
  FILE *fp;
  uint8_t pal_quad[4];
  char *scrap;
  int bytes,i;
  fp=fopen(filename,"rb");
  if (!fp)
    return NULL;

  if (!read_BMP_header(fp)) return NULL;
  
  if (bmp.id[0]!='B' || bmp.id[1]!='M')  
    return NULL;

  if (bmp.bits!=8)
    return NULL;
  
  im=new image((bmp.width+3)&(0xffffffff-3),
                 (bmp.height+3)&0xffffffff-3);

  if (!im)
    return NULL;

  pal=new palette(256);
  for (i=0;i<256;i++)
  {
    fread(pal_quad,1,4,fp);
    pal->set(i,pal_quad[2],pal_quad[1],pal_quad[0]);
  }
  bytes=(im->width()+3)/4;
  bytes*=4;
  scrap=(char *)jmalloc(bytes,"xwd_read scrap");
  for (i=im->height();i;i--)
  {
    fread(scrap,1,bytes,fp);
    memcpy(im->scan_line(i-1),scrap,im->width());
  }
  jfree(scrap);
  fclose(fp);
  return im;
}

int write_BMP_header(FILE *fp)
{
  if (!fwrite(&bmp.id,1,2,fp)) return 0;  
  write_uint32(fp,bmp.filesize);  
  if (!fwrite(bmp.reserved,1,4,fp)) return 0;   
  write_uint32(fp,bmp.headersize);
  write_uint32(fp,bmp.infosize);  
  write_uint32(fp,bmp.width);
  write_uint32(fp,bmp.height);
  write_uint16(fp,bmp.biplanes);
  write_uint16(fp,bmp.bits);
  write_uint32(fp,bmp.bicompression);
  write_uint32(fp,bmp.bisizeimage);
  write_uint32(fp,bmp.bixpelspermeter);
  write_uint32(fp,bmp.biypelspermeter);
  write_uint32(fp,bmp.biclrused);
  write_uint32(fp,bmp.biclrimportant);   
  return 1;
  
}

void write_bmp(image *im, palette *pal, char *filename)
{
  FILE *fp;
  int i,bytes;
  uint8_t pal_quad[4];
  fp=fopen(filename,"wb");
  if (!fp)
  { printf("Error : unable to open %s for writing!\n",filename);
    exit(0);
  }
  bytes=(im->width()+3)/4;
  memset((char *)&bmp,0,sizeof(bmp));
  memcpy(bmp.id,"BM",2);
  bmp.width=im->width();
  bmp.height=im->height();
  bmp.bits=8;
  bmp.infosize=0x28L;
  bmp.biplanes=1;
  bmp.headersize=1078;
  bmp.filesize=bmp.headersize+bytes*im->height()*4;
  bmp.bisizeimage=im->width()*im->height();
  bmp.biclrused=256;
  bmp.biclrimportant=256;
  write_BMP_header(fp);
  
  pal_quad[3]=0;
  for (i=0;i<256;i++)
  {
    pal->get(i,pal_quad[2],pal_quad[1],pal_quad[0]);
    fwrite(pal_quad,1,4,fp);
  }
  for (i=im->height();i;i--)
    fwrite(im->scan_line(i-1),1,bytes*4,fp);
  fclose(fp);
}