TargaLoader::TargaLoader(const IODevicePtr &iodevice, bool srgb) : file(iodevice), srgb(srgb) { read_header(); read_image_id(); read_color_map(); read_image_data(); decode_palette(); decode_image(); }
Image TGAReader::read_stream(std::istream &stream, const std::string &error_prefix) { this->stream = &stream; this->error_prefix = error_prefix; read_header(); skip(header.id_field_length); if (header.color_map_type == ColorMapType::PRESENT) read_color_map(); return read_image_data(); }
parse_switches (j_decompress_ptr cinfo, int argc, char **argv, int last_file_arg_seen, boolean for_real) /* Parse optional switches. * Returns argv[] index of first file-name argument (== argc if none). * Any file names with indexes <= last_file_arg_seen are ignored; * they have presumably been processed in a previous iteration. * (Pass 0 for last_file_arg_seen on the first or only iteration.) * for_real is FALSE on the first (dummy) pass; we may skip any expensive * processing. */ { int argn; char * arg; /* Set up default JPEG parameters. */ requested_fmt = DEFAULT_FMT; /* set default output file format */ outfilename = NULL; cinfo->err->trace_level = 0; /* Scan command line options, adjust parameters */ for (argn = 1; argn < argc; argn++) { arg = argv[argn]; if (*arg != '-') { /* Not a switch, must be a file name argument */ if (argn <= last_file_arg_seen) { outfilename = NULL; /* -outfile applies to just one input file */ continue; /* ignore this name if previously processed */ } break; /* else done parsing switches */ } arg++; /* advance past switch marker character */ if (keymatch(arg, "bmp", 1)) { /* BMP output format. */ requested_fmt = FMT_BMP; } else if (keymatch(arg, "colors", 1) || keymatch(arg, "colours", 1) || keymatch(arg, "quantize", 1) || keymatch(arg, "quantise", 1)) { /* Do color quantization. */ int val; if (++argn >= argc) /* advance to next argument */ usage(); if (sscanf(argv[argn], "%d", &val) != 1) usage(); cinfo->desired_number_of_colors = val; cinfo->quantize_colors = TRUE; } else if (keymatch(arg, "dct", 2)) { /* Select IDCT algorithm. */ if (++argn >= argc) /* advance to next argument */ usage(); if (keymatch(argv[argn], "int", 1)) { cinfo->dct_method = JDCT_ISLOW; } else if (keymatch(argv[argn], "fast", 2)) { cinfo->dct_method = JDCT_IFAST; } else if (keymatch(argv[argn], "float", 2)) { cinfo->dct_method = JDCT_FLOAT; } else usage(); } else if (keymatch(arg, "dither", 2)) { /* Select dithering algorithm. */ if (++argn >= argc) /* advance to next argument */ usage(); if (keymatch(argv[argn], "fs", 2)) { cinfo->dither_mode = JDITHER_FS; } else if (keymatch(argv[argn], "none", 2)) { cinfo->dither_mode = JDITHER_NONE; } else if (keymatch(argv[argn], "ordered", 2)) { cinfo->dither_mode = JDITHER_ORDERED; } else usage(); } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) { /* Enable debug printouts. */ /* On first -d, print version identification */ static boolean printed_version = FALSE; if (! printed_version) { fprintf(stderr, "Independent JPEG Group's DJPEG, version %s\n%s\n", JVERSION, JCOPYRIGHT); printed_version = TRUE; } cinfo->err->trace_level++; } else if (keymatch(arg, "fast", 1)) { /* Select recommended processing options for quick-and-dirty output. */ cinfo->two_pass_quantize = FALSE; cinfo->dither_mode = JDITHER_ORDERED; if (! cinfo->quantize_colors) /* don't override an earlier -colors */ cinfo->desired_number_of_colors = 216; cinfo->dct_method = JDCT_FASTEST; cinfo->do_fancy_upsampling = FALSE; } else if (keymatch(arg, "gif", 1)) { /* GIF output format. */ requested_fmt = FMT_GIF; } else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) { /* Force monochrome output. */ cinfo->out_color_space = JCS_GRAYSCALE; } else if (keymatch(arg, "map", 3)) { /* Quantize to a color map taken from an input file. */ if (++argn >= argc) /* advance to next argument */ usage(); if (for_real) { /* too expensive to do twice! */ #ifdef QUANT_2PASS_SUPPORTED /* otherwise can't quantize to supplied map */ FILE * mapfile; if ((mapfile = fopen(argv[argn], READ_BINARY)) == NULL) { fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]); exit(EXIT_FAILURE); } read_color_map(cinfo, mapfile); fclose(mapfile); cinfo->quantize_colors = TRUE; #else ERREXIT(cinfo, JERR_NOT_COMPILED); #endif } } else if (keymatch(arg, "maxmemory", 3)) { /* Maximum memory in Kb (or Mb with 'm'). */ long lval; char ch = 'x'; if (++argn >= argc) /* advance to next argument */ usage(); if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1) usage(); if (ch == 'm' || ch == 'M') lval *= 1000L; cinfo->mem->max_memory_to_use = lval * 1000L; } else if (keymatch(arg, "nosmooth", 3)) { /* Suppress fancy upsampling */ cinfo->do_fancy_upsampling = FALSE; } else if (keymatch(arg, "onepass", 3)) { /* Use fast one-pass quantization. */ cinfo->two_pass_quantize = FALSE; } else if (keymatch(arg, "os2", 3)) { /* BMP output format (OS/2 flavor). */ requested_fmt = FMT_OS2; } else if (keymatch(arg, "outfile", 4)) { /* Set output file name. */ if (++argn >= argc) /* advance to next argument */ usage(); outfilename = argv[argn]; /* save it away for later use */ } else if (keymatch(arg, "pnm", 1) || keymatch(arg, "ppm", 1)) { /* PPM/PGM output format. */ requested_fmt = FMT_PPM; } else if (keymatch(arg, "rle", 1)) { /* RLE output format. */ requested_fmt = FMT_RLE; } else if (keymatch(arg, "scale", 1)) { /* Scale the output image by a fraction M/N. */ if (++argn >= argc) /* advance to next argument */ usage(); if (sscanf(argv[argn], "%d/%d", &cinfo->scale_num, &cinfo->scale_denom) < 1) usage(); } else if (keymatch(arg, "targa", 1)) { /* Targa output format. */ requested_fmt = FMT_TARGA; } else { usage(); /* bogus switch */ } } return argn; /* return index of next arg (file name) */ }
Errcode read_tiftags(Tiff_file *tf) /***************************************************************************** * load all the tags in an ifd, save the data we care about along the way. * after reading everything in the ifd, this routine attempts to fudge in * any data that was missing (eg, strip offsets, strip bytecounts). it also * verifies that the required fields were present (our idea of required * fields, not tiff's idea. we require image width and height; we can fake * just about anything else.) ****************************************************************************/ { Errcode err; short entry_count; Dirent entry; int bps_count; /* * plug in default values for things we care about... */ tf->width = 0; tf->height = 0; tf->longest_strip = 0; tf->strips_per_image = 0; tf->planar_configuration = 1; tf->rows_per_strip = 0x7fffffff; tf->samples_per_pixel = 1; tf->bits_per_sample[0] = 1; tf->bits_per_sample[1] = 0; tf->bits_per_sample[2] = 0; tf->compression = CMPRS_NONE; tf->photometric = PHMET_GREY_0ISBLACK; tf->min_sample_value = 0; tf->max_sample_value = 0; /* default will be calc'd later if needed */ /* * the saved offset of the next ifd becomes the offset to the current * ifd. we seek to that location (just in case), and load the count * of entries in the ifd, which will be used as a loop counter. */ tf->off_ifd_start = tf->off_ifd_cur = tf->off_ifd_next; if (Success != fseek(tf->file, tf->off_ifd_cur, SEEK_SET)) return pj_errno_errcode(); if (1 != fread(&entry_count, sizeof(entry_count), 1, tf->file)) return pj_errno_errcode(); SWAPW(&entry_count); tf->off_ifd_cur += sizeof(entry_count); /* * loop through all the entries (tags) in the ifd, storing off the data * we care about into our own structure as we go. */ while (entry_count--) { if (Success != (err = read_next_dirent(tf, &entry))) return err; switch (entry.tag) { case TAG_IMAGE_WIDTH: tf->width = entry.value.word; break; case TAG_IMAGE_LENGTH: tf->height = entry.value.word; break; case TAG_BITS_PER_SAMPLE: bps_count = entry.count; switch (entry.count) { case 1: tf->bits_per_sample[0] = entry.value.word; if (tf->bits_per_sample[0] > 8) return Err_wrong_type; break; case 3: if (Success != fseek(tf->file, entry.value.offset, SEEK_SET)) return pj_errno_errcode(); if (3 != fread(tf->bits_per_sample, sizeof(short), 3, tf->file)) return Err_truncated; if (tf->swap_bytes) { swapw(&tf->bits_per_sample[0]); swapw(&tf->bits_per_sample[1]); swapw(&tf->bits_per_sample[2]); } if (tf->bits_per_sample[0] != 8 || tf->bits_per_sample[1] != 8 || tf->bits_per_sample[2] != 8 ) return Err_wrong_type; break; default: return Err_wrong_type; } break; case TAG_COMPRESSION: tf->compression = entry.value.uword; break; case TAG_PHOTOMETRIC_INTERP: tf->photometric = entry.value.word; break; case TAG_STRIP_OFFSETS: case TAG_SHORT_STRIP_OFFSETS: /* Aldus private tag 32768 */ if (Success != (err = read_strip_offsets(tf, entry.value.offset, entry.type, entry.count))) return err; break; case TAG_SAMPLES_PER_PIXEL: tf->samples_per_pixel = entry.value.word; switch (tf->samples_per_pixel) { case 1: if (tf->photometric == PHMET_RGB) return Err_format; break; case 3: tf->photometric = PHMET_RGB; /* force RGB interp */ break; default: return Err_wrong_type; } break; case TAG_ROWS_PER_STRIP: tf->rows_per_strip = (entry.type == TYPE_SHORT) ? entry.value.word : entry.value.dword; break; case TAG_STRIP_BYTE_COUNTS: if (Success != (err = read_strip_bytecounts(tf, entry.value.offset, entry.type, entry.count))) return err; break; case TAG_MIN_SAMPLE_VALUE: case TAG_MAX_SAMPLE_VALUE: /* we ignore these fields and calc values below. * we use the min/max values to calculate greyscale * pallete entries, but on the advice of of the TIFF 5.0 * doc ('these values should not affect the visual display * of the data, they are for statistical purposes only'), * we use 2**bits_per_sample instead of max_sample_value. */ break; case TAG_PLANAR_CONFIG: tf->planar_configuration = entry.value.word; break; case TAG_COLORMAP: if (Success != (err = read_color_map(tf, entry.value.offset, entry.count))) return err; break; default: break; } tf->off_ifd_cur += sizeof(entry); } /* * read the offset to the next ifd; we may need it for multi-image file */ if (Success != fseek(tf->file, tf->off_ifd_cur, SEEK_SET)) return pj_errno_errcode(); if (1 != fread(&tf->off_ifd_next, sizeof(tf->off_ifd_next), 1, tf->file)) return Err_truncated; SWAPD(&tf->off_ifd_next); /* * if we have RGB data but we only got one bits_per_sample value, * propogate it to the other two entries in the array. * calculate the total pixel depth. */ if (tf->photometric == PHMET_RGB && bps_count != 3) { tf->bits_per_sample[1] = tf->bits_per_sample[0]; tf->bits_per_sample[2] = tf->bits_per_sample[0]; } tf->pixel_depth = tf->bits_per_sample[0] + tf->bits_per_sample[1] + tf->bits_per_sample[2]; /* * calculate max_sample_value as (2**bits_per_sample)-1... */ if (tf->max_sample_value == 0) tf->max_sample_value = (0x01 << tf->bits_per_sample[0]) - 1; /* * hmmm. it seems some tif files don't have strip bytecount entries. * we'll see symptoms of that here if the longest strip size is zero * after reading all the tags. when this occurs, we call a routine * to calculate the byte counts. the routine does some sanity checking * and will return an error if the counts look totally unreasonable. */ if (tf->longest_strip == 0) if (Success != (err = calc_strip_bytecounts(tf))) return err; /* * all entries in this ifd have been dealt with, make sure we have * the minimum required data to run the rest of the program... * checking strips_per_image ensures that we got strip offsets. * checking longest_strip ensures we got (or calc'd) strip bytecounts. */ if (tf->width == 0 || tf->height == 0 || tf->strips_per_image == 0 || tf->longest_strip == 0) return Err_format; return Success; }
static Errcode read_256_color_frame(Rfile *rf) /* Read and parse all the opcodes in a RND file. */ { int opcode; Rcel *screen = rf->screen; /* clear color map to zeros */ stuff_bytes(0,screen->cmap->ctab, screen->cmap->num_colors * sizeof(Rgb3)); #ifdef DEBUG #define PRT(s) printf(s) #else #define PRT(s) #endif /* DEBUG */ for(;;) { opcode = fgetc(rf->file); switch(opcode) { case EOF: return(Success); case RND_CLEAR: /* Clear entire display */ pj_set_rast(screen,0); continue; case RND_CMAPB: /* Begin Color map */ read_color_map(rf); break; case RND_POLY: /* Polygon */ read_polygon(rf); break; case RND_CRANGE: /* Continous-color range */ PRT("RND_CRANGE"); goto bad_opcode; case RND_CPOLY: /* Continous-color polygon */ PRT("RND_CPOLY"); goto bad_opcode; case RND_WSLINE: /* Output Scan line to driver */ read_scanline(rf); break; case RND_RSLINE: /* Input Scan line from driver */ PRT("RND_RSLINE"); goto bad_opcode; case RND_RCMAP: /* Input color map rgb from driver */ PRT("RND_RCMAP"); goto bad_opcode; case RND_ETAIL: /* i/o details for hard copy drivers */ PRT("RND_ETAIL"); goto bad_opcode; case RND_CFGREC: /* execution time configuration record */ PRT("RND_CFGREC"); goto bad_opcode; case RND_NEWCFG: /* new configuration record */ PRT("RND_NEWCFG"); goto bad_opcode; case RND_CHGCFG: /* change configuration record */ PRT("RND_CHGCFG"); goto bad_opcode; case RND_SHOWCFG: /* show configuration record */ PRT("RND_SHOWCFG"); goto bad_opcode; case RND_FNAME: PRT("RND_FNAME"); goto bad_opcode; default: bad_opcode: #ifdef DEBUG printf("#%2d @ %06x", opcode, ftell(rf->file)); #endif /* DEBUG */ rf->lasterr = Err_format; goto error; } if(rf->lasterr < Success) goto error; } error: return(rf->lasterr); #undef PRT }