/* * cjpeg.c * * Copyright (C) 1991-1998, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains a command-line user interface for the JPEG compressor. * It should work on any system with Unix- or MS-DOS-style command lines. * * Two different command line styles are permitted, depending on the * compile-time switch TWO_FILE_COMMANDLINE: *  cjpeg [options]  inputfile outputfile *  cjpeg [options]  [inputfile] * In the second style, output is always to standard output, which you'd * normally redirect to a file or pipe to some other program.  Input is * either from a named file or from standard input (typically redirected). * The second style is convenient on Unix but is unhelpful on systems that * don't support pipes.  Also, you MUST use the first style if your system * doesn't do binary I/O to stdin/stdout. * To simplify script writing, the "-outfile" switch is provided.  The syntax *  cjpeg [options]  -outfile outputfile  inputfile * works regardless of which command line style is used. */#include "cdjpeg.h"   /* Common decls for cjpeg/djpeg applications */#include "jversion.h"   /* for version message */#ifdef USE_CCOMMAND   /* command-line reader for Macintosh */#ifdef __MWERKS__#include <SIOUX.h>              /* Metrowerks needs this */#include <console.h>    /* ... and this */#endif#ifdef THINK_C#include <console.h>    /* Think declares it here */#endif#endif#include "ippcore.h"/* Create the add-on message string table. */#define JMESSAGE(code,string) string ,static const char * const cdjpeg_message_table[] = {#include "cderror.h"  NULL};/* * This routine determines what format the input file is, * and selects the appropriate input-reading module. * * To determine which family of input formats the file belongs to, * we may look only at the first byte of the file, since C does not * guarantee that more than one character can be pushed back with ungetc. * Looking at additional bytes would require one of these approaches: *     1) assume we can fseek() the input file (fails for piped input); *     2) assume we can push back more than one character (works in *        some C implementations, but unportable); *     3) provide our own buffering (breaks input readers that want to use *        stdio directly, such as the RLE library); * or  4) don't put back the data, and modify the input_init methods to assume *        they start reading after the start of file (also breaks RLE library). * #1 is attractive for MS-DOS but is untenable on Unix. * * The most portable solution for file types that can't be identified by their * first byte is to make the user tell us what they are.  This is also the * only approach for "raw" file types that contain only arbitrary values. * We presently apply this method for Targa files.  Most of the time Targa * files start with 0x00, so we recognize that case.  Potentially, however, * a Targa file could start with any byte value (byte 0 is the length of the * seldom-used ID field), so we provide a switch to force Targa input mode. */static boolean is_targa;  /* records user -targa switch */LOCAL(cjpeg_source_ptr)select_file_type (j_compress_ptr cinfo, FILE * infile){  int c;  if (is_targa) {#ifdef TARGA_SUPPORTED    return jinit_read_targa(cinfo);#else    ERREXIT(cinfo, JERR_TGA_NOTCOMP);#endif  }  if ((c = getc(infile)) == EOF)    ERREXIT(cinfo, JERR_INPUT_EMPTY);  if (ungetc(c, infile) == EOF)    ERREXIT(cinfo, JERR_UNGETC_FAILED);  switch (c) {#ifdef BMP_SUPPORTED  case 'B':    return jinit_read_bmp(cinfo);#endif#ifdef GIF_SUPPORTED  case 'G':    return jinit_read_gif(cinfo);#endif#ifdef PPM_SUPPORTED  case 'P':    return jinit_read_ppm(cinfo);#endif#ifdef RLE_SUPPORTED  case 'R':    return jinit_read_rle(cinfo);#endif#ifdef TARGA_SUPPORTED  case 0x00:    return jinit_read_targa(cinfo);#endif  default:    ERREXIT(cinfo, JERR_UNKNOWN_FORMAT);    break;  }  return NULL;      /* suppress compiler warnings */}/* * Argument-parsing code. * The switch parser is designed to be useful with DOS-style command line * syntax, ie, intermixed switches and file names, where only the switches * to the left of a given file name affect processing of that file. * The main program in this file doesn't actually use this capability... */static const char * progname; /* program name for error messages */static char * outfilename;  /* for -outfile switch */LOCAL(void)usage (void)/* complain about bad command line */{  fprintf(stderr, "usage: %s [switches] ", progname);#ifdef TWO_FILE_COMMANDLINE  fprintf(stderr, "inputfile outputfile\n");#else  fprintf(stderr, "[inputfile]\n");#endif  fprintf(stderr, "Switches (names may be abbreviated):\n");  fprintf(stderr, "  -quality N     Compression quality (0..100; 5-95 is useful range)\n");  fprintf(stderr, "  -grayscale     Create monochrome JPEG file\n");#ifdef ENTROPY_OPT_SUPPORTED  fprintf(stderr, "  -optimize      Optimize Huffman table (smaller file, but slow compression)\n");#endif#ifdef C_PROGRESSIVE_SUPPORTED  fprintf(stderr, "  -progressive   Create progressive JPEG file\n");#endif#ifdef TARGA_SUPPORTED  fprintf(stderr, "  -targa         Input file is Targa format (usually not needed)\n");#endif  fprintf(stderr, "Switches for advanced users:\n");#ifdef DCT_ISLOW_SUPPORTED  fprintf(stderr, "  -dct int       Use integer DCT method%s\n",    (JDCT_DEFAULT == JDCT_ISLOW ? " (default)" : ""));#endif#ifdef DCT_IFAST_SUPPORTED  fprintf(stderr, "  -dct fast      Use fast integer DCT (less accurate)%s\n",    (JDCT_DEFAULT == JDCT_IFAST ? " (default)" : ""));#endif#ifdef DCT_FLOAT_SUPPORTED  fprintf(stderr, "  -dct float     Use floating-point DCT method%s\n",    (JDCT_DEFAULT == JDCT_FLOAT ? " (default)" : ""));#endif  fprintf(stderr, "  -restart N     Set restart interval in rows, or in blocks with B\n");#ifdef INPUT_SMOOTHING_SUPPORTED  fprintf(stderr, "  -smooth N      Smooth dithered input (N=1..100 is strength)\n");#endif  fprintf(stderr, "  -maxmemory N   Maximum memory to use (in kbytes)\n");  fprintf(stderr, "  -outfile name  Specify name for output file\n");  fprintf(stderr, "  -verbose  or  -debug   Emit debug output\n");  fprintf(stderr, "Switches for wizards:\n");#ifdef C_ARITH_CODING_SUPPORTED  fprintf(stderr, "  -arithmetic    Use arithmetic coding\n");#endif  fprintf(stderr, "  -baseline      Force baseline quantization tables\n");  fprintf(stderr, "  -qtables file  Use quantization tables given in file\n");  fprintf(stderr, "  -qslots N[,...]    Set component quantization tables\n");  fprintf(stderr, "  -sample HxV[,...]  Set component sampling factors\n");#ifdef C_MULTISCAN_FILES_SUPPORTED  fprintf(stderr, "  -scans file    Create multi-scan JPEG per script file\n");#endif  exit(EXIT_FAILURE);}LOCAL(int)parse_switches (j_compress_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;  int quality;      /* -quality parameter */  int q_scale_factor;   /* scaling percentage for -qtables */  boolean force_baseline;  boolean simple_progressive;  char * qtablefile = NULL; /* saves -qtables filename if any */  char * qslotsarg = NULL;  /* saves -qslots parm if any */  char * samplearg = NULL;  /* saves -sample parm if any */  char * scansarg = NULL; /* saves -scans parm if any */  /* Set up default JPEG parameters. */  /* Note that default -quality level need not, and does not,   * match the default scaling for an explicit -qtables argument.   */  quality = 75;     /* default -quality value */  q_scale_factor = 100;   /* default to no scaling for -qtables */  force_baseline = FALSE; /* by default, allow 16-bit quantizers */  simple_progressive = FALSE;  is_targa = FALSE;  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, "arithmetic", 1)) {      /* Use arithmetic coding. */#ifdef C_ARITH_CODING_SUPPORTED      cinfo->arith_code = TRUE;#else      fprintf(stderr, "%s: sorry, arithmetic coding not supported\n",        progname);      exit(EXIT_FAILURE);#endif    } else if (keymatch(arg, "baseline", 1)) {      /* Force baseline-compatible output (8-bit quantizer values). */      force_baseline = TRUE;    } else if (keymatch(arg, "dct", 2)) {      /* Select DCT 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, "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 CJPEG, version %s\n%s\n",        JVERSION, JCOPYRIGHT);        printed_version = TRUE;      }      cinfo->err->trace_level++;    } else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) {      /* Force a monochrome JPEG file to be generated. */      jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);    } 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, "optimize", 1) || keymatch(arg, "optimise", 1)) {      /* Enable entropy parm optimization. */#ifdef ENTROPY_OPT_SUPPORTED      cinfo->optimize_coding = TRUE;#else      fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n",        progname);      exit(EXIT_FAILURE);#endif    } else if (keymatch(arg, "outfile", 4)) {      /* Set output file name. */      if (++argn >= argc) /* advance to next argument */        usage();