djpeg.c

   1 /*
   2  * djpeg.c
   3  *
   4  * This file was part of the Independent JPEG Group's software:
   5  * Copyright (C) 1991-1997, Thomas G. Lane.
   6  * Modified 2013 by Guido Vollbeding.
   7  * libjpeg-turbo Modifications:
   8  * Copyright (C) 2010-2011, 2013-2017, 2020, D. R. Commander.
   9  * Copyright (C) 2015, Google, Inc.
  10  * For conditions of distribution and use, see the accompanying README.ijg
  11  * file.
  12  *
  13  * This file contains a command-line user interface for the JPEG decompressor.
  14  * It should work on any system with Unix- or MS-DOS-style command lines.
  15  *
  16  * Two different command line styles are permitted, depending on the
  17  * compile-time switch TWO_FILE_COMMANDLINE:
  18  *      djpeg [options]  inputfile outputfile
  19  *      djpeg [options]  [inputfile]
  20  * In the second style, output is always to standard output, which you'd
  21  * normally redirect to a file or pipe to some other program.  Input is
  22  * either from a named file or from standard input (typically redirected).
  23  * The second style is convenient on Unix but is unhelpful on systems that
  24  * don't support pipes.  Also, you MUST use the first style if your system
  25  * doesn't do binary I/O to stdin/stdout.
  26  * To simplify script writing, the "-outfile" switch is provided.  The syntax
  27  *      djpeg [options]  -outfile outputfile  inputfile
  28  * works regardless of which command line style is used.
  29  */
  30
  31 #include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
  32 #include "jversion.h"           /* for version message */
  33 #include "jconfigint.h"
  34
  35 #ifndef HAVE_STDLIB_H           /* <stdlib.h> should declare free() */
  36 extern void free(void *ptr);
  37 #endif
  38
  39 #include <ctype.h>              /* to declare isprint() */
  40
  41 #ifdef USE_CCOMMAND             /* command-line reader for Macintosh */
  42 #ifdef __MWERKS__
  43 #include <SIOUX.h>              /* Metrowerks needs this */
  44 #include <console.h>            /* ... and this */
  45 #endif
  46 #ifdef THINK_C
  47 #include <console.h>            /* Think declares it here */
  48 #endif
  49 #endif
  50
  51
  52 /* Create the add-on message string table. */
  53
  54 #define JMESSAGE(code, string)  string,
  55
  56 static const char * const cdjpeg_message_table[] = {
  57 #include "cderror.h"
  58   NULL
  59 };
  60
  61
  62 /*
  63  * This list defines the known output image formats
  64  * (not all of which need be supported by a given version).
  65  * You can change the default output format by defining DEFAULT_FMT;
  66  * indeed, you had better do so if you undefine PPM_SUPPORTED.
  67  */
  68
  69 typedef enum {
  70   FMT_BMP,                      /* BMP format (Windows flavor) */
  71   FMT_GIF,                      /* GIF format */
  72   FMT_OS2,                      /* BMP format (OS/2 flavor) */
  73   FMT_PPM,                      /* PPM/PGM (PBMPLUS formats) */
  74   FMT_RLE,                      /* RLE format */
  75   FMT_TARGA,                    /* Targa format */
  76   FMT_TIFF                      /* TIFF format */
  77 } IMAGE_FORMATS;
  78
  79 #ifndef DEFAULT_FMT             /* so can override from CFLAGS in Makefile */
  80 #define DEFAULT_FMT     FMT_PPM
  81 #endif
  82
  83 static IMAGE_FORMATS requested_fmt;
  84
  85
  86 /*
  87  * Argument-parsing code.
  88  * The switch parser is designed to be useful with DOS-style command line
  89  * syntax, ie, intermixed switches and file names, where only the switches
  90  * to the left of a given file name affect processing of that file.
  91  * The main program in this file doesn't actually use this capability...
  92  */
  93
  94
  95 static const char *progname;    /* program name for error messages */
  96 static char *icc_filename;      /* for -icc switch */
  97 static char *outfilename;       /* for -outfile switch */
  98 boolean memsrc;                 /* for -memsrc switch */
  99 boolean skip, crop;
 100 JDIMENSION skip_start, skip_end;
 101 JDIMENSION crop_x, crop_y, crop_width, crop_height;
 102 #define INPUT_BUF_SIZE  4096
 103
 104
 105 LOCAL(void)
 106 usage(void)
 107 /* complain about bad command line */
 108 {
 109   fprintf(stderr, "usage: %s [switches] ", progname);
 110 #ifdef TWO_FILE_COMMANDLINE
 111   fprintf(stderr, "inputfile outputfile\n");
 112 #else
 113   fprintf(stderr, "[inputfile]\n");
 114 #endif
 115
 116   fprintf(stderr, "Switches (names may be abbreviated):\n");
 117   fprintf(stderr, "  -colors N      Reduce image to no more than N colors\n");
 118   fprintf(stderr, "  -fast          Fast, low-quality processing\n");
 119   fprintf(stderr, "  -grayscale     Force grayscale output\n");
 120   fprintf(stderr, "  -rgb           Force RGB output\n");
 121   fprintf(stderr, "  -rgb565        Force RGB565 output\n");
 122 #ifdef IDCT_SCALING_SUPPORTED
 123   fprintf(stderr, "  -scale M/N     Scale output image by fraction M/N, eg, 1/8\n");
 124 #endif
 125 #ifdef BMP_SUPPORTED
 126   fprintf(stderr, "  -bmp           Select BMP output format (Windows style)%s\n",
 127           (DEFAULT_FMT == FMT_BMP ? " (default)" : ""));
 128 #endif
 129 #ifdef GIF_SUPPORTED
 130   fprintf(stderr, "  -gif           Select GIF output format%s\n",
 131           (DEFAULT_FMT == FMT_GIF ? " (default)" : ""));
 132 #endif
 133 #ifdef BMP_SUPPORTED
 134   fprintf(stderr, "  -os2           Select BMP output format (OS/2 style)%s\n",
 135           (DEFAULT_FMT == FMT_OS2 ? " (default)" : ""));
 136 #endif
 137 #ifdef PPM_SUPPORTED
 138   fprintf(stderr, "  -pnm           Select PBMPLUS (PPM/PGM) output format%s\n",
 139           (DEFAULT_FMT == FMT_PPM ? " (default)" : ""));
 140 #endif
 141 #ifdef RLE_SUPPORTED
 142   fprintf(stderr, "  -rle           Select Utah RLE output format%s\n",
 143           (DEFAULT_FMT == FMT_RLE ? " (default)" : ""));
 144 #endif
 145 #ifdef TARGA_SUPPORTED
 146   fprintf(stderr, "  -targa         Select Targa output format%s\n",
 147           (DEFAULT_FMT == FMT_TARGA ? " (default)" : ""));
 148 #endif
 149   fprintf(stderr, "Switches for advanced users:\n");
 150 #ifdef DCT_ISLOW_SUPPORTED
 151   fprintf(stderr, "  -dct int       Use accurate integer DCT method%s\n",
 152           (JDCT_DEFAULT == JDCT_ISLOW ? " (default)" : ""));
 153 #endif
 154 #ifdef DCT_IFAST_SUPPORTED
 155   fprintf(stderr, "  -dct fast      Use less accurate integer DCT method [legacy feature]%s\n",
 156           (JDCT_DEFAULT == JDCT_IFAST ? " (default)" : ""));
 157 #endif
 158 #ifdef DCT_FLOAT_SUPPORTED
 159   fprintf(stderr, "  -dct float     Use floating-point DCT method [legacy feature]%s\n",
 160           (JDCT_DEFAULT == JDCT_FLOAT ? " (default)" : ""));
 161 #endif
 162   fprintf(stderr, "  -dither fs     Use F-S dithering (default)\n");
 163   fprintf(stderr, "  -dither none   Don't use dithering in quantization\n");
 164   fprintf(stderr, "  -dither ordered  Use ordered dither (medium speed, quality)\n");
 165   fprintf(stderr, "  -icc FILE      Extract ICC profile to FILE\n");
 166 #ifdef QUANT_2PASS_SUPPORTED
 167   fprintf(stderr, "  -map FILE      Map to colors used in named image file\n");
 168 #endif
 169   fprintf(stderr, "  -nosmooth      Don't use high-quality upsampling\n");
 170 #ifdef QUANT_1PASS_SUPPORTED
 171   fprintf(stderr, "  -onepass       Use 1-pass quantization (fast, low quality)\n");
 172 #endif
 173   fprintf(stderr, "  -maxmemory N   Maximum memory to use (in kbytes)\n");
 174   fprintf(stderr, "  -outfile name  Specify name for output file\n");
 175 #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
 176   fprintf(stderr, "  -memsrc        Load input file into memory before decompressing\n");
 177 #endif
 178
 179   fprintf(stderr, "  -skip Y0,Y1    Decompress all rows except those between Y0 and Y1 (inclusive)\n");
 180   fprintf(stderr, "  -crop WxH+X+Y  Decompress only a rectangular subregion of the image\n");
 181   fprintf(stderr, "                 [requires PBMPLUS (PPM/PGM), GIF, or Targa output format]\n");
 182   fprintf(stderr, "  -verbose  or  -debug   Emit debug output\n");
 183   fprintf(stderr, "  -version       Print version information and exit\n");
 184   exit(EXIT_FAILURE);
 185 }
 186
 187
 188 LOCAL(int)
 189 parse_switches(j_decompress_ptr cinfo, int argc, char **argv,
 190                int last_file_arg_seen, boolean for_real)
 191 /* Parse optional switches.
 192  * Returns argv[] index of first file-name argument (== argc if none).
 193  * Any file names with indexes <= last_file_arg_seen are ignored;
 194  * they have presumably been processed in a previous iteration.
 195  * (Pass 0 for last_file_arg_seen on the first or only iteration.)
 196  * for_real is FALSE on the first (dummy) pass; we may skip any expensive
 197  * processing.
 198  */
 199 {
 200   int argn;
 201   char *arg;
 202
 203   /* Set up default JPEG parameters. */
 204   requested_fmt = DEFAULT_FMT;  /* set default output file format */
 205   icc_filename = NULL;
 206   outfilename = NULL;
 207   memsrc = FALSE;
 208   skip = FALSE;
 209   crop = FALSE;
 210   cinfo->err->trace_level = 0;
 211
 212   /* Scan command line options, adjust parameters */
 213
 214   for (argn = 1; argn < argc; argn++) {
 215     arg = argv[argn];
 216     if (*arg != '-') {
 217       /* Not a switch, must be a file name argument */
 218       if (argn <= last_file_arg_seen) {
 219         outfilename = NULL;     /* -outfile applies to just one input file */
 220         continue;               /* ignore this name if previously processed */
 221       }
 222       break;                    /* else done parsing switches */
 223     }
 224     arg++;                      /* advance past switch marker character */
 225
 226     if (keymatch(arg, "bmp", 1)) {
 227       /* BMP output format. */
 228       requested_fmt = FMT_BMP;
 229
 230     } else if (keymatch(arg, "colors", 1) || keymatch(arg, "colours", 1) ||
 231                keymatch(arg, "quantize", 1) || keymatch(arg, "quantise", 1)) {
 232       /* Do color quantization. */
 233       int val;
 234
 235       if (++argn >= argc)       /* advance to next argument */
 236         usage();
 237       if (sscanf(argv[argn], "%d", &val) != 1)
 238         usage();
 239       cinfo->desired_number_of_colors = val;
 240       cinfo->quantize_colors = TRUE;
 241
 242     } else if (keymatch(arg, "dct", 2)) {
 243       /* Select IDCT algorithm. */
 244       if (++argn >= argc)       /* advance to next argument */
 245         usage();
 246       if (keymatch(argv[argn], "int", 1)) {
 247         cinfo->dct_method = JDCT_ISLOW;
 248       } else if (keymatch(argv[argn], "fast", 2)) {
 249         cinfo->dct_method = JDCT_IFAST;
 250       } else if (keymatch(argv[argn], "float", 2)) {
 251         cinfo->dct_method = JDCT_FLOAT;
 252       } else
 253         usage();
 254
 255     } else if (keymatch(arg, "dither", 2)) {
 256       /* Select dithering algorithm. */
 257       if (++argn >= argc)       /* advance to next argument */
 258         usage();
 259       if (keymatch(argv[argn], "fs", 2)) {
 260         cinfo->dither_mode = JDITHER_FS;
 261       } else if (keymatch(argv[argn], "none", 2)) {
 262         cinfo->dither_mode = JDITHER_NONE;
 263       } else if (keymatch(argv[argn], "ordered", 2)) {
 264         cinfo->dither_mode = JDITHER_ORDERED;
 265       } else
 266         usage();
 267
 268     } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {
 269       /* Enable debug printouts. */
 270       /* On first -d, print version identification */
 271       static boolean printed_version = FALSE;
 272
 273       if (!printed_version) {
 274         fprintf(stderr, "%s version %s (build %s)\n",
 275                 PACKAGE_NAME, VERSION, BUILD);
 276         fprintf(stderr, "%s\n\n", JCOPYRIGHT);
 277         fprintf(stderr, "Emulating The Independent JPEG Group's software, version %s\n\n",
 278                 JVERSION);
 279         printed_version = TRUE;
 280       }
 281       cinfo->err->trace_level++;
 282
 283     } else if (keymatch(arg, "version", 4)) {
 284       fprintf(stderr, "%s version %s (build %s)\n",
 285               PACKAGE_NAME, VERSION, BUILD);
 286       exit(EXIT_SUCCESS);
 287
 288     } else if (keymatch(arg, "fast", 1)) {
 289       /* Select recommended processing options for quick-and-dirty output. */
 290       cinfo->two_pass_quantize = FALSE;
 291       cinfo->dither_mode = JDITHER_ORDERED;
 292       if (!cinfo->quantize_colors) /* don't override an earlier -colors */
 293         cinfo->desired_number_of_colors = 216;
 294       cinfo->dct_method = JDCT_FASTEST;
 295       cinfo->do_fancy_upsampling = FALSE;
 296
 297     } else if (keymatch(arg, "gif", 1)) {
 298       /* GIF output format. */
 299       requested_fmt = FMT_GIF;
 300
 301     } else if (keymatch(arg, "grayscale", 2) ||
 302                keymatch(arg, "greyscale", 2)) {
 303       /* Force monochrome output. */
 304       cinfo->out_color_space = JCS_GRAYSCALE;
 305
 306     } else if (keymatch(arg, "rgb", 2)) {
 307       /* Force RGB output. */
 308       cinfo->out_color_space = JCS_RGB;
 309
 310     } else if (keymatch(arg, "rgb565", 2)) {
 311       /* Force RGB565 output. */
 312       cinfo->out_color_space = JCS_RGB565;
 313
 314     } else if (keymatch(arg, "icc", 1)) {
 315       /* Set ICC filename. */
 316       if (++argn >= argc)       /* advance to next argument */
 317         usage();
 318       icc_filename = argv[argn];
 319       jpeg_save_markers(cinfo, JPEG_APP0 + 2, 0xFFFF);
 320
 321     } else if (keymatch(arg, "map", 3)) {
 322       /* Quantize to a color map taken from an input file. */
 323       if (++argn >= argc)       /* advance to next argument */
 324         usage();
 325       if (for_real) {           /* too expensive to do twice! */
 326 #ifdef QUANT_2PASS_SUPPORTED    /* otherwise can't quantize to supplied map */
 327         FILE *mapfile;
 328
 329         if ((mapfile = fopen(argv[argn], READ_BINARY)) == NULL) {
 330           fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]);
 331           exit(EXIT_FAILURE);
 332         }
 333         read_color_map(cinfo, mapfile);
 334         fclose(mapfile);
 335         cinfo->quantize_colors = TRUE;
 336 #else
 337         ERREXIT(cinfo, JERR_NOT_COMPILED);
 338 #endif
 339       }
 340
 341     } else if (keymatch(arg, "maxmemory", 3)) {
 342       /* Maximum memory in Kb (or Mb with 'm'). */
 343       long lval;
 344       char ch = 'x';
 345
 346       if (++argn >= argc)       /* advance to next argument */
 347         usage();
 348       if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
 349         usage();
 350       if (ch == 'm' || ch == 'M')
 351         lval *= 1000L;
 352       cinfo->mem->max_memory_to_use = lval * 1000L;
 353
 354     } else if (keymatch(arg, "nosmooth", 3)) {
 355       /* Suppress fancy upsampling */
 356       cinfo->do_fancy_upsampling = FALSE;
 357
 358     } else if (keymatch(arg, "onepass", 3)) {
 359       /* Use fast one-pass quantization. */
 360       cinfo->two_pass_quantize = FALSE;
 361
 362     } else if (keymatch(arg, "os2", 3)) {
 363       /* BMP output format (OS/2 flavor). */
 364       requested_fmt = FMT_OS2;
 365
 366     } else if (keymatch(arg, "outfile", 4)) {
 367       /* Set output file name. */
 368       if (++argn >= argc)       /* advance to next argument */
 369         usage();
 370       outfilename = argv[argn]; /* save it away for later use */
 371
 372     } else if (keymatch(arg, "memsrc", 2)) {
 373       /* Use in-memory source manager */
 374 #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
 375       memsrc = TRUE;
 376 #else
 377       fprintf(stderr, "%s: sorry, in-memory source manager was not compiled in\n",
 378               progname);
 379       exit(EXIT_FAILURE);
 380 #endif
 381
 382     } else if (keymatch(arg, "pnm", 1) || keymatch(arg, "ppm", 1)) {
 383       /* PPM/PGM output format. */
 384       requested_fmt = FMT_PPM;
 385
 386     } else if (keymatch(arg, "rle", 1)) {
 387       /* RLE output format. */
 388       requested_fmt = FMT_RLE;
 389
 390     } else if (keymatch(arg, "scale", 2)) {
 391       /* Scale the output image by a fraction M/N. */
 392       if (++argn >= argc)       /* advance to next argument */
 393         usage();
 394       if (sscanf(argv[argn], "%u/%u",
 395                  &cinfo->scale_num, &cinfo->scale_denom) != 2)
 396         usage();
 397
 398     } else if (keymatch(arg, "skip", 2)) {
 399       if (++argn >= argc)
 400         usage();
 401       if (sscanf(argv[argn], "%u,%u", &skip_start, &skip_end) != 2 ||
 402           skip_start > skip_end)
 403         usage();
 404       skip = TRUE;
 405
 406     } else if (keymatch(arg, "crop", 2)) {
 407       char c;
 408       if (++argn >= argc)
 409         usage();
 410       if (sscanf(argv[argn], "%u%c%u+%u+%u", &crop_width, &c, &crop_height,
 411                  &crop_x, &crop_y) != 5 ||
 412           (c != 'X' && c != 'x') || crop_width < 1 || crop_height < 1)
 413         usage();
 414       crop = TRUE;
 415
 416     } else if (keymatch(arg, "targa", 1)) {
 417       /* Targa output format. */
 418       requested_fmt = FMT_TARGA;
 419
 420     } else {
 421       usage();                  /* bogus switch */
 422     }
 423   }
 424
 425   return argn;                  /* return index of next arg (file name) */
 426 }
 427
 428
 429 /*
 430  * Marker processor for COM and interesting APPn markers.
 431  * This replaces the library's built-in processor, which just skips the marker.
 432  * We want to print out the marker as text, to the extent possible.
 433  * Note this code relies on a non-suspending data source.
 434  */
 435
 436 LOCAL(unsigned int)
 437 jpeg_getc(j_decompress_ptr cinfo)
 438 /* Read next byte */
 439 {
 440   struct jpeg_source_mgr *datasrc = cinfo->src;
 441
 442   if (datasrc->bytes_in_buffer == 0) {
 443     if (!(*datasrc->fill_input_buffer) (cinfo))
 444       ERREXIT(cinfo, JERR_CANT_SUSPEND);
 445   }
 446   datasrc->bytes_in_buffer--;
 447   return GETJOCTET(*datasrc->next_input_byte++);
 448 }
 449
 450
 451 METHODDEF(boolean)
 452 print_text_marker(j_decompress_ptr cinfo)
 453 {
 454   boolean traceit = (cinfo->err->trace_level >= 1);
 455   long length;
 456   unsigned int ch;
 457   unsigned int lastch = 0;
 458
 459   length = jpeg_getc(cinfo) << 8;
 460   length += jpeg_getc(cinfo);
 461   length -= 2;                  /* discount the length word itself */
 462
 463   if (traceit) {
 464     if (cinfo->unread_marker == JPEG_COM)
 465       fprintf(stderr, "Comment, length %ld:\n", (long)length);
 466     else                        /* assume it is an APPn otherwise */
 467       fprintf(stderr, "APP%d, length %ld:\n",
 468               cinfo->unread_marker - JPEG_APP0, (long)length);
 469   }
 470
 471   while (--length >= 0) {
 472     ch = jpeg_getc(cinfo);
 473     if (traceit) {
 474       /* Emit the character in a readable form.
 475        * Nonprintables are converted to \nnn form,
 476        * while \ is converted to \\.
 477        * Newlines in CR, CR/LF, or LF form will be printed as one newline.
 478        */
 479       if (ch == '\r') {
 480         fprintf(stderr, "\n");
 481       } else if (ch == '\n') {
 482         if (lastch != '\r')
 483           fprintf(stderr, "\n");
 484       } else if (ch == '\\') {
 485         fprintf(stderr, "\\\\");
 486       } else if (isprint(ch)) {
 487         putc(ch, stderr);
 488       } else {
 489         fprintf(stderr, "\\%03o", ch);
 490       }
 491       lastch = ch;
 492     }
 493   }
 494
 495   if (traceit)
 496     fprintf(stderr, "\n");
 497
 498   return TRUE;
 499 }
 500
 501
 502 /*
 503  * The main program.
 504  */
 505
 506 int
 507 main(int argc, char **argv)
 508 {
 509   struct jpeg_decompress_struct cinfo;
 510   struct jpeg_error_mgr jerr;
 511 #ifdef PROGRESS_REPORT
 512   struct cdjpeg_progress_mgr progress;
 513 #endif
 514   int file_index;
 515   djpeg_dest_ptr dest_mgr = NULL;
 516   FILE *input_file;
 517   FILE *output_file;
 518   unsigned char *inbuffer = NULL;
 519 #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
 520   unsigned long insize = 0;
 521 #endif
 522   JDIMENSION num_scanlines;
 523
 524   /* On Mac, fetch a command line. */
 525 #ifdef USE_CCOMMAND
 526   argc = ccommand(&argv);
 527 #endif
 528
 529   progname = argv[0];
 530   if (progname == NULL || progname[0] == 0)
 531     progname = "djpeg";         /* in case C library doesn't provide it */
 532
 533   /* Initialize the JPEG decompression object with default error handling. */
 534   cinfo.err = jpeg_std_error(&jerr);
 535   jpeg_create_decompress(&cinfo);
 536   /* Add some application-specific error messages (from cderror.h) */
 537   jerr.addon_message_table = cdjpeg_message_table;
 538   jerr.first_addon_message = JMSG_FIRSTADDONCODE;
 539   jerr.last_addon_message = JMSG_LASTADDONCODE;
 540
 541   /* Insert custom marker processor for COM and APP12.
 542    * APP12 is used by some digital camera makers for textual info,
 543    * so we provide the ability to display it as text.
 544    * If you like, additional APPn marker types can be selected for display,
 545    * but don't try to override APP0 or APP14 this way (see libjpeg.txt).
 546    */
 547   jpeg_set_marker_processor(&cinfo, JPEG_COM, print_text_marker);
 548   jpeg_set_marker_processor(&cinfo, JPEG_APP0 + 12, print_text_marker);
 549
 550   /* Scan command line to find file names. */
 551   /* It is convenient to use just one switch-parsing routine, but the switch
 552    * values read here are ignored; we will rescan the switches after opening
 553    * the input file.
 554    * (Exception: tracing level set here controls verbosity for COM markers
 555    * found during jpeg_read_header...)
 556    */
 557
 558   file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
 559
 560 #ifdef TWO_FILE_COMMANDLINE
 561   /* Must have either -outfile switch or explicit output file name */
 562   if (outfilename == NULL) {
 563     if (file_index != argc - 2) {
 564       fprintf(stderr, "%s: must name one input and one output file\n",
 565               progname);
 566       usage();
 567     }
 568     outfilename = argv[file_index + 1];
 569   } else {
 570     if (file_index != argc - 1) {
 571       fprintf(stderr, "%s: must name one input and one output file\n",
 572               progname);
 573       usage();
 574     }
 575   }
 576 #else
 577   /* Unix style: expect zero or one file name */
 578   if (file_index < argc - 1) {
 579     fprintf(stderr, "%s: only one input file\n", progname);
 580     usage();
 581   }
 582 #endif /* TWO_FILE_COMMANDLINE */
 583
 584   /* Open the input file. */
 585   if (file_index < argc) {
 586     if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
 587       fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
 588       exit(EXIT_FAILURE);
 589     }
 590   } else {
 591     /* default input file is stdin */
 592     input_file = read_stdin();
 593   }
 594
 595   /* Open the output file. */
 596   if (outfilename != NULL) {
 597     if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
 598       fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
 599       exit(EXIT_FAILURE);
 600     }
 601   } else {
 602     /* default output file is stdout */
 603     output_file = write_stdout();
 604   }
 605
 606 #ifdef PROGRESS_REPORT
 607   start_progress_monitor((j_common_ptr)&cinfo, &progress);
 608 #endif
 609
 610   /* Specify data source for decompression */
 611 #if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
 612   if (memsrc) {
 613     size_t nbytes;
 614     do {
 615       inbuffer = (unsigned char *)realloc(inbuffer, insize + INPUT_BUF_SIZE);
 616       if (inbuffer == NULL) {
 617         fprintf(stderr, "%s: memory allocation failure\n", progname);
 618         exit(EXIT_FAILURE);
 619       }
 620       nbytes = JFREAD(input_file, &inbuffer[insize], INPUT_BUF_SIZE);
 621       if (nbytes < INPUT_BUF_SIZE && ferror(input_file)) {
 622         if (file_index < argc)
 623           fprintf(stderr, "%s: can't read from %s\n", progname,
 624                   argv[file_index]);
 625         else
 626           fprintf(stderr, "%s: can't read from stdin\n", progname);
 627       }
 628       insize += (unsigned long)nbytes;
 629     } while (nbytes == INPUT_BUF_SIZE);
 630     fprintf(stderr, "Compressed size:  %lu bytes\n", insize);
 631     jpeg_mem_src(&cinfo, inbuffer, insize);
 632   } else
 633 #endif
 634     jpeg_stdio_src(&cinfo, input_file);
 635
 636   /* Read file header, set default decompression parameters */
 637   (void)jpeg_read_header(&cinfo, TRUE);
 638
 639   /* Adjust default decompression parameters by re-parsing the options */
 640   file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
 641
 642   /* Initialize the output module now to let it override any crucial
 643    * option settings (for instance, GIF wants to force color quantization).
 644    */
 645   switch (requested_fmt) {
 646 #ifdef BMP_SUPPORTED
 647   case FMT_BMP:
 648     dest_mgr = jinit_write_bmp(&cinfo, FALSE, TRUE);
 649     break;
 650   case FMT_OS2:
 651     dest_mgr = jinit_write_bmp(&cinfo, TRUE, TRUE);
 652     break;
 653 #endif
 654 #ifdef GIF_SUPPORTED
 655   case FMT_GIF:
 656     dest_mgr = jinit_write_gif(&cinfo);
 657     break;
 658 #endif
 659 #ifdef PPM_SUPPORTED
 660   case FMT_PPM:
 661     dest_mgr = jinit_write_ppm(&cinfo);
 662     break;
 663 #endif
 664 #ifdef RLE_SUPPORTED
 665   case FMT_RLE:
 666     dest_mgr = jinit_write_rle(&cinfo);
 667     break;
 668 #endif
 669 #ifdef TARGA_SUPPORTED
 670   case FMT_TARGA:
 671     dest_mgr = jinit_write_targa(&cinfo);
 672     break;
 673 #endif
 674   default:
 675     ERREXIT(&cinfo, JERR_UNSUPPORTED_FORMAT);
 676     break;
 677   }
 678   dest_mgr->output_file = output_file;
 679
 680   /* Start decompressor */
 681   (void)jpeg_start_decompress(&cinfo);
 682
 683   /* Skip rows */
 684   if (skip) {
 685     JDIMENSION tmp;
 686
 687     /* Check for valid skip_end.  We cannot check this value until after
 688      * jpeg_start_decompress() is called.  Note that we have already verified
 689      * that skip_start <= skip_end.
 690      */
 691     if (skip_end > cinfo.output_height - 1) {
 692       fprintf(stderr, "%s: skip region exceeds image height %d\n", progname,
 693               cinfo.output_height);
 694       exit(EXIT_FAILURE);
 695     }
 696
 697     /* Write output file header.  This is a hack to ensure that the destination
 698      * manager creates an output image of the proper size.
 699      */
 700     tmp = cinfo.output_height;
 701     cinfo.output_height -= (skip_end - skip_start + 1);
 702     (*dest_mgr->start_output) (&cinfo, dest_mgr);
 703     cinfo.output_height = tmp;
 704
 705     /* Process data */
 706     while (cinfo.output_scanline < skip_start) {
 707       num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
 708                                           dest_mgr->buffer_height);
 709       (*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
 710     }
 711     if ((tmp = jpeg_skip_scanlines(&cinfo, skip_end - skip_start + 1)) !=
 712         skip_end - skip_start + 1) {
 713       fprintf(stderr, "%s: jpeg_skip_scanlines() returned %d rather than %d\n",
 714               progname, tmp, skip_end - skip_start + 1);
 715       exit(EXIT_FAILURE);
 716     }
 717     while (cinfo.output_scanline < cinfo.output_height) {
 718       num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
 719                                           dest_mgr->buffer_height);
 720       (*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
 721     }
 722
 723   /* Decompress a subregion */
 724   } else if (crop) {
 725     JDIMENSION tmp;
 726
 727     /* Check for valid crop dimensions.  We cannot check these values until
 728      * after jpeg_start_decompress() is called.
 729      */
 730     if (crop_x + crop_width > cinfo.output_width ||
 731         crop_y + crop_height > cinfo.output_height) {
 732       fprintf(stderr, "%s: crop dimensions exceed image dimensions %d x %d\n",
 733               progname, cinfo.output_width, cinfo.output_height);
 734       exit(EXIT_FAILURE);
 735     }
 736
 737     jpeg_crop_scanline(&cinfo, &crop_x, &crop_width);
 738     if (dest_mgr->calc_buffer_dimensions)
 739       (*dest_mgr->calc_buffer_dimensions) (&cinfo, dest_mgr);
 740     else
 741       ERREXIT(&cinfo, JERR_UNSUPPORTED_FORMAT);
 742
 743     /* Write output file header.  This is a hack to ensure that the destination
 744      * manager creates an output image of the proper size.
 745      */
 746     tmp = cinfo.output_height;
 747     cinfo.output_height = crop_height;
 748     (*dest_mgr->start_output) (&cinfo, dest_mgr);
 749     cinfo.output_height = tmp;
 750
 751     /* Process data */
 752     if ((tmp = jpeg_skip_scanlines(&cinfo, crop_y)) != crop_y) {
 753       fprintf(stderr, "%s: jpeg_skip_scanlines() returned %d rather than %d\n",
 754               progname, tmp, crop_y);
 755       exit(EXIT_FAILURE);
 756     }
 757     while (cinfo.output_scanline < crop_y + crop_height) {
 758       num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
 759                                           dest_mgr->buffer_height);
 760       (*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
 761     }
 762     if ((tmp =
 763          jpeg_skip_scanlines(&cinfo,
 764                              cinfo.output_height - crop_y - crop_height)) !=
 765         cinfo.output_height - crop_y - crop_height) {
 766       fprintf(stderr, "%s: jpeg_skip_scanlines() returned %d rather than %d\n",
 767               progname, tmp, cinfo.output_height - crop_y - crop_height);
 768       exit(EXIT_FAILURE);
 769     }
 770
 771   /* Normal full-image decompress */
 772   } else {
 773     /* Write output file header */
 774     (*dest_mgr->start_output) (&cinfo, dest_mgr);
 775
 776     /* Process data */
 777     while (cinfo.output_scanline < cinfo.output_height) {
 778       num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
 779                                           dest_mgr->buffer_height);
 780       (*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
 781     }
 782   }
 783
 784 #ifdef PROGRESS_REPORT
 785   /* Hack: count final pass as done in case finish_output does an extra pass.
 786    * The library won't have updated completed_passes.
 787    */
 788   progress.pub.completed_passes = progress.pub.total_passes;
 789 #endif
 790
 791   if (icc_filename != NULL) {
 792     FILE *icc_file;
 793     JOCTET *icc_profile;
 794     unsigned int icc_len;
 795
 796     if ((icc_file = fopen(icc_filename, WRITE_BINARY)) == NULL) {
 797       fprintf(stderr, "%s: can't open %s\n", progname, icc_filename);
 798       exit(EXIT_FAILURE);
 799     }
 800     if (jpeg_read_icc_profile(&cinfo, &icc_profile, &icc_len)) {
 801       if (fwrite(icc_profile, icc_len, 1, icc_file) < 1) {
 802         fprintf(stderr, "%s: can't read ICC profile from %s\n", progname,
 803                 icc_filename);
 804         free(icc_profile);
 805         fclose(icc_file);
 806         exit(EXIT_FAILURE);
 807       }
 808       free(icc_profile);
 809       fclose(icc_file);
 810     } else if (cinfo.err->msg_code != JWRN_BOGUS_ICC)
 811       fprintf(stderr, "%s: no ICC profile data in JPEG file\n", progname);
 812   }
 813
 814   /* Finish decompression and release memory.
 815    * I must do it in this order because output module has allocated memory
 816    * of lifespan JPOOL_IMAGE; it needs to finish before releasing memory.
 817    */
 818   (*dest_mgr->finish_output) (&cinfo, dest_mgr);
 819   (void)jpeg_finish_decompress(&cinfo);
 820   jpeg_destroy_decompress(&cinfo);
 821
 822   /* Close files, if we opened them */
 823   if (input_file != stdin)
 824     fclose(input_file);
 825   if (output_file != stdout)
 826     fclose(output_file);
 827
 828 #ifdef PROGRESS_REPORT
 829   end_progress_monitor((j_common_ptr)&cinfo);
 830 #endif
 831
 832   if (memsrc)
 833     free(inbuffer);
 834
 835   /* All done. */
 836   exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
 837   return 0;                     /* suppress no-return-value warnings */
 838 }