4 * Copyright (C) 1991-1997, Thomas G. Lane.
5 * Modified 2009-2015 by Guido Vollbeding.
6 * This file is part of the Independent JPEG Group's software.
7 * For conditions of distribution and use, see the accompanying README file.
9 * This file contains a command-line user interface for the JPEG decompressor.
10 * It should work on any system with Unix- or MS-DOS-style command lines.
12 * Two different command line styles are permitted, depending on the
13 * compile-time switch TWO_FILE_COMMANDLINE:
14 * djpeg [options] inputfile outputfile
15 * djpeg [options] [inputfile]
16 * In the second style, output is always to standard output, which you'd
17 * normally redirect to a file or pipe to some other program. Input is
18 * either from a named file or from standard input (typically redirected).
19 * The second style is convenient on Unix but is unhelpful on systems that
20 * don't support pipes. Also, you MUST use the first style if your system
21 * doesn't do binary I/O to stdin/stdout.
22 * To simplify script writing, the "-outfile" switch is provided. The syntax
23 * djpeg [options] -outfile outputfile inputfile
24 * works regardless of which command line style is used.
27 #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
28 #include "jversion.h" /* for version message */
30 #include <ctype.h> /* to declare isprint() */
32 #ifdef USE_CCOMMAND /* command-line reader for Macintosh */
34 #include <SIOUX.h> /* Metrowerks needs this */
35 #include <console.h> /* ... and this */
38 #include <console.h> /* Think declares it here */
43 /* Create the add-on message string table. */
45 #define JMESSAGE(code,string) string ,
47 static const char * const cdjpeg_message_table
[] = {
54 * This list defines the known output image formats
55 * (not all of which need be supported by a given version).
56 * You can change the default output format by defining DEFAULT_FMT;
57 * indeed, you had better do so if you undefine PPM_SUPPORTED.
61 FMT_BMP
, /* BMP format (Windows flavor) */
62 FMT_GIF
, /* GIF format */
63 FMT_OS2
, /* BMP format (OS/2 flavor) */
64 FMT_PPM
, /* PPM/PGM (PBMPLUS formats) */
65 FMT_RLE
, /* RLE format */
66 FMT_TARGA
, /* Targa format */
67 FMT_TIFF
/* TIFF format */
70 #ifndef DEFAULT_FMT /* so can override from CFLAGS in Makefile */
71 #define DEFAULT_FMT FMT_PPM
74 static IMAGE_FORMATS requested_fmt
;
78 * Argument-parsing code.
79 * The switch parser is designed to be useful with DOS-style command line
80 * syntax, ie, intermixed switches and file names, where only the switches
81 * to the left of a given file name affect processing of that file.
82 * The main program in this file doesn't actually use this capability...
86 static const char * progname
; /* program name for error messages */
87 static char * outfilename
; /* for -outfile switch */
92 /* complain about bad command line */
94 fprintf(stderr
, "usage: %s [switches] ", progname
);
95 #ifdef TWO_FILE_COMMANDLINE
96 fprintf(stderr
, "inputfile outputfile\n");
98 fprintf(stderr
, "[inputfile]\n");
101 fprintf(stderr
, "Switches (names may be abbreviated):\n");
102 fprintf(stderr
, " -colors N Reduce image to no more than N colors\n");
103 fprintf(stderr
, " -fast Fast, low-quality processing\n");
104 fprintf(stderr
, " -grayscale Force grayscale output\n");
105 fprintf(stderr
, " -rgb Force RGB output\n");
106 #ifdef IDCT_SCALING_SUPPORTED
107 fprintf(stderr
, " -scale M/N Scale output image by fraction M/N, eg, 1/8\n");
110 fprintf(stderr
, " -bmp Select BMP output format (Windows style)%s\n",
111 (DEFAULT_FMT
== FMT_BMP
? " (default)" : ""));
114 fprintf(stderr
, " -gif Select GIF output format%s\n",
115 (DEFAULT_FMT
== FMT_GIF
? " (default)" : ""));
118 fprintf(stderr
, " -os2 Select BMP output format (OS/2 style)%s\n",
119 (DEFAULT_FMT
== FMT_OS2
? " (default)" : ""));
122 fprintf(stderr
, " -pnm Select PBMPLUS (PPM/PGM) output format%s\n",
123 (DEFAULT_FMT
== FMT_PPM
? " (default)" : ""));
126 fprintf(stderr
, " -rle Select Utah RLE output format%s\n",
127 (DEFAULT_FMT
== FMT_RLE
? " (default)" : ""));
129 #ifdef TARGA_SUPPORTED
130 fprintf(stderr
, " -targa Select Targa output format%s\n",
131 (DEFAULT_FMT
== FMT_TARGA
? " (default)" : ""));
133 fprintf(stderr
, "Switches for advanced users:\n");
134 #ifdef DCT_ISLOW_SUPPORTED
135 fprintf(stderr
, " -dct int Use integer DCT method%s\n",
136 (JDCT_DEFAULT
== JDCT_ISLOW
? " (default)" : ""));
138 #ifdef DCT_IFAST_SUPPORTED
139 fprintf(stderr
, " -dct fast Use fast integer DCT (less accurate)%s\n",
140 (JDCT_DEFAULT
== JDCT_IFAST
? " (default)" : ""));
142 #ifdef DCT_FLOAT_SUPPORTED
143 fprintf(stderr
, " -dct float Use floating-point DCT method%s\n",
144 (JDCT_DEFAULT
== JDCT_FLOAT
? " (default)" : ""));
146 fprintf(stderr
, " -dither fs Use F-S dithering (default)\n");
147 fprintf(stderr
, " -dither none Don't use dithering in quantization\n");
148 fprintf(stderr
, " -dither ordered Use ordered dither (medium speed, quality)\n");
149 #ifdef QUANT_2PASS_SUPPORTED
150 fprintf(stderr
, " -map FILE Map to colors used in named image file\n");
152 fprintf(stderr
, " -nosmooth Don't use high-quality upsampling\n");
153 #ifdef QUANT_1PASS_SUPPORTED
154 fprintf(stderr
, " -onepass Use 1-pass quantization (fast, low quality)\n");
156 fprintf(stderr
, " -maxmemory N Maximum memory to use (in kbytes)\n");
157 fprintf(stderr
, " -outfile name Specify name for output file\n");
158 fprintf(stderr
, " -verbose or -debug Emit debug output\n");
164 parse_switches (j_decompress_ptr cinfo
, int argc
, char **argv
,
165 int last_file_arg_seen
, boolean for_real
)
166 /* Parse optional switches.
167 * Returns argv[] index of first file-name argument (== argc if none).
168 * Any file names with indexes <= last_file_arg_seen are ignored;
169 * they have presumably been processed in a previous iteration.
170 * (Pass 0 for last_file_arg_seen on the first or only iteration.)
171 * for_real is FALSE on the first (dummy) pass; we may skip any expensive
178 /* Set up default JPEG parameters. */
179 requested_fmt
= DEFAULT_FMT
; /* set default output file format */
181 cinfo
->err
->trace_level
= 0;
183 /* Scan command line options, adjust parameters */
185 for (argn
= 1; argn
< argc
; argn
++) {
188 /* Not a switch, must be a file name argument */
189 if (argn
<= last_file_arg_seen
) {
190 outfilename
= NULL
; /* -outfile applies to just one input file */
191 continue; /* ignore this name if previously processed */
193 break; /* else done parsing switches */
195 arg
++; /* advance past switch marker character */
197 if (keymatch(arg
, "bmp", 1)) {
198 /* BMP output format. */
199 requested_fmt
= FMT_BMP
;
201 } else if (keymatch(arg
, "colors", 1) || keymatch(arg
, "colours", 1) ||
202 keymatch(arg
, "quantize", 1) || keymatch(arg
, "quantise", 1)) {
203 /* Do color quantization. */
206 if (++argn
>= argc
) /* advance to next argument */
208 if (sscanf(argv
[argn
], "%d", &val
) != 1)
210 cinfo
->desired_number_of_colors
= val
;
211 cinfo
->quantize_colors
= TRUE
;
213 } else if (keymatch(arg
, "dct", 2)) {
214 /* Select IDCT algorithm. */
215 if (++argn
>= argc
) /* advance to next argument */
217 if (keymatch(argv
[argn
], "int", 1)) {
218 cinfo
->dct_method
= JDCT_ISLOW
;
219 } else if (keymatch(argv
[argn
], "fast", 2)) {
220 cinfo
->dct_method
= JDCT_IFAST
;
221 } else if (keymatch(argv
[argn
], "float", 2)) {
222 cinfo
->dct_method
= JDCT_FLOAT
;
226 } else if (keymatch(arg
, "dither", 2)) {
227 /* Select dithering algorithm. */
228 if (++argn
>= argc
) /* advance to next argument */
230 if (keymatch(argv
[argn
], "fs", 2)) {
231 cinfo
->dither_mode
= JDITHER_FS
;
232 } else if (keymatch(argv
[argn
], "none", 2)) {
233 cinfo
->dither_mode
= JDITHER_NONE
;
234 } else if (keymatch(argv
[argn
], "ordered", 2)) {
235 cinfo
->dither_mode
= JDITHER_ORDERED
;
239 } else if (keymatch(arg
, "debug", 1) || keymatch(arg
, "verbose", 1)) {
240 /* Enable debug printouts. */
241 /* On first -d, print version identification */
242 static boolean printed_version
= FALSE
;
244 if (! printed_version
) {
245 fprintf(stderr
, "Independent JPEG Group's DJPEG, version %s\n%s\n",
246 JVERSION
, JCOPYRIGHT
);
247 printed_version
= TRUE
;
249 cinfo
->err
->trace_level
++;
251 } else if (keymatch(arg
, "fast", 1)) {
252 /* Select recommended processing options for quick-and-dirty output. */
253 cinfo
->two_pass_quantize
= FALSE
;
254 cinfo
->dither_mode
= JDITHER_ORDERED
;
255 if (! cinfo
->quantize_colors
) /* don't override an earlier -colors */
256 cinfo
->desired_number_of_colors
= 216;
257 cinfo
->dct_method
= JDCT_FASTEST
;
258 cinfo
->do_fancy_upsampling
= FALSE
;
260 } else if (keymatch(arg
, "gif", 1)) {
261 /* GIF output format. */
262 requested_fmt
= FMT_GIF
;
264 } else if (keymatch(arg
, "grayscale", 2) || keymatch(arg
, "greyscale",2)) {
265 /* Force monochrome output. */
266 cinfo
->out_color_space
= JCS_GRAYSCALE
;
268 } else if (keymatch(arg
, "rgb", 3)) {
269 /* Force RGB output. */
270 cinfo
->out_color_space
= JCS_RGB
;
272 } else if (keymatch(arg
, "map", 3)) {
273 /* Quantize to a color map taken from an input file. */
274 if (++argn
>= argc
) /* advance to next argument */
276 if (for_real
) { /* too expensive to do twice! */
277 #ifdef QUANT_2PASS_SUPPORTED /* otherwise can't quantize to supplied map */
280 if ((mapfile
= fopen(argv
[argn
], READ_BINARY
)) == NULL
) {
281 fprintf(stderr
, "%s: can't open %s\n", progname
, argv
[argn
]);
284 read_color_map(cinfo
, mapfile
);
286 cinfo
->quantize_colors
= TRUE
;
288 ERREXIT(cinfo
, JERR_NOT_COMPILED
);
292 } else if (keymatch(arg
, "maxmemory", 3)) {
293 /* Maximum memory in Kb (or Mb with 'm'). */
297 if (++argn
>= argc
) /* advance to next argument */
299 if (sscanf(argv
[argn
], "%ld%c", &lval
, &ch
) < 1)
301 if (ch
== 'm' || ch
== 'M')
303 cinfo
->mem
->max_memory_to_use
= lval
* 1000L;
305 } else if (keymatch(arg
, "nosmooth", 3)) {
306 /* Suppress fancy upsampling. */
307 cinfo
->do_fancy_upsampling
= FALSE
;
309 } else if (keymatch(arg
, "onepass", 3)) {
310 /* Use fast one-pass quantization. */
311 cinfo
->two_pass_quantize
= FALSE
;
313 } else if (keymatch(arg
, "os2", 3)) {
314 /* BMP output format (OS/2 flavor). */
315 requested_fmt
= FMT_OS2
;
317 } else if (keymatch(arg
, "outfile", 4)) {
318 /* Set output file name. */
319 if (++argn
>= argc
) /* advance to next argument */
321 outfilename
= argv
[argn
]; /* save it away for later use */
323 } else if (keymatch(arg
, "pnm", 1) || keymatch(arg
, "ppm", 1)) {
324 /* PPM/PGM output format. */
325 requested_fmt
= FMT_PPM
;
327 } else if (keymatch(arg
, "rle", 1)) {
328 /* RLE output format. */
329 requested_fmt
= FMT_RLE
;
331 } else if (keymatch(arg
, "scale", 1)) {
332 /* Scale the output image by a fraction M/N. */
333 if (++argn
>= argc
) /* advance to next argument */
335 if (sscanf(argv
[argn
], "%u/%u",
336 &cinfo
->scale_num
, &cinfo
->scale_denom
) < 1)
339 } else if (keymatch(arg
, "targa", 1)) {
340 /* Targa output format. */
341 requested_fmt
= FMT_TARGA
;
344 usage(); /* bogus switch */
348 return argn
; /* return index of next arg (file name) */
353 * Marker processor for COM and interesting APPn markers.
354 * This replaces the library's built-in processor, which just skips the marker.
355 * We want to print out the marker as text, to the extent possible.
356 * Note this code relies on a non-suspending data source.
360 jpeg_getc (j_decompress_ptr cinfo
)
363 struct jpeg_source_mgr
* datasrc
= cinfo
->src
;
365 if (datasrc
->bytes_in_buffer
== 0) {
366 if (! (*datasrc
->fill_input_buffer
) (cinfo
))
367 ERREXIT(cinfo
, JERR_CANT_SUSPEND
);
369 datasrc
->bytes_in_buffer
--;
370 return GETJOCTET(*datasrc
->next_input_byte
++);
375 print_text_marker (j_decompress_ptr cinfo
)
377 boolean traceit
= (cinfo
->err
->trace_level
>= 1);
380 unsigned int lastch
= 0;
382 length
= jpeg_getc(cinfo
) << 8;
383 length
+= jpeg_getc(cinfo
);
384 length
-= 2; /* discount the length word itself */
387 if (cinfo
->unread_marker
== JPEG_COM
)
388 fprintf(stderr
, "Comment, length %ld:\n", (long) length
);
389 else /* assume it is an APPn otherwise */
390 fprintf(stderr
, "APP%d, length %ld:\n",
391 cinfo
->unread_marker
- JPEG_APP0
, (long) length
);
394 while (--length
>= 0) {
395 ch
= jpeg_getc(cinfo
);
397 /* Emit the character in a readable form.
398 * Nonprintables are converted to \nnn form,
399 * while \ is converted to \\.
400 * Newlines in CR, CR/LF, or LF form will be printed as one newline.
403 fprintf(stderr
, "\n");
404 } else if (ch
== '\n') {
406 fprintf(stderr
, "\n");
407 } else if (ch
== '\\') {
408 fprintf(stderr
, "\\\\");
409 } else if (isprint(ch
)) {
412 fprintf(stderr
, "\\%03o", ch
);
419 fprintf(stderr
, "\n");
430 main (int argc
, char **argv
)
432 struct jpeg_decompress_struct cinfo
;
433 struct jpeg_error_mgr jerr
;
434 #ifdef PROGRESS_REPORT
435 struct cdjpeg_progress_mgr progress
;
438 djpeg_dest_ptr dest_mgr
= NULL
;
441 JDIMENSION num_scanlines
;
443 /* On Mac, fetch a command line. */
445 argc
= ccommand(&argv
);
449 if (progname
== NULL
|| progname
[0] == 0)
450 progname
= "djpeg"; /* in case C library doesn't provide it */
452 /* Initialize the JPEG decompression object with default error handling. */
453 cinfo
.err
= jpeg_std_error(&jerr
);
454 jpeg_create_decompress(&cinfo
);
455 /* Add some application-specific error messages (from cderror.h) */
456 jerr
.addon_message_table
= cdjpeg_message_table
;
457 jerr
.first_addon_message
= JMSG_FIRSTADDONCODE
;
458 jerr
.last_addon_message
= JMSG_LASTADDONCODE
;
460 /* Insert custom marker processor for COM and APP12.
461 * APP12 is used by some digital camera makers for textual info,
462 * so we provide the ability to display it as text.
463 * If you like, additional APPn marker types can be selected for display,
464 * but don't try to override APP0 or APP14 this way (see libjpeg.doc).
466 jpeg_set_marker_processor(&cinfo
, JPEG_COM
, print_text_marker
);
467 jpeg_set_marker_processor(&cinfo
, JPEG_APP0
+12, print_text_marker
);
469 /* Now safe to enable signal catcher. */
470 #ifdef NEED_SIGNAL_CATCHER
471 enable_signal_catcher((j_common_ptr
) &cinfo
);
474 /* Scan command line to find file names. */
475 /* It is convenient to use just one switch-parsing routine, but the switch
476 * values read here are ignored; we will rescan the switches after opening
478 * (Exception: tracing level set here controls verbosity for COM markers
479 * found during jpeg_read_header...)
482 file_index
= parse_switches(&cinfo
, argc
, argv
, 0, FALSE
);
484 #ifdef TWO_FILE_COMMANDLINE
485 /* Must have either -outfile switch or explicit output file name */
486 if (outfilename
== NULL
) {
487 if (file_index
!= argc
-2) {
488 fprintf(stderr
, "%s: must name one input and one output file\n",
492 outfilename
= argv
[file_index
+1];
494 if (file_index
!= argc
-1) {
495 fprintf(stderr
, "%s: must name one input and one output file\n",
501 /* Unix style: expect zero or one file name */
502 if (file_index
< argc
-1) {
503 fprintf(stderr
, "%s: only one input file\n", progname
);
506 #endif /* TWO_FILE_COMMANDLINE */
508 /* Open the input file. */
509 if (file_index
< argc
) {
510 if ((input_file
= fopen(argv
[file_index
], READ_BINARY
)) == NULL
) {
511 fprintf(stderr
, "%s: can't open %s\n", progname
, argv
[file_index
]);
515 /* default input file is stdin */
516 input_file
= read_stdin();
519 /* Open the output file. */
520 if (outfilename
!= NULL
) {
521 if ((output_file
= fopen(outfilename
, WRITE_BINARY
)) == NULL
) {
522 fprintf(stderr
, "%s: can't open %s\n", progname
, outfilename
);
526 /* default output file is stdout */
527 output_file
= write_stdout();
530 #ifdef PROGRESS_REPORT
531 start_progress_monitor((j_common_ptr
) &cinfo
, &progress
);
534 /* Specify data source for decompression */
535 jpeg_stdio_src(&cinfo
, input_file
);
537 /* Read file header, set default decompression parameters */
538 (void) jpeg_read_header(&cinfo
, TRUE
);
540 /* Adjust default decompression parameters by re-parsing the options */
541 file_index
= parse_switches(&cinfo
, argc
, argv
, 0, TRUE
);
543 /* Initialize the output module now to let it override any crucial
544 * option settings (for instance, GIF wants to force color quantization).
546 switch (requested_fmt
) {
549 dest_mgr
= jinit_write_bmp(&cinfo
, FALSE
);
552 dest_mgr
= jinit_write_bmp(&cinfo
, TRUE
);
557 dest_mgr
= jinit_write_gif(&cinfo
);
562 dest_mgr
= jinit_write_ppm(&cinfo
);
567 dest_mgr
= jinit_write_rle(&cinfo
);
570 #ifdef TARGA_SUPPORTED
572 dest_mgr
= jinit_write_targa(&cinfo
);
576 ERREXIT(&cinfo
, JERR_UNSUPPORTED_FORMAT
);
579 dest_mgr
->output_file
= output_file
;
581 /* Start decompressor */
582 (void) jpeg_start_decompress(&cinfo
);
584 /* Write output file header */
585 (*dest_mgr
->start_output
) (&cinfo
, dest_mgr
);
588 while (cinfo
.output_scanline
< cinfo
.output_height
) {
589 num_scanlines
= jpeg_read_scanlines(&cinfo
, dest_mgr
->buffer
,
590 dest_mgr
->buffer_height
);
591 (*dest_mgr
->put_pixel_rows
) (&cinfo
, dest_mgr
, num_scanlines
);
594 #ifdef PROGRESS_REPORT
595 /* Hack: count final pass as done in case finish_output does an extra pass.
596 * The library won't have updated completed_passes.
598 progress
.pub
.completed_passes
= progress
.pub
.total_passes
;
601 /* Finish decompression and release memory.
602 * I must do it in this order because output module has allocated memory
603 * of lifespan JPOOL_IMAGE; it needs to finish before releasing memory.
605 (*dest_mgr
->finish_output
) (&cinfo
, dest_mgr
);
606 (void) jpeg_finish_decompress(&cinfo
);
607 jpeg_destroy_decompress(&cinfo
);
609 /* Close files, if we opened them */
610 if (input_file
!= stdin
)
612 if (output_file
!= stdout
)
615 #ifdef PROGRESS_REPORT
616 end_progress_monitor((j_common_ptr
) &cinfo
);
620 exit(jerr
.num_warnings
? EXIT_WARNING
: EXIT_SUCCESS
);
621 return 0; /* suppress no-return-value warnings */