From e9e9684117719204929821028ba9dbb7915ea119 Mon Sep 17 00:00:00 2001 From: kraxel Date: Sun, 28 Mar 2004 11:31:57 +0000 Subject: Initial revision --- rd/Makefile | 2 + rd/magick.c | 85 ++++++++++++++ rd/read-bmp.c | 216 ++++++++++++++++++++++++++++++++++ rd/read-gif.c | 220 +++++++++++++++++++++++++++++++++++ rd/read-jpeg.c | 187 ++++++++++++++++++++++++++++++ rd/read-pcd.c | 78 +++++++++++++ rd/read-png.c | 164 ++++++++++++++++++++++++++ rd/read-ppm.c | 110 ++++++++++++++++++ rd/read-tiff.c | 195 +++++++++++++++++++++++++++++++ rd/read-xpm.c | 287 ++++++++++++++++++++++++++++++++++++++++++++++ rd/read-xwd.c | 357 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 11 files changed, 1901 insertions(+) create mode 100644 rd/Makefile create mode 100644 rd/magick.c create mode 100644 rd/read-bmp.c create mode 100644 rd/read-gif.c create mode 100644 rd/read-jpeg.c create mode 100644 rd/read-pcd.c create mode 100644 rd/read-png.c create mode 100644 rd/read-ppm.c create mode 100644 rd/read-tiff.c create mode 100644 rd/read-xpm.c create mode 100644 rd/read-xwd.c (limited to 'rd') diff --git a/rd/Makefile b/rd/Makefile new file mode 100644 index 0000000..4e33e30 --- /dev/null +++ b/rd/Makefile @@ -0,0 +1,2 @@ +default: + cd ..; $(MAKE) diff --git a/rd/magick.c b/rd/magick.c new file mode 100644 index 0000000..f17e5e3 --- /dev/null +++ b/rd/magick.c @@ -0,0 +1,85 @@ +#include +#include +#include + +#include "loader.h" +#include "viewer.h" + +extern char *binary; + +static int first = 1; +static ExceptionInfo exception; + +struct magick_state { + ImageInfo *image_info; + Image *image; +}; + +static void* +magick_init(FILE *fp, char *filename, int *width, int *height) +{ + struct magick_state *h; + + /* libmagick wants a filename */ + fclose(fp); + + if (first) { + /* init library first time */ + MagickIncarnate(binary); + GetExceptionInfo(&exception); + first = 0; + } + + h = malloc(sizeof(*h)); + memset(h,0,sizeof(*h)); + + h->image_info=CloneImageInfo(NULL); + strcpy(h->image_info->filename,filename); + h->image = ReadImage(h->image_info,&exception); + if (NULL == h->image) { + MagickError(exception.severity,exception.reason,exception.description); + goto oops; + } + + *width = h->image->rows; + *height = h->image->columns; + return h; + + oops: + if (h->image) + DestroyImage(h->image); + if (h->image_info) + DestroyImageInfo(h->image_info); + free(h); + return NULL; +} + +static void +magick_read(unsigned char *dst, int line, void *data) +{ + struct magick_state *h = data; + DispatchImage (h->image,0,line,h->image->columns, 1, + "RGB", 0, data); +} + +static void +magick_done(void *data) +{ + struct magick_state *h = data; + + DestroyImageInfo(h->image_info); + DestroyImage(h->image); + free(h); +} + +static struct ida_loader magick_loader = { + name: "libmagick", + init: magick_init, + read: magick_read, + done: magick_done, +}; + +static void __init init_rd(void) +{ + load_register(&magick_loader); +} diff --git a/rd/read-bmp.c b/rd/read-bmp.c new file mode 100644 index 0000000..30b5574 --- /dev/null +++ b/rd/read-bmp.c @@ -0,0 +1,216 @@ +#include +#include +#include +#include +#ifdef HAVE_ENDIAN_H +# include +#endif + +#include "readers.h" + +/* ---------------------------------------------------------------------- */ + +typedef unsigned int uint32; +typedef unsigned short uint16; + +/* bitmap files are little endian */ +#if BYTE_ORDER == LITTLE_ENDIAN +# define le16_to_cpu(x) (x) +# define le32_to_cpu(x) (x) +#elif BYTE_ORDER == BIG_ENDIAN +# define le16_to_cpu(x) (((x>>8) & 0x00ff) |\ + ((x<<8) & 0xff00)) +# define le32_to_cpu(x) (((x>>24) & 0x000000ff) |\ + ((x>>8) & 0x0000ff00) |\ + ((x<<8) & 0x00ff0000) |\ + ((x<<24) & 0xff000000)) +#else +# error "Oops: unknown byte order" +#endif + +/* ---------------------------------------------------------------------- */ +/* load */ + +struct bmp_hdr { + uint32 foobar; + + uint32 size; /* == BitMapInfoHeader */ + uint32 width; + uint32 height; + uint16 planes; + uint16 bit_cnt; + char compression[4]; + uint32 image_size; + uint32 xpels_meter; + uint32 ypels_meter; + uint32 num_colors; /* used colors */ + uint32 imp_colors; /* important colors */ + /* may be more for some codecs */ +}; + +struct bmp_cmap { + unsigned char blue; + unsigned char green; + unsigned char red; + unsigned char unused; +}; + +struct bmp_state { + struct bmp_hdr hdr; + struct bmp_cmap cmap[256]; + FILE *fp; +}; + +static void* +bmp_init(FILE *fp, char *filename, unsigned int page, + struct ida_image_info *i, int thumbnail) +{ + struct bmp_state *h; + + h = malloc(sizeof(*h)); + memset(h,0,sizeof(*h)); + h->fp = fp; + + fseek(fp,10,SEEK_SET); + fread(&h->hdr,sizeof(struct bmp_hdr),1,fp); + +#if BYTE_ORDER == BIG_ENDIAN + h->hdr.foobar = le32_to_cpu(h->hdr.foobar); + h->hdr.size = le32_to_cpu(h->hdr.size); + h->hdr.width = le32_to_cpu(h->hdr.width); + h->hdr.height = le32_to_cpu(h->hdr.height); + + h->hdr.planes = le16_to_cpu(h->hdr.planes); + h->hdr.bit_cnt = le16_to_cpu(h->hdr.bit_cnt); + + h->hdr.image_size = le32_to_cpu(h->hdr.image_size); + h->hdr.xpels_meter = le32_to_cpu(h->hdr.xpels_meter); + h->hdr.ypels_meter = le32_to_cpu(h->hdr.ypels_meter); + h->hdr.num_colors = le32_to_cpu(h->hdr.num_colors); + h->hdr.imp_colors = le32_to_cpu(h->hdr.imp_colors); +#endif + + if (debug) + fprintf(stderr,"bmp: hdr=%d size=%dx%d planes=%d" + " bits=%d size=%d res=%dx%d colors=%d/%d | %d\n", + h->hdr.size,h->hdr.width,h->hdr.height, + h->hdr.planes,h->hdr.bit_cnt,h->hdr.image_size, + h->hdr.xpels_meter,h->hdr.ypels_meter, + h->hdr.num_colors,h->hdr.imp_colors,h->hdr.foobar); + if (h->hdr.bit_cnt != 1 && + h->hdr.bit_cnt != 4 && + h->hdr.bit_cnt != 8 && + h->hdr.bit_cnt != 24) { + fprintf(stderr,"bmp: can't handle depth [%d]\n",h->hdr.bit_cnt); + goto oops; + } + if (h->hdr.compression[0] || h->hdr.compression[1] || + h->hdr.compression[2] || h->hdr.compression[3]) { + fprintf(stderr,"bmp: can't handle compressed bitmaps [%c%c%c%c]\n", + h->hdr.compression[0], + h->hdr.compression[1], + h->hdr.compression[2], + h->hdr.compression[3]); + goto oops; + } + + if (0 == h->hdr.num_colors && h->hdr.bit_cnt <= 8) + h->hdr.num_colors = (1 << h->hdr.bit_cnt); + if (h->hdr.num_colors > 256) + h->hdr.num_colors = 256; + if (h->hdr.num_colors) { + fseek(fp,14+h->hdr.size,SEEK_SET); + fread(&h->cmap,sizeof(struct bmp_cmap),h->hdr.num_colors,fp); + } + + i->width = h->hdr.width; + i->height = h->hdr.height; + if (h->hdr.xpels_meter) + i->dpi = res_m_to_inch(h->hdr.xpels_meter); + i->npages = 1; + return h; + + oops: + free(h); + return NULL; +} + +static void +bmp_read(unsigned char *dst, unsigned int line, void *data) +{ + struct bmp_state *h = data; + unsigned int ll,y,x,pixel,byte = 0; + + ll = (((h->hdr.width * h->hdr.bit_cnt + 31) & ~0x1f) >> 3); + y = h->hdr.height - line - 1; + fseek(h->fp,h->hdr.foobar + y * ll,SEEK_SET); + + switch (h->hdr.bit_cnt) { + case 1: + for (x = 0; x < h->hdr.width; x++) { + if (0 == (x & 0x07)) + byte = fgetc(h->fp); + pixel = byte & (0x80 >> (x & 0x07)) ? 1 : 0; + *(dst++) = h->cmap[pixel].red; + *(dst++) = h->cmap[pixel].green; + *(dst++) = h->cmap[pixel].blue; + } + break; + case 4: + for (x = 0; x < h->hdr.width; x++) { + if (x & 1) { + pixel = byte & 0xf; + } else { + byte = fgetc(h->fp); + pixel = byte >> 4; + } + *(dst++) = h->cmap[pixel].red; + *(dst++) = h->cmap[pixel].green; + *(dst++) = h->cmap[pixel].blue; + } + break; + case 8: + for (x = 0; x < h->hdr.width; x++) { + pixel = fgetc(h->fp); + *(dst++) = h->cmap[pixel].red; + *(dst++) = h->cmap[pixel].green; + *(dst++) = h->cmap[pixel].blue; + } + break; + case 24: + for (x = 0; x < h->hdr.width; x++) { + dst[2] = fgetc(h->fp); + dst[1] = fgetc(h->fp); + dst[0] = fgetc(h->fp); + dst += 3; + } + break; + default: + memset(dst,128,h->hdr.width*3); + break; + } +} + +static void +bmp_done(void *data) +{ + struct bmp_state *h = data; + + fclose(h->fp); + free(h); +} + +static struct ida_loader bmp_loader = { + magic: "BM", + moff: 0, + mlen: 2, + name: "bmp", + init: bmp_init, + read: bmp_read, + done: bmp_done, +}; + +static void __init init_rd(void) +{ + load_register(&bmp_loader); +} diff --git a/rd/read-gif.c b/rd/read-gif.c new file mode 100644 index 0000000..b841dc7 --- /dev/null +++ b/rd/read-gif.c @@ -0,0 +1,220 @@ +#include +#include +#include +#include + +#include "readers.h" + +struct gif_state { + FILE *infile; + GifFileType *gif; + GifPixelType *row; + GifPixelType *il; + int w,h; +}; + +static GifRecordType +gif_fileread(struct gif_state *h) +{ + GifRecordType RecordType; + GifByteType *Extension; + int ExtCode, rc; + char *type; + + for (;;) { + if (GIF_ERROR == DGifGetRecordType(h->gif,&RecordType)) { + if (debug) + fprintf(stderr,"gif: DGifGetRecordType failed\n"); + PrintGifError(); + return -1; + } + switch (RecordType) { + case IMAGE_DESC_RECORD_TYPE: + if (debug) + fprintf(stderr,"gif: IMAGE_DESC_RECORD_TYPE found\n"); + return RecordType; + case EXTENSION_RECORD_TYPE: + if (debug) + fprintf(stderr,"gif: EXTENSION_RECORD_TYPE found\n"); + for (rc = DGifGetExtension(h->gif,&ExtCode,&Extension); + NULL != Extension; + rc = DGifGetExtensionNext(h->gif,&Extension)) { + if (rc == GIF_ERROR) { + if (debug) + fprintf(stderr,"gif: DGifGetExtension failed\n"); + PrintGifError(); + return -1; + } + if (debug) { + switch (ExtCode) { + case COMMENT_EXT_FUNC_CODE: type="comment"; break; + case GRAPHICS_EXT_FUNC_CODE: type="graphics"; break; + case PLAINTEXT_EXT_FUNC_CODE: type="plaintext"; break; + case APPLICATION_EXT_FUNC_CODE: type="appl"; break; + default: type="???"; break; + } + fprintf(stderr,"gif: extcode=0x%x [%s]\n",ExtCode,type); + } + } + break; + case TERMINATE_RECORD_TYPE: + if (debug) + fprintf(stderr,"gif: TERMINATE_RECORD_TYPE found\n"); + return RecordType; + default: + if (debug) + fprintf(stderr,"gif: unknown record type [%d]\n",RecordType); + return -1; + } + } +} + +#if 0 +static void +gif_skipimage(struct gif_state *h) +{ + unsigned char *line; + int i; + + if (debug) + fprintf(stderr,"gif: skipping image record ...\n"); + DGifGetImageDesc(h->gif); + line = malloc(h->gif->SWidth); + for (i = 0; i < h->gif->SHeight; i++) + DGifGetLine(h->gif, line, h->gif->SWidth); + free(line); +} +#endif + +static void* +gif_init(FILE *fp, char *filename, unsigned int page, + struct ida_image_info *info, int thumbnail) +{ + struct gif_state *h; + GifRecordType RecordType; + int i, image = 0; + + h = malloc(sizeof(*h)); + memset(h,0,sizeof(*h)); + + h->infile = fp; + h->gif = DGifOpenFileHandle(fileno(fp)); + h->row = malloc(h->gif->SWidth * sizeof(GifPixelType)); + + while (0 == image) { + RecordType = gif_fileread(h); + switch (RecordType) { + case IMAGE_DESC_RECORD_TYPE: + if (GIF_ERROR == DGifGetImageDesc(h->gif)) { + if (debug) + fprintf(stderr,"gif: DGifGetImageDesc failed\n"); + PrintGifError(); + } + if (NULL == h->gif->SColorMap && + NULL == h->gif->Image.ColorMap) { + if (debug) + fprintf(stderr,"gif: oops: no colormap found\n"); + goto oops; + } +#if 0 + info->width = h->w = h->gif->SWidth; + info->height = h->h = h->gif->SHeight; +#else + info->width = h->w = h->gif->Image.Width; + info->height = h->h = h->gif->Image.Height; +#endif + info->npages = 1; + image = 1; + if (debug) + fprintf(stderr,"gif: reading image record ...\n"); + if (h->gif->Image.Interlace) { + if (debug) + fprintf(stderr,"gif: interlaced\n"); + h->il = malloc(h->w * h->h * sizeof(GifPixelType)); + for (i = 0; i < h->h; i += 8) + DGifGetLine(h->gif, h->il + h->w*i,h->w); + for (i = 4; i < h->gif->SHeight; i += 8) + DGifGetLine(h->gif, h->il + h->w*i,h->w); + for (i = 2; i < h->gif->SHeight; i += 4) + DGifGetLine(h->gif, h->il + h->w*i,h->w); + } + break; + case TERMINATE_RECORD_TYPE: + default: + goto oops; + } + } + if (0 == info->width || 0 == info->height) + goto oops; + + if (debug) + fprintf(stderr,"gif: s=%dx%d i=%dx%d\n", + h->gif->SWidth,h->gif->SHeight, + h->gif->Image.Width,h->gif->Image.Height); + return h; + + oops: + if (debug) + fprintf(stderr,"gif: fatal error, aborting\n"); + DGifCloseFile(h->gif); + fclose(h->infile); + free(h->row); + free(h); + return NULL; +} + +static void +gif_read(unsigned char *dst, unsigned int line, void *data) +{ + struct gif_state *h = data; + GifColorType *cmap; + int x; + + if (h->gif->Image.Interlace) { + if (line % 2) { + DGifGetLine(h->gif, h->row, h->w); + } else { + memcpy(h->row, h->il + h->w * line, h->w); + } + } else { + DGifGetLine(h->gif, h->row, h->w); + } + cmap = h->gif->Image.ColorMap ? + h->gif->Image.ColorMap->Colors : h->gif->SColorMap->Colors; + for (x = 0; x < h->w; x++) { + dst[0] = cmap[h->row[x]].Red; + dst[1] = cmap[h->row[x]].Green; + dst[2] = cmap[h->row[x]].Blue; + dst += 3; + } +} + +static void +gif_done(void *data) +{ + struct gif_state *h = data; + + if (debug) + fprintf(stderr,"gif: done, cleaning up\n"); + DGifCloseFile(h->gif); + fclose(h->infile); + if (h->il) + free(h->il); + free(h->row); + free(h); +} + +static struct ida_loader gif_loader = { + magic: "GIF", + moff: 0, + mlen: 3, + name: "libungif", + init: gif_init, + read: gif_read, + done: gif_done, +}; + +static void __init init_rd(void) +{ + load_register(&gif_loader); +} diff --git a/rd/read-jpeg.c b/rd/read-jpeg.c new file mode 100644 index 0000000..d12fb40 --- /dev/null +++ b/rd/read-jpeg.c @@ -0,0 +1,187 @@ +#include +#include +#include +#include +#include +#include + +#include + +#include "readers.h" +#include "misc.h" + +/* ---------------------------------------------------------------------- */ +/* load */ + +struct jpeg_state { + FILE * infile; /* source file */ + + struct jpeg_decompress_struct cinfo; + struct jpeg_error_mgr jerr; + JSAMPARRAY buffer; /* Output row buffer */ + int row_stride,linelength; /* physical row width in output buffer */ + unsigned char *image,*ptr; + + /* thumbnail */ + unsigned char *thumbnail; + unsigned int tpos, tsize; +}; + +/* ---------------------------------------------------------------------- */ +/* data source manager for thumbnail images */ + +static void thumbnail_src_init(struct jpeg_decompress_struct *cinfo) +{ + struct jpeg_state *h = container_of(cinfo, struct jpeg_state, cinfo); + cinfo->src->next_input_byte = h->thumbnail; + cinfo->src->bytes_in_buffer = h->tsize; +} + +static int thumbnail_src_fill(struct jpeg_decompress_struct *cinfo) +{ + fprintf(stderr,"jpeg: panic: no more thumbnail input data\n"); + exit(1); +} + +static void thumbnail_src_skip(struct jpeg_decompress_struct *cinfo, + long num_bytes) +{ + cinfo->src->next_input_byte += num_bytes; +} + +static void thumbnail_src_term(struct jpeg_decompress_struct *cinfo) +{ + /* nothing */ +} + +static struct jpeg_source_mgr thumbnail_mgr = { + .init_source = thumbnail_src_init, + .fill_input_buffer = thumbnail_src_fill, + .skip_input_data = thumbnail_src_skip, + .resync_to_restart = jpeg_resync_to_restart, + .term_source = thumbnail_src_term, +}; + +/* ---------------------------------------------------------------------- */ +/* jpeg loader */ + +static void* +jpeg_init(FILE *fp, char *filename, unsigned int page, + struct ida_image_info *i, int thumbnail) +{ + struct jpeg_state *h; + jpeg_saved_marker_ptr mark; + + h = malloc(sizeof(*h)); + memset(h,0,sizeof(*h)); + h->infile = fp; + + h->cinfo.err = jpeg_std_error(&h->jerr); + jpeg_create_decompress(&h->cinfo); + jpeg_save_markers(&h->cinfo, JPEG_COM, 0xffff); /* comment */ + jpeg_save_markers(&h->cinfo, JPEG_APP0+1, 0xffff); /* EXIF */ + jpeg_stdio_src(&h->cinfo, h->infile); + jpeg_read_header(&h->cinfo, TRUE); + + for (mark = h->cinfo.marker_list; NULL != mark; mark = mark->next) { + switch (mark->marker) { + case JPEG_COM: + if (debug) + fprintf(stderr,"jpeg: comment found (COM marker) [%.*s]\n", + (int)mark->data_length, mark->data); + load_add_extra(i,EXTRA_COMMENT,mark->data,mark->data_length); + break; + case JPEG_APP0 +1: + if (debug) + fprintf(stderr,"jpeg: exif data found (APP1 marker)\n"); + load_add_extra(i,EXTRA_COMMENT,mark->data,mark->data_length); + + if (thumbnail) { + ExifData *ed; + + ed = exif_data_new_from_data(mark->data,mark->data_length); + if (ed->data && + ed->data[0] == 0xff && + ed->data[1] == 0xd8) { + if (debug) + fprintf(stderr,"jpeg: exif thumbnail found\n"); + + /* save away thumbnail data */ + h->thumbnail = malloc(ed->size); + h->tsize = ed->size; + memcpy(h->thumbnail,ed->data,ed->size); + } + exif_data_unref(ed); + } + break; + } + } + + if (h->thumbnail) { + /* save image size */ + i->thumbnail = 1; + i->real_width = h->cinfo.image_width; + i->real_height = h->cinfo.image_height; + + /* re-setup jpeg */ + jpeg_destroy_decompress(&h->cinfo); + fclose(h->infile); + h->infile = NULL; + jpeg_create_decompress(&h->cinfo); + h->cinfo.src = &thumbnail_mgr; + jpeg_read_header(&h->cinfo, TRUE); + } + + h->cinfo.out_color_space = JCS_RGB; + jpeg_start_decompress(&h->cinfo); + i->width = h->cinfo.image_width; + i->height = h->cinfo.image_height; + i->npages = 1; + switch (h->cinfo.density_unit) { + case 0: /* unknown */ + break; + case 1: /* dot per inch */ + i->dpi = h->cinfo.X_density; + break; + case 2: /* dot per cm */ + i->dpi = res_cm_to_inch(h->cinfo.X_density); + break; + } + + return h; +} + +static void +jpeg_read(unsigned char *dst, unsigned int line, void *data) +{ + struct jpeg_state *h = data; + JSAMPROW row = dst; + jpeg_read_scanlines(&h->cinfo, &row, 1); +} + +static void +jpeg_done(void *data) +{ + struct jpeg_state *h = data; + jpeg_destroy_decompress(&h->cinfo); + if (h->infile) + fclose(h->infile); + if (h->thumbnail) + free(h->thumbnail); + free(h); +} + +struct ida_loader jpeg_loader = { + magic: "\xff\xd8", + moff: 0, + mlen: 2, + name: "libjpeg", + init: jpeg_init, + read: jpeg_read, + done: jpeg_done, +}; + +static void __init init_rd(void) +{ + load_register(&jpeg_loader); +} diff --git a/rd/read-pcd.c b/rd/read-pcd.c new file mode 100644 index 0000000..40c43d5 --- /dev/null +++ b/rd/read-pcd.c @@ -0,0 +1,78 @@ +#include +#include +#include +#include +#include "pcd.h" + +#include "readers.h" + +extern int pcd_res; + +/* ---------------------------------------------------------------------- */ +/* load */ + +struct pcd_state { + struct PCD_IMAGE img; + int left,top,width,height; +}; + +static void* +pcd_init(FILE *fp, char *filename, unsigned int page, + struct ida_image_info *i, int thumbnail) +{ + struct pcd_state *h; + + fclose(fp); + h = malloc(sizeof(*h)); + memset(h,0,sizeof(*h)); + + if (0 != pcd_open(&h->img, filename)) + goto oops; + if (-1 == pcd_select(&h->img, thumbnail ? 1 : pcd_res, + 0,0,0, pcd_get_rot(&h->img, 0), + &h->left, &h->top, &h->width, &h->height)) + goto oops; + if (-1 == pcd_decode(&h->img)) + goto oops; + + i->width = h->width; + i->height = h->height; + i->npages = 1; + return h; + + oops: + free(h); + return NULL; +} + +static void +pcd_read(unsigned char *dst, unsigned int line, void *data) +{ + struct pcd_state *h = data; + + pcd_get_image_line(&h->img, line, dst, PCD_TYPE_RGB, 0); +} + +static void +pcd_done(void *data) +{ + struct pcd_state *h = data; + + pcd_close(&h->img); + free(h); +} + +static struct ida_loader pcd_loader = { + magic: "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff", + moff: 0, + mlen: 16, + name: "libpcd", + init: pcd_init, + read: pcd_read, + done: pcd_done, +}; + +static void __init init_rd(void) +{ + load_register(&pcd_loader); +} diff --git a/rd/read-png.c b/rd/read-png.c new file mode 100644 index 0000000..c4f82d2 --- /dev/null +++ b/rd/read-png.c @@ -0,0 +1,164 @@ +#include +#include +#include +#include +#include + +#include "readers.h" + +static const char *ct[] = { + "gray", "X1", "rgb", "palette", + "graya", "X5", "rgba", "X7", +}; + +struct png_state { + FILE *infile; + png_structp png; + png_infop info; + png_bytep image; + png_uint_32 w,h; + int color_type; +}; + +static void* +png_init(FILE *fp, char *filename, unsigned int page, + struct ida_image_info *i, int thumbnail) +{ + struct png_state *h; + int bit_depth, interlace_type; + int pass, number_passes; + unsigned int y; + png_uint_32 resx, resy; + png_color_16 *file_bg, my_bg = { + .red = 192, + .green = 192, + .blue = 192, + .gray = 192, + }; + int unit; + + h = malloc(sizeof(*h)); + memset(h,0,sizeof(*h)); + + h->infile = fp; + + h->png = png_create_read_struct(PNG_LIBPNG_VER_STRING, + NULL, NULL, NULL); + if (NULL == h->png) + goto oops; + h->info = png_create_info_struct(h->png); + if (NULL == h->info) + goto oops; + + png_init_io(h->png, h->infile); + png_read_info(h->png, h->info); + png_get_IHDR(h->png, h->info, &h->w, &h->h, + &bit_depth,&h->color_type,&interlace_type, NULL,NULL); + png_get_pHYs(h->png, h->info, &resx, &resy, &unit); + i->width = h->w; + i->height = h->h; + if (PNG_RESOLUTION_METER == unit) + i->dpi = res_m_to_inch(resx); + if (debug) + fprintf(stderr,"png: color_type=%s #1\n",ct[h->color_type]); + i->npages = 1; + + png_set_packing(h->png); + if (bit_depth == 16) + png_set_strip_16(h->png); + if (h->color_type == PNG_COLOR_TYPE_PALETTE) + png_set_palette_to_rgb(h->png); + if (h->color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) + png_set_gray_1_2_4_to_8(h->png); + + if (png_get_bKGD(h->png, h->info, &file_bg)) { + png_set_background(h->png,file_bg,PNG_BACKGROUND_GAMMA_FILE,1,1.0); + } else { + png_set_background(h->png,&my_bg,PNG_BACKGROUND_GAMMA_SCREEN,0,1.0); + } + + number_passes = png_set_interlace_handling(h->png); + png_read_update_info(h->png, h->info); + + h->color_type = png_get_color_type(h->png, h->info); + if (debug) + fprintf(stderr,"png: color_type=%s #2\n",ct[h->color_type]); + + h->image = malloc(i->width * i->height * 4); + + for (pass = 0; pass < number_passes-1; pass++) { + if (debug) + fprintf(stderr,"png: pass #%d\n",pass); + for (y = 0; y < i->height; y++) { + png_bytep row = h->image + y * i->width * 4; + png_read_rows(h->png, &row, NULL, 1); + } + } + + return h; + + oops: + if (h->image) + free(h->image); + if (h->png) + png_destroy_read_struct(&h->png, NULL, NULL); + fclose(h->infile); + free(h); + return NULL; +} + +static void +png_read(unsigned char *dst, unsigned int line, void *data) +{ + struct png_state *h = data; + + png_bytep row = h->image + line * h->w * 4; + switch (h->color_type) { + case PNG_COLOR_TYPE_GRAY: + png_read_rows(h->png, &row, NULL, 1); + load_gray(dst,row,h->w); + break; + case PNG_COLOR_TYPE_RGB: + png_read_rows(h->png, &row, NULL, 1); + memcpy(dst,row,3*h->w); + break; + case PNG_COLOR_TYPE_RGB_ALPHA: + png_read_rows(h->png, &row, NULL, 1); + load_rgba(dst,row,h->w); + break; + case PNG_COLOR_TYPE_GRAY_ALPHA: + png_read_rows(h->png, &row, NULL, 1); + load_graya(dst,row,h->w); + break; + default: + /* shouldn't happen */ + fprintf(stderr,"Oops: %s:%d\n",__FILE__,__LINE__); + exit(1); + } +} + +static void +png_done(void *data) +{ + struct png_state *h = data; + + free(h->image); + png_destroy_read_struct(&h->png, &h->info, NULL); + fclose(h->infile); + free(h); +} + +static struct ida_loader png_loader = { + magic: "\x89PNG", + moff: 0, + mlen: 4, + name: "libpng", + init: png_init, + read: png_read, + done: png_done, +}; + +static void __init init_rd(void) +{ + load_register(&png_loader); +} diff --git a/rd/read-ppm.c b/rd/read-ppm.c new file mode 100644 index 0000000..b7eb326 --- /dev/null +++ b/rd/read-ppm.c @@ -0,0 +1,110 @@ +#include +#include +#include +#include + +#include "readers.h" + +/* ---------------------------------------------------------------------- */ +/* load */ + +struct ppm_state { + FILE *infile; + int width,height; + unsigned char *row; +}; + +static void* +pnm_init(FILE *fp, char *filename, unsigned int page, + struct ida_image_info *i, int thumbnail) +{ + struct ppm_state *h; + char line[1024]; + + h = malloc(sizeof(*h)); + memset(h,0,sizeof(*h)); + + h->infile = fp; + fgets(line,sizeof(line),fp); /* Px */ + fgets(line,sizeof(line),fp); /* width height */ + while ('#' == line[0]) + fgets(line,sizeof(line),fp); /* skip comments */ + sscanf(line,"%d %d",&h->width,&h->height); + fgets(line,sizeof(line),fp); /* ??? */ + if (0 == h->width || 0 == h->height) + goto oops; + i->width = h->width; + i->height = h->height; + i->npages = 1; + h->row = malloc(h->width*3); + + return h; + + oops: + fclose(fp); + free(h); + return NULL; +} + +static void +ppm_read(unsigned char *dst, unsigned int line, void *data) +{ + struct ppm_state *h = data; + + fread(dst,h->width,3,h->infile); +} + +static void +pgm_read(unsigned char *dst, unsigned int line, void *data) +{ + struct ppm_state *h = data; + unsigned char *src; + int x; + + fread(h->row,h->width,1,h->infile); + src = h->row; + for (x = 0; x < h->width; x++) { + dst[0] = src[0]; + dst[1] = src[0]; + dst[2] = src[0]; + dst += 3; + src += 1; + } +} + +static void +pnm_done(void *data) +{ + struct ppm_state *h = data; + + fclose(h->infile); + free(h->row); + free(h); +} + +struct ida_loader ppm_loader = { + magic: "P6", + moff: 0, + mlen: 2, + name: "ppm parser", + init: pnm_init, + read: ppm_read, + done: pnm_done, +}; + +static struct ida_loader pgm_loader = { + magic: "P5", + moff: 0, + mlen: 2, + name: "pgm parser", + init: pnm_init, + read: pgm_read, + done: pnm_done, +}; + +static void __init init_rd(void) +{ + load_register(&ppm_loader); + load_register(&pgm_loader); +} + diff --git a/rd/read-tiff.c b/rd/read-tiff.c new file mode 100644 index 0000000..3f75b83 --- /dev/null +++ b/rd/read-tiff.c @@ -0,0 +1,195 @@ +#include +#include +#include +#include +#include + +#include "readers.h" + +struct tiff_state { + TIFF* tif; + char emsg[1024]; + tdir_t ndirs; /* Number of directories */ + /* (could be interpreted as number of pages) */ + uint32 width,height; + uint16 config,nsamples,depth,fillorder,photometric; + uint32* row; + uint32* image; + uint16 resunit; + float xres,yres; +}; + +static void* +tiff_init(FILE *fp, char *filename, unsigned int page, + struct ida_image_info *i, int thumbnail) +{ + struct tiff_state *h; + + fclose(fp); + h = malloc(sizeof(*h)); + memset(h,0,sizeof(*h)); + + TIFFSetWarningHandler(NULL); + h->tif = TIFFOpen(filename,"r"); + if (NULL == h->tif) + goto oops; + /* Determine number of directories */ + h->ndirs = 1; + while (TIFFReadDirectory(h->tif)) + h->ndirs++; + i->npages = h->ndirs; + /* Select requested directory (page) */ + if (!TIFFSetDirectory(h->tif, (tdir_t)page)) + goto oops; + + TIFFGetField(h->tif, TIFFTAG_IMAGEWIDTH, &h->width); + TIFFGetField(h->tif, TIFFTAG_IMAGELENGTH, &h->height); + TIFFGetField(h->tif, TIFFTAG_PLANARCONFIG, &h->config); + TIFFGetField(h->tif, TIFFTAG_SAMPLESPERPIXEL, &h->nsamples); + TIFFGetField(h->tif, TIFFTAG_BITSPERSAMPLE, &h->depth); + TIFFGetField(h->tif, TIFFTAG_FILLORDER, &h->fillorder); + TIFFGetField(h->tif, TIFFTAG_PHOTOMETRIC, &h->photometric); + h->row = malloc(TIFFScanlineSize(h->tif)); + if (debug) + fprintf(stderr,"tiff: %" PRId32 "x%" PRId32 ", planar=%d, " + "nsamples=%d, depth=%d fo=%d pm=%d scanline=%" PRId32 "\n", + h->width,h->height,h->config,h->nsamples,h->depth, + h->fillorder,h->photometric, + TIFFScanlineSize(h->tif)); + + if (PHOTOMETRIC_PALETTE == h->photometric || + PHOTOMETRIC_YCBCR == h->photometric || + PHOTOMETRIC_SEPARATED == h->photometric || + TIFFIsTiled(h->tif) || + (1 != h->depth && 8 != h->depth)) { + /* for the more difficuilt cases we let libtiff + * do all the hard work. Drawback is that we lose + * progressive loading and decode everything here */ + if (debug) + fprintf(stderr,"tiff: reading whole image [TIFFReadRGBAImage]\n"); + h->image=malloc(4*h->width*h->height); + TIFFReadRGBAImage(h->tif, h->width, h->height, h->image, 0); + } else { + if (debug) + fprintf(stderr,"tiff: reading scanline by scanline\n"); + h->row = malloc(TIFFScanlineSize(h->tif)); + } + + i->width = h->width; + i->height = h->height; + + if (TIFFGetField(h->tif, TIFFTAG_RESOLUTIONUNIT, &h->resunit) && + TIFFGetField(h->tif, TIFFTAG_XRESOLUTION, &h->xres) && + TIFFGetField(h->tif, TIFFTAG_YRESOLUTION, &h->yres)) { + switch (h->resunit) { + case RESUNIT_NONE: + break; + case RESUNIT_INCH: + i->dpi = h->xres; + break; + case RESUNIT_CENTIMETER: + i->dpi = res_cm_to_inch(h->xres); + break; + } + } + + return h; + + oops: + if (h->tif) + TIFFClose(h->tif); + free(h); + return NULL; +} + +static void +tiff_read(unsigned char *dst, unsigned int line, void *data) +{ + struct tiff_state *h = data; + int s,on,off; + + if (h->image) { + /* loaded whole image using TIFFReadRGBAImage() */ + uint32 *row = h->image + h->width * (h->height - line -1); + load_rgba(dst,(unsigned char*)row,h->width); + return; + } + + if (h->config == PLANARCONFIG_CONTIG) { + TIFFReadScanline(h->tif, h->row, line, 0); + } else if (h->config == PLANARCONFIG_SEPARATE) { + for (s = 0; s < h->nsamples; s++) + TIFFReadScanline(h->tif, h->row, line, s); + } + + switch (h->nsamples) { + case 1: + if (1 == h->depth) { + /* black/white */ + on = 0, off = 0; + if (PHOTOMETRIC_MINISWHITE == h->photometric) + on = 0, off = 255; + if (PHOTOMETRIC_MINISBLACK == h->photometric) + on = 255, off = 0; +#if 0 + /* Huh? Does TIFFReadScanline handle this already ??? */ + if (FILLORDER_MSB2LSB == h->fillorder) + load_bits_msb(dst,(unsigned char*)(h->row),h->width,on,off); + else + load_bits_lsb(dst,(unsigned char*)(h->row),h->width,on,off); +#else + load_bits_msb(dst,(unsigned char*)(h->row),h->width,on,off); +#endif + } else { + /* grayscaled */ + load_gray(dst,(unsigned char*)(h->row),h->width); + } + break; + case 3: + /* rgb */ + memcpy(dst,h->row,3*h->width); + break; + case 4: + /* rgb+alpha */ + load_rgba(dst,(unsigned char*)(h->row),h->width); + break; + } +} + +static void +tiff_done(void *data) +{ + struct tiff_state *h = data; + + TIFFClose(h->tif); + if (h->row) + free(h->row); + if (h->image) + free(h->image); + free(h); +} + +static struct ida_loader tiff1_loader = { + magic: "MM\x00\x2a", + moff: 0, + mlen: 4, + name: "libtiff", + init: tiff_init, + read: tiff_read, + done: tiff_done, +}; +static struct ida_loader tiff2_loader = { + magic: "II\x2a\x00", + moff: 0, + mlen: 4, + name: "libtiff", + init: tiff_init, + read: tiff_read, + done: tiff_done, +}; + +static void __init init_rd(void) +{ + load_register(&tiff1_loader); + load_register(&tiff2_loader); +} diff --git a/rd/read-xpm.c b/rd/read-xpm.c new file mode 100644 index 0000000..affdce6 --- /dev/null +++ b/rd/read-xpm.c @@ -0,0 +1,287 @@ +#include +#include +#include +#include + +#include +#include + +#include "ida.h" + +#include "readers.h" +#include "viewer.h" + +/* ---------------------------------------------------------------------- */ +/* load */ + +struct xpm_color { + char name[8]; + XColor color; +}; + +struct xpm_state { + FILE *infile; + int width,height,colors,chars; + struct xpm_color *cmap; + char *charline; + char *rgbrow; +}; + +static void* +xpm_init(FILE *fp, char *filename, unsigned int page, + struct ida_image_info *info, int thumbnail) +{ + struct xpm_state *h; + char line[1024],cname[32],*tmp; + XColor dummy; + int i; + Colormap cmap = DefaultColormapOfScreen(XtScreen(app_shell)); + + h = malloc(sizeof(*h)); + memset(h,0,sizeof(*h)); + h->infile = fp; + + fgets(line,sizeof(line)-1,fp); /* XPM */ + fgets(line,sizeof(line)-1,fp); /* static char ... */ + while (0 == strncmp(line,"/*",2)) { + while (NULL == strstr(line,"*/")) + fgets(line,sizeof(line)-1,fp); + fgets(line,sizeof(line)-1,fp); + } + + /* size, colors */ + fgets(line,sizeof(line)-1,fp); + if (0 == strncmp(line,"/*",2)) { + while (NULL == strstr(line,"*/")) + fgets(line,sizeof(line)-1,fp); + fgets(line,sizeof(line)-1,fp); + } + if (4 != sscanf(line,"\"%d %d %d %d", + &h->width,&h->height,&h->colors,&h->chars)) + goto oops; + if (h->chars > 7) + goto oops; + + /* read color table */ + h->cmap = malloc(h->colors * sizeof(struct xpm_color)); + memset(h->cmap,0,h->colors * sizeof(struct xpm_color)); + for (i = 0; i < h->colors; i++) { + fgets(line,sizeof(line)-1,fp); + while (0 == strncmp(line,"/*",2)) { + while (NULL == strstr(line,"*/")) + fgets(line,sizeof(line)-1,fp); + fgets(line,sizeof(line)-1,fp); + } + memcpy(h->cmap[i].name,line+1,h->chars); + + if (NULL != (tmp = strstr(line+1+h->chars,"c "))) { + /* color */ + sscanf(tmp+2,"%32[^\" ]",cname); + } else if (NULL != (tmp = strstr(line+h->chars,"m "))) { + /* mono */ + sscanf(tmp+2,"%32[^\" ]",cname); + } else if (NULL != (tmp = strstr(line+h->chars,"g "))) { + /* gray? */ + sscanf(tmp+2,"%32[^\" ]",cname); + } else + goto oops; + if (0 == strcasecmp(cname,"none")) + /* transparent */ + strcpy(cname,"lightgray"); + if (debug) + fprintf(stderr,"xpm: cmap: \"%*.*s\" => %s\n", + h->chars,h->chars,h->cmap[i].name,cname); +#if 0 + if (1 != sscanf(line+1+h->chars," c %32[^\"]",cname)) + goto oops; +#endif + XLookupColor(dpy,cmap,cname,&h->cmap[i].color,&dummy); + } + h->charline = malloc(h->width * h->chars + 8); + h->rgbrow = malloc(h->width * 3); + + info->width = h->width; + info->height = h->height; + info->npages = 1; + return h; + + oops: + fclose(fp); + free(h); + return NULL; +} + +static void +xpm_read(unsigned char *dst, unsigned int line, void *data) +{ + struct xpm_state *h = data; + char *src; + int i,c; + + fgets(h->charline,h->width * h->chars + 8,h->infile); + while (0 == strncmp(h->charline,"/*",2)) { + while (NULL == strstr(h->charline,"*/")) + fgets(h->charline,h->width * h->chars + 8,h->infile); + fgets(h->charline,h->width * h->chars + 8,h->infile); + } + src = h->charline+1; + for (i = 0; i < h->width; i++) { + for (c = 0; c < h->colors; c++) { + char *name = h->cmap[c].name; + if (src[0] != name[0]) + continue; + if (1 == h->chars) + break; + if (src[1] != name[1]) + continue; + if (2 == h->chars) + break; + if (0 == strncmp(src+2,name+2,h->chars-2)) + break; + } + if (c == h->colors) + continue; + dst[0] = h->cmap[c].color.red >> 8; + dst[1] = h->cmap[c].color.green >> 8; + dst[2] = h->cmap[c].color.blue >> 8; + src += h->chars; + dst += 3; + } +} + +static void +xpm_done(void *data) +{ + struct xpm_state *h = data; + + fclose(h->infile); + free(h->charline); + free(h->rgbrow); + free(h->cmap); + free(h); +} + +/* ---------------------------------------------------------------------- */ + +struct xbm_state { + FILE *infile; + int width,height; +}; + +static void* +xbm_init(FILE *fp, char *filename, unsigned int page, + struct ida_image_info *info, int thumbnail) +{ + struct xbm_state *h; + char line[256],dummy[128]; + int i; + + h = malloc(sizeof(*h)); + memset(h,0,sizeof(*h)); + h->infile = fp; + + for (i = 0; i < 128; i++) { + fgets(line,sizeof(line)-1,fp); + if (0 == strncmp(line,"#define",7)) + break; + } + if (128 == i) + goto oops; + + if (2 != sscanf(line,"#define %127s %d",dummy,&h->width)) + goto oops; + fgets(line,sizeof(line)-1,fp); + if (2 != sscanf(line,"#define %127s %d",dummy,&h->height)) + goto oops; + if (debug) + fprintf(stderr,"xbm: %dx%d\n",h->width,h->height); + + for (i = 0; i < 4; i++) { + fgets(line,sizeof(line)-1,fp); + if (strstr(line,"[] = {")) + break; + } + if (4 == i) + goto oops; + + info->width = h->width; + info->height = h->height; + info->npages = 1; + return h; + + oops: + if (debug) + fprintf(stderr,"xbm: %s",line); + fclose(fp); + free(h); + return NULL; +} + +static void +xbm_read(unsigned char *dst, unsigned int line, void *data) +{ + struct xbm_state *h = data; + int x,val; + + for (x = 0; x < h->width; x++) { + if (0 == (x % 8)) + fscanf(h->infile," 0x%x,",&val); + if (val & (1 << (x % 8))) { + *(dst++) = 0; + *(dst++) = 0; + *(dst++) = 0; + } else { + *(dst++) = 255; + *(dst++) = 255; + *(dst++) = 255; + } + } +} + +static void +xbm_done(void *data) +{ + struct xpm_state *h = data; + + fclose(h->infile); + free(h); +} + +/* ---------------------------------------------------------------------- */ + +static struct ida_loader xpm_loader = { + magic: "/* XPM */", + moff: 0, + mlen: 9, + name: "xpm parser", + init: xpm_init, + read: xpm_read, + done: xpm_done, +}; + +static struct ida_loader xbm1_loader = { + magic: "#define", + moff: 0, + mlen: 7, + name: "xbm parser", + init: xbm_init, + read: xbm_read, + done: xbm_done, +}; + +static struct ida_loader xbm2_loader = { + magic: "/*", + moff: 0, + mlen: 2, + name: "xbm parser", + init: xbm_init, + read: xbm_read, + done: xbm_done, +}; + +static void __init init_rd(void) +{ + load_register(&xpm_loader); + load_register(&xbm1_loader); + load_register(&xbm2_loader); +} diff --git a/rd/read-xwd.c b/rd/read-xwd.c new file mode 100644 index 0000000..8d15cf3 --- /dev/null +++ b/rd/read-xwd.c @@ -0,0 +1,357 @@ +#include +#include +#include +#include +#include +#include +#include +#ifdef HAVE_ENDIAN_H +# include +#endif + +#include "readers.h" +#include "viewer.h" +#include "xwd.h" +#include "x11.h" +#include "ida.h" + +/* xwd files are big endian */ +#if BYTE_ORDER == BIG_ENDIAN +# define be16_to_cpu(x) (x) +# define be32_to_cpu(x) (x) +#elif BYTE_ORDER == LITTLE_ENDIAN +# define be16_to_cpu(x) (((x>>8) & 0x00ff) |\ + ((x<<8) & 0xff00)) +# define be32_to_cpu(x) (((x>>24) & 0x000000ff) |\ + ((x>>8) & 0x0000ff00) |\ + ((x<<8) & 0x00ff0000) |\ + ((x<<24) & 0xff000000)) +#else +# error "Oops: unknown byte order" +#endif + +static char *vclass[] = { + "StaticGray", + "GrayScale", + "StaticColor", + "PseudoColor", + "TrueColor", + "DirectColor", +}; +static char *order[] = { + "LSBFirst", + "MSBFirst", +}; +static char *fmt[] = { + "XYBitmap", + "XYPixmap", + "ZPixmap", +}; + +/* ----------------------------------------------------------------------- */ + +struct xwd_state { + FILE *infile; + XWDFileHeader header; + XWDColor cmap[256]; + int width,bpp; + unsigned char *row; + unsigned long *pix; + unsigned long r_mask,g_mask,b_mask; + int r_shift,g_shift,b_shift; + int r_bits,g_bits,b_bits; +}; + +static void +xwd_map(struct xwd_state *h) +{ + int i; + unsigned long mask; + + h->r_mask = be32_to_cpu(h->header.red_mask); + h->g_mask = be32_to_cpu(h->header.green_mask); + h->b_mask = be32_to_cpu(h->header.blue_mask); + for (i = 0; i < 32; i++) { + mask = (1 << i); + if (h->r_mask & mask) + h->r_bits++; + else if (!h->r_bits) + h->r_shift++; + if (h->g_mask & mask) + h->g_bits++; + else if (!h->g_bits) + h->g_shift++; + if (h->b_mask & mask) + h->b_bits++; + else if (!h->b_bits) + h->b_shift++; + } + h->r_shift -= (8 - h->r_bits); + h->g_shift -= (8 - h->g_bits); + h->b_shift -= (8 - h->b_bits); +#if 0 + fprintf(stderr,"xwd: color: bits shift\n"); + fprintf(stderr,"xwd: red : %04i %05i\n", h->r_bits, h->r_shift); + fprintf(stderr,"xwd: green: %04i %05i\n", h->g_bits, h->g_shift); + fprintf(stderr,"xwd: blue : %04i %05i\n", h->b_bits, h->b_shift); +#endif +} + + +static void* +xwd_init(FILE *fp, char *filename, unsigned int page, + struct ida_image_info *i, int thumbnail) +{ + struct xwd_state *h; + char *buf; + int size; + + h = malloc(sizeof(*h)); + memset(h,0,sizeof(*h)); + h->infile = fp; + + fread(&h->header,sizeof(h->header),1,fp); + + if ((be32_to_cpu(h->header.pixmap_format) >sizeof(fmt)/sizeof(char*)) || + (be32_to_cpu(h->header.byte_order) >sizeof(order)/sizeof(char*)) || + (be32_to_cpu(h->header.visual_class) >sizeof(vclass)/sizeof(char*))) { + fprintf(stderr,"xwd: invalid file\n"); + goto oops; + } + + if (debug) + fprintf(stderr, + "xwd: fmt=%s depth=%" PRId32 " size=%" PRId32 "x%" PRId32 + " bpp=%" PRId32 " bpl=%" PRId32 "\n" + "xwd: order=%s vclass=%s masks=%" PRIx32 "/%" PRIx32 + "/%" PRIx32 " cmap=%" PRId32 "\n", + fmt[be32_to_cpu(h->header.pixmap_format)], + be32_to_cpu(h->header.pixmap_depth), + be32_to_cpu(h->header.pixmap_width), + be32_to_cpu(h->header.pixmap_height), + be32_to_cpu(h->header.bits_per_pixel), + be32_to_cpu(h->header.bytes_per_line), + order[be32_to_cpu(h->header.byte_order)], + vclass[be32_to_cpu(h->header.visual_class)], + be32_to_cpu(h->header.red_mask), + be32_to_cpu(h->header.green_mask), + be32_to_cpu(h->header.blue_mask), + be32_to_cpu(h->header.colormap_entries)); + + size = be32_to_cpu(h->header.header_size)-sizeof(h->header); + buf = malloc(size); + fread(buf,size,1,fp); + if (debug) + fprintf(stderr,"xwd: name=%s\n",buf); + free(buf); + + /* check format */ + if (8 != be32_to_cpu(h->header.bits_per_pixel) && + 16 != be32_to_cpu(h->header.bits_per_pixel) && + 24 != be32_to_cpu(h->header.bits_per_pixel) && + 32 != be32_to_cpu(h->header.bits_per_pixel)) { + fprintf(stderr,"xwd: Oops: bpp != 8/16/24/32\n"); + goto oops; + } + if (be32_to_cpu(h->header.pixmap_format) != ZPixmap) { + fprintf(stderr,"xwd: Oops: can read only ZPixmap format\n"); + goto oops; + } + + /* color map */ + if (be32_to_cpu(h->header.colormap_entries) > 256) { + fprintf(stderr,"xwd: colormap too big (%" PRId32 " > 256)\n", + be32_to_cpu(h->header.colormap_entries)); + goto oops; + } + fread(&h->cmap,sizeof(XWDColor),be32_to_cpu(h->header.colormap_entries),fp); +#if 0 + for (i = 0; i < be32_to_cpu(h->header.colormap_entries); i++) + fprintf(stderr, "xwd cmap: %d: " + "pix=%ld rgb=%d/%d/%d flags=%d pad=%d\n",i, + be32_to_cpu(h->cmap[i].pixel), + be16_to_cpu(h->cmap[i].red), + be16_to_cpu(h->cmap[i].green), + be16_to_cpu(h->cmap[i].blue), + h->cmap[i].flags, + h->cmap[i].pad); +#endif + + switch (be32_to_cpu(h->header.visual_class)) { + case StaticGray: + case PseudoColor: + /* nothing */ + break; + case TrueColor: + case DirectColor: + xwd_map(h); + break; + default: + fprintf(stderr,"xwd: Oops: visual not implemented [%s]\n", + vclass[be32_to_cpu(h->header.visual_class)]); + goto oops; + } + + h->bpp = be32_to_cpu(h->header.bits_per_pixel); + h->width = be32_to_cpu(h->header.pixmap_width); + h->pix = malloc(h->width*sizeof(unsigned long)); + h->row = malloc(be32_to_cpu(h->header.bytes_per_line)); + i->width = be32_to_cpu(h->header.pixmap_width); + i->height = be32_to_cpu(h->header.pixmap_height); + i->npages = 1; + return h; + + oops: + fclose(h->infile); + free(h); + return NULL; +} + +static void +xwd_parse(unsigned char *dst, unsigned int line, void *data) +{ + struct xwd_state *h = data; + unsigned long r,g,b; + int x,i,bits; + + /* data to 32bit values */ + memset(h->pix,0,h->width * sizeof(unsigned long)); + if (be32_to_cpu(h->header.byte_order) == LSBFirst) { + for (i = 0, x = 0; x < h->width; x++) + for (bits = 0; bits < h->bpp; bits += 8) + h->pix[x] |= h->row[i++] << bits; + } else { + for (i = 0, x = 0; x < h->width; x++) + for (bits = 0; bits < h->bpp; bits += 8) + h->pix[x] <<= 8, h->pix[x] |= h->row[i++]; + } + + /* transform to rgb */ + switch (be32_to_cpu(h->header.visual_class)) { + case StaticGray: + for (x = 0; x < h->width; x++) { + dst[0] = h->pix[x]; + dst[1] = h->pix[x]; + dst[2] = h->pix[x]; + dst += 3; + } + break; + case PseudoColor: + for (x = 0; x < h->width; x++) { + dst[0] = be16_to_cpu(h->cmap[h->pix[x]].red) >> 8; + dst[1] = be16_to_cpu(h->cmap[h->pix[x]].green) >> 8; + dst[2] = be16_to_cpu(h->cmap[h->pix[x]].blue) >> 8; + dst += 3; + } + break; + case TrueColor: + case DirectColor: + for (x = 0; x < h->width; x++) { + r = h->pix[x] & h->r_mask; + if (h->r_shift > 0) + r >>= h->r_shift; + if (h->r_shift < 0) + r <<= -h->r_shift; + g = h->pix[x] & h->g_mask; + if (h->g_shift > 0) + g >>= h->g_shift; + if (h->g_shift < 0) + g <<= -h->g_shift; + b = h->pix[x] & h->b_mask; + if (h->b_shift > 0) + b >>= h->b_shift; + if (h->b_shift < 0) + b <<= -h->b_shift; + dst[0] = r; + dst[1] = g; + dst[2] = b; + dst += 3; + } + break; + } +} + +static void +xwd_read(unsigned char *dst, unsigned int line, void *data) +{ + struct xwd_state *h = data; + + fread(h->row,be32_to_cpu(h->header.bytes_per_line),1,h->infile); + xwd_parse(dst, line, data); +} + +static void +xwd_done(void *data) +{ + struct xwd_state *h = data; + + fclose(h->infile); + free(h->pix); + free(h->row); + free(h); +} + +static struct ida_loader xwd_loader = { + magic: "\0\0\0\7", + moff: 4, + mlen: 4, + name: "xwd", + init: xwd_init, + read: xwd_read, + done: xwd_done, +}; + +static void __init init_rd(void) +{ + load_register(&xwd_loader); +} + +/* ----------------------------------------------------------------------- */ + +void +parse_ximage(struct ida_image *dest, XImage *src) +{ + struct xwd_state h; + Colormap cmap; + XColor col; + int y,i; + + memset(&h,0,sizeof(h)); + h.width = src->width; + h.bpp = src->bits_per_pixel; + h.header.red_mask = be32_to_cpu(info->red_mask); + h.header.green_mask = be32_to_cpu(info->green_mask); + h.header.blue_mask = be32_to_cpu(info->blue_mask); + h.header.visual_class = be32_to_cpu(info->class); + h.header.byte_order = be32_to_cpu(ImageByteOrder(dpy)); + h.pix = malloc(src->width * sizeof(unsigned long)); + + switch (be32_to_cpu(h.header.visual_class)) { + case PseudoColor: + cmap = DefaultColormapOfScreen(XtScreen(app_shell)); + for (i = 0; i < 256; i++) { + col.pixel = i; + XQueryColor(dpy,cmap,&col); + h.cmap[i].red = be16_to_cpu(col.red); + h.cmap[i].green = be16_to_cpu(col.green); + h.cmap[i].blue = be16_to_cpu(col.blue); + } + break; + case TrueColor: + case DirectColor: + xwd_map(&h); + break; + } + + memset(dest,0,sizeof(*dest)); + dest->i.width = src->width; + dest->i.height = src->height; + dest->data = malloc(dest->i.width * dest->i.height * 3); + memset(dest->data,0,dest->i.width * dest->i.height * 3); + + for (y = 0; y < src->height; y++) { + h.row = src->data + y*src->bytes_per_line; + xwd_parse(dest->data + 3*y*dest->i.width, y, &h); + } + free(h.pix); +} -- cgit