diff options
Diffstat (limited to 'urt/rle_getrow.c')
| -rw-r--r-- | urt/rle_getrow.c | 422 |
1 files changed, 189 insertions, 233 deletions
diff --git a/urt/rle_getrow.c b/urt/rle_getrow.c index ae220f5b..6a25c987 100644 --- a/urt/rle_getrow.c +++ b/urt/rle_getrow.c @@ -1,14 +1,14 @@ /* * This software is copyrighted as noted below. It may be freely copied, - * modified, and redistributed, provided that the copyright notice is + * modified, and redistributed, provided that the copyright notice is * preserved on all copies. - * + * * There is no warranty or other guarantee of fitness for this software, * it is provided solely "as is". Bug reports or fixes may be sent * to the author, who may or may not act on them as he desires. * * You may not include this software in a program or other software product - * without supplying the source, or without informing the end-user that the + * without supplying the source, or without informing the end-user that the * source is available for no extra charge. * * If you modify this software, you should include a notice giving the @@ -18,15 +18,15 @@ * Modified at BRL 16-May-88 by Mike Muuss to avoid Alliant STDC desire * to have all "void" functions so declared. */ -/* +/* * rle_getrow.c - Read an RLE file in. - * + * * Author: Spencer W. Thomas * Computer Science Dept. * University of Utah * Date: Wed Apr 10 1985 * Copyright (c) 1985 Spencer W. Thomas - * + * * $Id: rle_getrow.c,v 3.0.1.5 1992/03/04 19:33:08 spencer Exp spencer $ */ @@ -43,7 +43,7 @@ /* Read a two-byte "short" that started in VAX (LITTLE_ENDIAN) order */ #define VAXSHORT( var, fp )\ { var = fgetc(fp)&0xFF; var |= (fgetc(fp)) << 8; } - + /* Instruction format -- first byte is opcode, second is datum. */ #define OPCODE(inst) (inst[0] & ~LONG) @@ -52,14 +52,74 @@ static int debug_f; /* If non-zero, print debug info. */ + + +static void +readComments(rle_hdr * const hdrP) { + + FILE * ifP = hdrP->rle_file; + + /* There are comments */ + short comlen; + char * cp; + + VAXSHORT(comlen, ifP); /* get comment length */ + + if (comlen < 0) + pm_error("Negative comment length in RLE header"); + else if (comlen > 0) { + unsigned int const evenlen = (comlen + 1) & ~1; /* make it even */ + + char * commentHeap; + unsigned int i; + + MALLOCARRAY(commentHeap, evenlen); + + if (commentHeap == NULL) { + pm_error("Malloc failed for comment buffer of size %u " + "in rle_get_setup, reading '%s'", + evenlen, hdrP->file_name ); + } + fread(commentHeap, 1, evenlen, ifP); + /* Count the comments */ + for (i = 0, cp = commentHeap; cp < commentHeap + comlen; ++cp) { + if (*cp == '\0') + ++i; + } + ++i; /* extra for NULL pointer at end */ + /* Get space to put pointers to comments */ + MALLOCARRAY(hdrP->comments, i); + if (hdrP->comments == NULL) { + pm_error("Malloc failed for %d comment pointers " + "in rle_get_setup, reading '%s'", + i, hdrP->file_name ); + } + /* Set comment heap */ + hdrP->comments[0] = commentHeap; + + /* Set pointers to individual comments in the heap as + hdrP->comments[1], hdrP->comments[2], etc. + */ + for (i = 1, cp = commentHeap + 1; + cp < commentHeap + comlen; + ++cp) + if (*(cp - 1) == '\0') + hdrP->comments[i++] = cp; + hdrP->comments[i] = NULL; + } else + hdrP->comments = NULL; +} + + + int -rle_get_setup(rle_hdr * const the_hdr) { +rle_get_setup(rle_hdr * const hdrP) { /*----------------------------------------------------------------------------- Read the initialization information from an RLE file. Inputs: - the_hdr: Contains pointer to the input file. + hdrP: Contains pointer to the input file. Outputs: - the_hdr: Initialized with information from the input file. + hdrP: Initialized with information from the input file. Returns 0 on success, -1 if the file is not an RLE file, @@ -67,251 +127,148 @@ rle_get_setup(rle_hdr * const the_hdr) { -3 if an immediate EOF is hit (empty input file) -4 if an EOF is encountered reading the setup information. Assumptions: - infile points to the "magic" number in an RLE file (usually byte 0 - in the file). + input file is positioned to the "magic" number in an RLE file (usually + first byte of the file). Algorithm: - Read in the setup info and fill in the_hdr. + Read in the setup info and fill in *hdrP. ---------------------------------------------------------------------------- */ struct XtndRsetup setup; short magic; - FILE * infile = the_hdr->rle_file; + FILE * ifP = hdrP->rle_file; int i; - char * comment_buf; - + /* Clear old stuff out of the header. */ - rle_hdr_clear(the_hdr); - if (the_hdr->is_init != RLE_INIT_MAGIC) - rle_names(the_hdr, "Urt", "some file", 0); - ++the_hdr->img_num; /* Count images. */ + rle_hdr_clear(hdrP); + if (hdrP->is_init != RLE_INIT_MAGIC) + rle_names(hdrP, "Urt", "some file", 0); + ++hdrP->img_num; /* Count images. */ - VAXSHORT(magic, infile); - if (feof(infile)) + VAXSHORT(magic, ifP); + if (feof(ifP)) return RLE_EMPTY; if (magic != RLE_MAGIC) return RLE_NOT_RLE; - fread(&setup, 1, SETUPSIZE, infile); /* assume VAX packing */ - if (feof( infile)) + fread(&setup, 1, SETUPSIZE, ifP); /* assume VAX packing */ + if (feof( ifP)) return RLE_EOF; /* Extract information from setup */ - the_hdr->ncolors = setup.h_ncolors; - for (i = 0; i < the_hdr->ncolors; ++i) - RLE_SET_BIT(*the_hdr, i); + hdrP->ncolors = setup.h_ncolors; + for (i = 0; i < hdrP->ncolors; ++i) + RLE_SET_BIT(*hdrP, i); if (!(setup.h_flags & H_NO_BACKGROUND) && setup.h_ncolors > 0) { rle_pixel * bg_color; - MALLOCARRAY(the_hdr->bg_color, setup.h_ncolors); - if (!the_hdr->bg_color) + MALLOCARRAY(hdrP->bg_color, setup.h_ncolors); + if (!hdrP->bg_color) pm_error("Failed to allocation array for %u background colors", setup.h_ncolors); MALLOCARRAY(bg_color, 1 + (setup.h_ncolors / 2) * 2); if (!bg_color) pm_error("Failed to allocation array for %u background colors", 1+(setup.h_ncolors / 2) * 2); - fread((char *)bg_color, 1, 1 + (setup.h_ncolors / 2) * 2, infile); + fread((char *)bg_color, 1, 1 + (setup.h_ncolors / 2) * 2, ifP); for (i = 0; i < setup.h_ncolors; ++i) - the_hdr->bg_color[i] = bg_color[i]; + hdrP->bg_color[i] = bg_color[i]; free(bg_color); } else { - getc(infile); /* skip filler byte */ - the_hdr->bg_color = NULL; + getc(ifP); /* skip filler byte */ + hdrP->bg_color = NULL; } if (setup.h_flags & H_NO_BACKGROUND) - the_hdr->background = 0; + hdrP->background = 0; else if (setup.h_flags & H_CLEARFIRST) - the_hdr->background = 2; + hdrP->background = 2; else - the_hdr->background = 1; + hdrP->background = 1; if (setup.h_flags & H_ALPHA) { - the_hdr->alpha = 1; - RLE_SET_BIT( *the_hdr, RLE_ALPHA ); + hdrP->alpha = 1; + RLE_SET_BIT( *hdrP, RLE_ALPHA ); } else - the_hdr->alpha = 0; + hdrP->alpha = 0; + + hdrP->xmin = vax_gshort(setup.hc_xpos); + hdrP->ymin = vax_gshort(setup.hc_ypos); + hdrP->xmax = hdrP->xmin + vax_gshort(setup.hc_xlen) - 1; + hdrP->ymax = hdrP->ymin + vax_gshort(setup.hc_ylen) - 1; - the_hdr->xmin = vax_gshort(setup.hc_xpos); - the_hdr->ymin = vax_gshort(setup.hc_ypos); - the_hdr->xmax = the_hdr->xmin + vax_gshort(setup.hc_xlen) - 1; - the_hdr->ymax = the_hdr->ymin + vax_gshort(setup.hc_ylen) - 1; + hdrP->ncmap = setup.h_ncmap; + hdrP->cmaplen = setup.h_cmaplen; - the_hdr->ncmap = setup.h_ncmap; - the_hdr->cmaplen = setup.h_cmaplen; - if (the_hdr->ncmap > 0) { - int const maplen = the_hdr->ncmap * (1 << the_hdr->cmaplen); + if (hdrP->ncmap > 0) { + int const maplen = hdrP->ncmap * (1 << hdrP->cmaplen); - int i; - char *maptemp; + unsigned int i; + unsigned char *maptemp; - MALLOCARRAY(the_hdr->cmap, maplen); + MALLOCARRAY(hdrP->cmap, maplen); MALLOCARRAY(maptemp, 2 * maplen); - if (the_hdr->cmap == NULL || maptemp == NULL) { + if (hdrP->cmap == NULL || maptemp == NULL) { pm_error("Malloc failed for color map of size %d*%d " "in rle_get_setup, reading '%s'", - the_hdr->ncmap, (1 << the_hdr->cmaplen), - the_hdr->file_name ); + hdrP->ncmap, (1 << hdrP->cmaplen), + hdrP->file_name ); return RLE_NO_SPACE; } - fread(maptemp, 2, maplen, infile); + fread(maptemp, 2, maplen, ifP); for (i = 0; i < maplen; ++i) - the_hdr->cmap[i] = vax_gshort(&maptemp[i * 2]); + hdrP->cmap[i] = vax_gshort(&maptemp[i * 2]); free(maptemp); } - /* Check for comments */ - if (setup.h_flags & H_COMMENT) { - short comlen, evenlen; - char * cp; - - VAXSHORT(comlen, infile); /* get comment length */ - evenlen = (comlen + 1) & ~1; /* make it even */ - if (evenlen) { - MALLOCARRAY(comment_buf, evenlen); - - if (comment_buf == NULL) { - pm_error("Malloc failed for comment buffer of size %d " - "in rle_get_setup, reading '%s'", - comlen, the_hdr->file_name ); - return RLE_NO_SPACE; - } - fread(comment_buf, 1, evenlen, infile); - /* Count the comments */ - for (i = 0, cp = comment_buf; cp < comment_buf + comlen; ++cp) - if (*cp == '\0') - ++i; - ++i; /* extra for NULL pointer at end */ - /* Get space to put pointers to comments */ - MALLOCARRAY(the_hdr->comments, i); - if (the_hdr->comments == NULL) { - pm_error("Malloc failed for %d comment pointers " - "in rle_get_setup, reading '%s'", - i, the_hdr->file_name ); - return RLE_NO_SPACE; - } - /* Get pointers to the comments */ - *the_hdr->comments = comment_buf; - for (i = 1, cp = comment_buf + 1; - cp < comment_buf + comlen; - ++cp) - if (*(cp - 1) == '\0') - the_hdr->comments[i++] = cp; - the_hdr->comments[i] = NULL; - } else - the_hdr->comments = NULL; - } else - the_hdr->comments = NULL; + if (setup.h_flags & H_COMMENT) + readComments(hdrP); + else + hdrP->comments = NULL; /* Initialize state for rle_getrow */ - the_hdr->priv.get.scan_y = the_hdr->ymin; - the_hdr->priv.get.vert_skip = 0; - the_hdr->priv.get.is_eof = 0; - the_hdr->priv.get.is_seek = ftell(infile) > 0; + hdrP->priv.get.scan_y = hdrP->ymin; + hdrP->priv.get.vert_skip = 0; + hdrP->priv.get.is_eof = 0; + hdrP->priv.get.is_seek = ftell(ifP) > 0; debug_f = 0; - if (!feof(infile)) + if (!feof(ifP)) return RLE_SUCCESS; /* success! */ else { - the_hdr->priv.get.is_eof = 1; + hdrP->priv.get.is_eof = 1; return RLE_EOF; } } -void -rle_get_setup_ok(rle_hdr * const the_hdr, - const char * const prog_name, - const char * const file_name) { -/*----------------------------------------------------------------------------- - Read the initialization information from an RLE file. - - Inputs: - the_hdr: Contains pointer to the input file. - prog_name: Program name to be printed in the error message. - file_name: File name to be printed in the error message. - If NULL, the string "stdin" is generated. - - Outputs: - the_hdr: Initialized with information from the input file. - If reading the header fails, it prints an error message - and exits with the appropriate status code. - Algorithm: - rle_get_setup does all the work. ----------------------------------------------------------------------------- */ - int code; - - /* Backwards compatibility: if is_init is not properly set, - * initialize the header. - */ - if (the_hdr->is_init != RLE_INIT_MAGIC) { - FILE * const f = the_hdr->rle_file; - rle_hdr_init( the_hdr ); - the_hdr->rle_file = f; - rle_names(the_hdr, prog_name, file_name, 0); - } - - code = rle_get_error(rle_get_setup(the_hdr), - the_hdr->cmd, the_hdr->file_name); - if (code) - exit(code); -} - - - -void -rle_debug( on_off ) - int on_off; -{ -/*----------------------------------------------------------------------------- - Turn RLE debugging on or off. - Inputs: - on_off: if 0, stop debugging, else start. - Outputs: - Sets internal debug flag. - Assumptions: - [None] - Algorithm: - [None] ----------------------------------------------------------------------------- */ - debug_f = on_off; - - /* Set line buffering on stderr. Character buffering is the default, and - * it is SLOOWWW for large amounts of output. - */ - setvbuf(stderr, NULL, _IOLBF, 0); -} - - - int -rle_getrow(rle_hdr * const the_hdr, +rle_getrow(rle_hdr * const hdrP, rle_pixel ** const scanline) { /*----------------------------------------------------------------------------- Get a scanline from the input file. Inputs: - the_hdr: Header structure containing information about + hdrP: Header structure containing information about the input file. Outputs: scanline: an array of pointers to the individual color scanlines. Scanline is assumed to have - the_hdr->ncolors pointers to arrays of rle_pixel, - each of which is at least the_hdr->xmax+1 long. + hdrP->ncolors pointers to arrays of rle_pixel, + each of which is at least hdrP->xmax+1 long. Returns the current scanline number. Assumptions: rle_get_setup has already been called. Algorithm: If a vertical skip is being executed, and clear-to-background is - specified (the_hdr->background is true), just set the + specified (hdrP->background is true), just set the scanlines to the background color. If clear-to-background is not set, just increment the scanline number and return. - + Otherwise, read input until a vertical skip is encountered, decoding the instructions into scanline data. - + If ymax is reached (or, somehow, passed), continue reading and discarding input until end of image. ---------------------------------------------------------------------------- */ - FILE * const infile = the_hdr->rle_file; + FILE * const ifP = hdrP->rle_file; rle_pixel * scanc; @@ -323,73 +280,73 @@ rle_getrow(rle_hdr * const the_hdr, short word, long_data; char inst[2]; - scan_x = the_hdr->xmin; /* initial value */ - max_x = the_hdr->xmax; /* initial value */ + scan_x = hdrP->xmin; /* initial value */ + max_x = hdrP->xmax; /* initial value */ channel = 0; /* initial value */ /* Clear to background if specified */ - if (the_hdr->background != 1) { - if (the_hdr->alpha && RLE_BIT( *the_hdr, -1)) - memset((char *)scanline[-1] + the_hdr->xmin, 0, - the_hdr->xmax - the_hdr->xmin + 1); - for (nc = 0; nc < the_hdr->ncolors; ++nc) { - if (RLE_BIT( *the_hdr, nc)) { + if (hdrP->background != 1) { + if (hdrP->alpha && RLE_BIT( *hdrP, -1)) + memset((char *)scanline[-1] + hdrP->xmin, 0, + hdrP->xmax - hdrP->xmin + 1); + for (nc = 0; nc < hdrP->ncolors; ++nc) { + if (RLE_BIT( *hdrP, nc)) { /* Unless bg color given explicitly, use 0. */ - if (the_hdr->background != 2 || the_hdr->bg_color[nc] == 0) - memset((char *)scanline[nc] + the_hdr->xmin, 0, - the_hdr->xmax - the_hdr->xmin + 1); + if (hdrP->background != 2 || hdrP->bg_color[nc] == 0) + memset((char *)scanline[nc] + hdrP->xmin, 0, + hdrP->xmax - hdrP->xmin + 1); else - memset((char *)scanline[nc] + the_hdr->xmin, - the_hdr->bg_color[nc], - the_hdr->xmax - the_hdr->xmin + 1); + memset((char *)scanline[nc] + hdrP->xmin, + hdrP->bg_color[nc], + hdrP->xmax - hdrP->xmin + 1); } } } /* If skipping, then just return */ - if (the_hdr->priv.get.vert_skip > 0) { - --the_hdr->priv.get.vert_skip; - ++the_hdr->priv.get.scan_y; - if (the_hdr->priv.get.vert_skip > 0) { - if (the_hdr->priv.get.scan_y >= the_hdr->ymax) { - int const y = the_hdr->priv.get.scan_y; - while (rle_getskip(the_hdr) != 32768) + if (hdrP->priv.get.vert_skip > 0) { + --hdrP->priv.get.vert_skip; + ++hdrP->priv.get.scan_y; + if (hdrP->priv.get.vert_skip > 0) { + if (hdrP->priv.get.scan_y >= hdrP->ymax) { + int const y = hdrP->priv.get.scan_y; + while (rle_getskip(hdrP) != 32768) ; return y; } else - return the_hdr->priv.get.scan_y; + return hdrP->priv.get.scan_y; } } /* If EOF has been encountered, return also */ - if (the_hdr->priv.get.is_eof) - return ++the_hdr->priv.get.scan_y; + if (hdrP->priv.get.is_eof) + return ++hdrP->priv.get.scan_y; /* Otherwise, read and interpret instructions until a skipLines instruction is encountered. */ - if (RLE_BIT(*the_hdr, channel)) + if (RLE_BIT(*hdrP, channel)) scanc = scanline[channel] + scan_x; else scanc = NULL; for (;;) { - inst[0] = getc(infile); - inst[1] = getc(infile); - if (feof(infile)) { - the_hdr->priv.get.is_eof = 1; + inst[0] = getc(ifP); + inst[1] = getc(ifP); + if (feof(ifP)) { + hdrP->priv.get.is_eof = 1; break; /* <--- one of the exits */ } switch(OPCODE(inst)) { case RSkipLinesOp: if (LONGP(inst)) { - VAXSHORT(the_hdr->priv.get.vert_skip, infile); + VAXSHORT(hdrP->priv.get.vert_skip, ifP); } else - the_hdr->priv.get.vert_skip = DATUM(inst); + hdrP->priv.get.vert_skip = DATUM(inst); if (debug_f) pm_message("Skip %d Lines (to %d)", - the_hdr->priv.get.vert_skip, - the_hdr->priv.get.scan_y + - the_hdr->priv.get.vert_skip); + hdrP->priv.get.vert_skip, + hdrP->priv.get.scan_y + + hdrP->priv.get.vert_skip); break; /* need to break for() here, too */ @@ -397,8 +354,8 @@ rle_getrow(rle_hdr * const the_hdr, channel = DATUM(inst); /* select color channel */ if (channel == 255) channel = -1; - scan_x = the_hdr->xmin; - if (RLE_BIT(*the_hdr, channel)) + scan_x = hdrP->xmin; + if (RLE_BIT(*hdrP, channel)) scanc = scanline[channel]+scan_x; if (debug_f) pm_message("Set color to %d (reset x to %d)", @@ -407,7 +364,7 @@ rle_getrow(rle_hdr * const the_hdr, case RSkipPixelsOp: if (LONGP(inst)) { - VAXSHORT(long_data, infile); + VAXSHORT(long_data, ifP); scan_x += long_data; scanc += long_data; if (debug_f) @@ -422,40 +379,40 @@ rle_getrow(rle_hdr * const the_hdr, case RByteDataOp: if (LONGP(inst)) { - VAXSHORT(nc, infile); + VAXSHORT(nc, ifP); } else nc = DATUM(inst); ++nc; if (debug_f) { - if (RLE_BIT(*the_hdr, channel)) + if (RLE_BIT(*hdrP, channel)) pm_message("Pixel data %d (to %d):", nc, scan_x + nc); else pm_message("Pixel data %d (to %d)", nc, scan_x + nc); } - if (RLE_BIT(*the_hdr, channel)) { + if (RLE_BIT(*hdrP, channel)) { /* Don't fill past end of scanline! */ if (scan_x + nc > max_x) { ns = scan_x + nc - max_x - 1; nc -= ns; } else ns = 0; - fread((char *)scanc, 1, nc, infile); + fread((char *)scanc, 1, nc, ifP); while (ns-- > 0) - getc(infile); + getc(ifP); if (nc & 0x1) - getc(infile); /* throw away odd byte */ + getc(ifP); /* throw away odd byte */ } else { - if (the_hdr->priv.get.is_seek) - fseek(infile, ((nc + 1) / 2) * 2, 1); + if (hdrP->priv.get.is_seek) + fseek(ifP, ((nc + 1) / 2) * 2, 1); else { int ii; for (ii = ((nc + 1) / 2) * 2; ii > 0; --ii) - getc(infile); /* discard it */ + getc(ifP); /* discard it */ } } scanc += nc; scan_x += nc; - if (debug_f && RLE_BIT(*the_hdr, channel)) { + if (debug_f && RLE_BIT(*hdrP, channel)) { rle_pixel * cp; for (cp = scanc - nc; nc > 0; --nc) fprintf(stderr, "%02x", *cp++); @@ -465,17 +422,17 @@ rle_getrow(rle_hdr * const the_hdr, case RRunDataOp: if (LONGP(inst)) { - VAXSHORT(nc, infile); + VAXSHORT(nc, ifP); } else nc = DATUM(inst); ++nc; scan_x += nc; - VAXSHORT(word, infile); + VAXSHORT(word, ifP); if (debug_f) pm_message("Run length %d (to %d), data %02x", nc, scan_x, word); - if (RLE_BIT(*the_hdr, channel)) { + if (RLE_BIT(*hdrP, channel)) { if (scan_x > max_x) { ns = scan_x - max_x - 1; nc -= ns; @@ -492,29 +449,28 @@ rle_getrow(rle_hdr * const the_hdr, break; case REOFOp: - the_hdr->priv.get.is_eof = 1; + hdrP->priv.get.is_eof = 1; if (debug_f) pm_message("End of Image"); break; default: pm_error("rle_getrow: Unrecognized opcode: %d, reading %s", - inst[0], the_hdr->file_name); + inst[0], hdrP->file_name); } if (OPCODE(inst) == RSkipLinesOp || OPCODE(inst) == REOFOp) break; /* <--- the other loop exit */ } /* If at end, skip the rest of a malformed image. */ - if (the_hdr->priv.get.scan_y >= the_hdr->ymax) { - int const y = the_hdr->priv.get.scan_y; - while (rle_getskip(the_hdr) != 32768 ) + if (hdrP->priv.get.scan_y >= hdrP->ymax) { + int const y = hdrP->priv.get.scan_y; + while (rle_getskip(hdrP) != 32768 ) ; return y; } - return the_hdr->priv.get.scan_y; + return hdrP->priv.get.scan_y; } - |