4 * Copyright (C) 1991-1998, Thomas G. Lane.
5 * Modified 2003-2013 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 compressor.
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 * cjpeg [options] inputfile outputfile
15 * cjpeg [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 * cjpeg [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 #ifdef USE_CCOMMAND /* command-line reader for Macintosh */
32 #include <SIOUX.h> /* Metrowerks needs this */
33 #include <console.h> /* ... and this */
36 #include <console.h> /* Think declares it here */
41 /* Create the add-on message string table. */
43 #define JMESSAGE(code,string) string ,
45 static const char * const cdjpeg_message_table
[] = {
52 * This routine determines what format the input file is,
53 * and selects the appropriate input-reading module.
55 * To determine which family of input formats the file belongs to,
56 * we may look only at the first byte of the file, since C does not
57 * guarantee that more than one character can be pushed back with ungetc.
58 * Looking at additional bytes would require one of these approaches:
59 * 1) assume we can fseek() the input file (fails for piped input);
60 * 2) assume we can push back more than one character (works in
61 * some C implementations, but unportable);
62 * 3) provide our own buffering (breaks input readers that want to use
63 * stdio directly, such as the RLE library);
64 * or 4) don't put back the data, and modify the input_init methods to assume
65 * they start reading after the start of file (also breaks RLE library).
66 * #1 is attractive for MS-DOS but is untenable on Unix.
68 * The most portable solution for file types that can't be identified by their
69 * first byte is to make the user tell us what they are. This is also the
70 * only approach for "raw" file types that contain only arbitrary values.
71 * We presently apply this method for Targa files. Most of the time Targa
72 * files start with 0x00, so we recognize that case. Potentially, however,
73 * a Targa file could start with any byte value (byte 0 is the length of the
74 * seldom-used ID field), so we provide a switch to force Targa input mode.
77 static boolean is_targa
; /* records user -targa switch */
80 LOCAL(cjpeg_source_ptr
)
81 select_file_type (j_compress_ptr cinfo
, FILE * infile
)
86 #ifdef TARGA_SUPPORTED
87 return jinit_read_targa(cinfo
);
89 ERREXIT(cinfo
, JERR_TGA_NOTCOMP
);
93 if ((c
= getc(infile
)) == EOF
)
94 ERREXIT(cinfo
, JERR_INPUT_EMPTY
);
95 if (ungetc(c
, infile
) == EOF
)
96 ERREXIT(cinfo
, JERR_UNGETC_FAILED
);
101 return jinit_read_bmp(cinfo
);
105 return jinit_read_gif(cinfo
);
109 return jinit_read_ppm(cinfo
);
113 return jinit_read_rle(cinfo
);
115 #ifdef TARGA_SUPPORTED
117 return jinit_read_targa(cinfo
);
120 ERREXIT(cinfo
, JERR_UNKNOWN_FORMAT
);
124 return NULL
; /* suppress compiler warnings */
129 * Argument-parsing code.
130 * The switch parser is designed to be useful with DOS-style command line
131 * syntax, ie, intermixed switches and file names, where only the switches
132 * to the left of a given file name affect processing of that file.
133 * The main program in this file doesn't actually use this capability...
137 static const char * progname
; /* program name for error messages */
138 static char * outfilename
; /* for -outfile switch */
143 /* complain about bad command line */
145 fprintf(stderr
, "usage: %s [switches] ", progname
);
146 #ifdef TWO_FILE_COMMANDLINE
147 fprintf(stderr
, "inputfile outputfile\n");
149 fprintf(stderr
, "[inputfile]\n");
152 fprintf(stderr
, "Switches (names may be abbreviated):\n");
153 fprintf(stderr
, " -quality N[,...] Compression quality (0..100; 5-95 is useful range)\n");
154 fprintf(stderr
, " -grayscale Create monochrome JPEG file\n");
155 fprintf(stderr
, " -rgb Create RGB JPEG file\n");
156 #ifdef ENTROPY_OPT_SUPPORTED
157 fprintf(stderr
, " -optimize Optimize Huffman table (smaller file, but slow compression)\n");
159 #ifdef C_PROGRESSIVE_SUPPORTED
160 fprintf(stderr
, " -progressive Create progressive JPEG file\n");
162 #ifdef DCT_SCALING_SUPPORTED
163 fprintf(stderr
, " -scale M/N Scale image by fraction M/N, eg, 1/2\n");
165 #ifdef TARGA_SUPPORTED
166 fprintf(stderr
, " -targa Input file is Targa format (usually not needed)\n");
168 fprintf(stderr
, "Switches for advanced users:\n");
169 #ifdef C_ARITH_CODING_SUPPORTED
170 fprintf(stderr
, " -arithmetic Use arithmetic coding\n");
172 #ifdef DCT_SCALING_SUPPORTED
173 fprintf(stderr
, " -block N DCT block size (1..16; default is 8)\n");
175 #if JPEG_LIB_VERSION_MAJOR >= 9
176 fprintf(stderr
, " -rgb1 Create RGB JPEG file with reversible color transform\n");
177 fprintf(stderr
, " -bgycc Create big gamut YCC JPEG file\n");
179 #ifdef DCT_ISLOW_SUPPORTED
180 fprintf(stderr
, " -dct int Use integer DCT method%s\n",
181 (JDCT_DEFAULT
== JDCT_ISLOW
? " (default)" : ""));
183 #ifdef DCT_IFAST_SUPPORTED
184 fprintf(stderr
, " -dct fast Use fast integer DCT (less accurate)%s\n",
185 (JDCT_DEFAULT
== JDCT_IFAST
? " (default)" : ""));
187 #ifdef DCT_FLOAT_SUPPORTED
188 fprintf(stderr
, " -dct float Use floating-point DCT method%s\n",
189 (JDCT_DEFAULT
== JDCT_FLOAT
? " (default)" : ""));
191 fprintf(stderr
, " -nosmooth Don't use high-quality downsampling\n");
192 fprintf(stderr
, " -restart N Set restart interval in rows, or in blocks with B\n");
193 #ifdef INPUT_SMOOTHING_SUPPORTED
194 fprintf(stderr
, " -smooth N Smooth dithered input (N=1..100 is strength)\n");
196 fprintf(stderr
, " -maxmemory N Maximum memory to use (in kbytes)\n");
197 fprintf(stderr
, " -outfile name Specify name for output file\n");
198 fprintf(stderr
, " -verbose or -debug Emit debug output\n");
199 fprintf(stderr
, "Switches for wizards:\n");
200 fprintf(stderr
, " -baseline Force baseline quantization tables\n");
201 fprintf(stderr
, " -qtables file Use quantization tables given in file\n");
202 fprintf(stderr
, " -qslots N[,...] Set component quantization tables\n");
203 fprintf(stderr
, " -sample HxV[,...] Set component sampling factors\n");
204 #ifdef C_MULTISCAN_FILES_SUPPORTED
205 fprintf(stderr
, " -scans file Create multi-scan JPEG per script file\n");
212 parse_switches (j_compress_ptr cinfo
, int argc
, char **argv
,
213 int last_file_arg_seen
, boolean for_real
)
214 /* Parse optional switches.
215 * Returns argv[] index of first file-name argument (== argc if none).
216 * Any file names with indexes <= last_file_arg_seen are ignored;
217 * they have presumably been processed in a previous iteration.
218 * (Pass 0 for last_file_arg_seen on the first or only iteration.)
219 * for_real is FALSE on the first (dummy) pass; we may skip any expensive
225 boolean force_baseline
;
226 boolean simple_progressive
;
227 char * qualityarg
= NULL
; /* saves -quality parm if any */
228 char * qtablefile
= NULL
; /* saves -qtables filename if any */
229 char * qslotsarg
= NULL
; /* saves -qslots parm if any */
230 char * samplearg
= NULL
; /* saves -sample parm if any */
231 char * scansarg
= NULL
; /* saves -scans parm if any */
233 /* Set up default JPEG parameters. */
235 force_baseline
= FALSE
; /* by default, allow 16-bit quantizers */
236 simple_progressive
= FALSE
;
239 cinfo
->err
->trace_level
= 0;
241 /* Scan command line options, adjust parameters */
243 for (argn
= 1; argn
< argc
; argn
++) {
246 /* Not a switch, must be a file name argument */
247 if (argn
<= last_file_arg_seen
) {
248 outfilename
= NULL
; /* -outfile applies to just one input file */
249 continue; /* ignore this name if previously processed */
251 break; /* else done parsing switches */
253 arg
++; /* advance past switch marker character */
255 if (keymatch(arg
, "arithmetic", 1)) {
256 /* Use arithmetic coding. */
257 #ifdef C_ARITH_CODING_SUPPORTED
258 cinfo
->arith_code
= TRUE
;
260 fprintf(stderr
, "%s: sorry, arithmetic coding not supported\n",
265 } else if (keymatch(arg
, "baseline", 2)) {
266 /* Force baseline-compatible output (8-bit quantizer values). */
267 force_baseline
= TRUE
;
269 } else if (keymatch(arg
, "block", 2)) {
270 /* Set DCT block size. */
271 #if defined DCT_SCALING_SUPPORTED && JPEG_LIB_VERSION_MAJOR >= 8 && \
272 (JPEG_LIB_VERSION_MAJOR > 8 || JPEG_LIB_VERSION_MINOR >= 3)
275 if (++argn
>= argc
) /* advance to next argument */
277 if (sscanf(argv
[argn
], "%d", &val
) != 1)
279 if (val
< 1 || val
> 16)
281 cinfo
->block_size
= val
;
283 fprintf(stderr
, "%s: sorry, block size setting not supported\n",
288 } else if (keymatch(arg
, "dct", 2)) {
289 /* Select DCT algorithm. */
290 if (++argn
>= argc
) /* advance to next argument */
292 if (keymatch(argv
[argn
], "int", 1)) {
293 cinfo
->dct_method
= JDCT_ISLOW
;
294 } else if (keymatch(argv
[argn
], "fast", 2)) {
295 cinfo
->dct_method
= JDCT_IFAST
;
296 } else if (keymatch(argv
[argn
], "float", 2)) {
297 cinfo
->dct_method
= JDCT_FLOAT
;
301 } else if (keymatch(arg
, "debug", 1) || keymatch(arg
, "verbose", 1)) {
302 /* Enable debug printouts. */
303 /* On first -d, print version identification */
304 static boolean printed_version
= FALSE
;
306 if (! printed_version
) {
307 fprintf(stderr
, "Independent JPEG Group's CJPEG, version %s\n%s\n",
308 JVERSION
, JCOPYRIGHT
);
309 printed_version
= TRUE
;
311 cinfo
->err
->trace_level
++;
313 } else if (keymatch(arg
, "grayscale", 2) || keymatch(arg
, "greyscale",2)) {
314 /* Force a monochrome JPEG file to be generated. */
315 jpeg_set_colorspace(cinfo
, JCS_GRAYSCALE
);
317 } else if (keymatch(arg
, "rgb", 3) || keymatch(arg
, "rgb1", 4)) {
318 /* Force an RGB JPEG file to be generated. */
319 #if JPEG_LIB_VERSION_MAJOR >= 9
320 /* Note: Entropy table assignment in jpeg_set_colorspace depends
321 * on color_transform.
323 cinfo
->color_transform
= arg
[3] ? JCT_SUBTRACT_GREEN
: JCT_NONE
;
325 jpeg_set_colorspace(cinfo
, JCS_RGB
);
327 } else if (keymatch(arg
, "bgycc", 5)) {
328 /* Force a big gamut YCC JPEG file to be generated. */
329 #if JPEG_LIB_VERSION_MAJOR >= 9 && \
330 (JPEG_LIB_VERSION_MAJOR > 9 || JPEG_LIB_VERSION_MINOR >= 1)
331 jpeg_set_colorspace(cinfo
, JCS_BG_YCC
);
333 fprintf(stderr
, "%s: sorry, BG_YCC colorspace not supported\n",
338 } else if (keymatch(arg
, "maxmemory", 3)) {
339 /* Maximum memory in Kb (or Mb with 'm'). */
343 if (++argn
>= argc
) /* advance to next argument */
345 if (sscanf(argv
[argn
], "%ld%c", &lval
, &ch
) < 1)
347 if (ch
== 'm' || ch
== 'M')
349 cinfo
->mem
->max_memory_to_use
= lval
* 1000L;
351 } else if (keymatch(arg
, "nosmooth", 3)) {
352 /* Suppress fancy downsampling. */
353 cinfo
->do_fancy_downsampling
= FALSE
;
355 } else if (keymatch(arg
, "optimize", 1) || keymatch(arg
, "optimise", 1)) {
356 /* Enable entropy parm optimization. */
357 #ifdef ENTROPY_OPT_SUPPORTED
358 cinfo
->optimize_coding
= TRUE
;
360 fprintf(stderr
, "%s: sorry, entropy optimization was not compiled\n",
365 } else if (keymatch(arg
, "outfile", 4)) {
366 /* Set output file name. */
367 if (++argn
>= argc
) /* advance to next argument */
369 outfilename
= argv
[argn
]; /* save it away for later use */
371 } else if (keymatch(arg
, "progressive", 1)) {
372 /* Select simple progressive mode. */
373 #ifdef C_PROGRESSIVE_SUPPORTED
374 simple_progressive
= TRUE
;
375 /* We must postpone execution until num_components is known. */
377 fprintf(stderr
, "%s: sorry, progressive output was not compiled\n",
382 } else if (keymatch(arg
, "quality", 1)) {
383 /* Quality ratings (quantization table scaling factors). */
384 if (++argn
>= argc
) /* advance to next argument */
386 qualityarg
= argv
[argn
];
388 } else if (keymatch(arg
, "qslots", 2)) {
389 /* Quantization table slot numbers. */
390 if (++argn
>= argc
) /* advance to next argument */
392 qslotsarg
= argv
[argn
];
393 /* Must delay setting qslots until after we have processed any
394 * colorspace-determining switches, since jpeg_set_colorspace sets
395 * default quant table numbers.
398 } else if (keymatch(arg
, "qtables", 2)) {
399 /* Quantization tables fetched from file. */
400 if (++argn
>= argc
) /* advance to next argument */
402 qtablefile
= argv
[argn
];
403 /* We postpone actually reading the file in case -quality comes later. */
405 } else if (keymatch(arg
, "restart", 1)) {
406 /* Restart interval in MCU rows (or in MCUs with 'b'). */
410 if (++argn
>= argc
) /* advance to next argument */
412 if (sscanf(argv
[argn
], "%ld%c", &lval
, &ch
) < 1)
414 if (lval
< 0 || lval
> 65535L)
416 if (ch
== 'b' || ch
== 'B') {
417 cinfo
->restart_interval
= (unsigned int) lval
;
418 cinfo
->restart_in_rows
= 0; /* else prior '-restart n' overrides me */
420 cinfo
->restart_in_rows
= (int) lval
;
421 /* restart_interval will be computed during startup */
424 } else if (keymatch(arg
, "sample", 2)) {
425 /* Set sampling factors. */
426 if (++argn
>= argc
) /* advance to next argument */
428 samplearg
= argv
[argn
];
429 /* Must delay setting sample factors until after we have processed any
430 * colorspace-determining switches, since jpeg_set_colorspace sets
431 * default sampling factors.
434 } else if (keymatch(arg
, "scale", 4)) {
435 /* Scale the image by a fraction M/N. */
436 if (++argn
>= argc
) /* advance to next argument */
438 if (sscanf(argv
[argn
], "%u/%u",
439 &cinfo
->scale_num
, &cinfo
->scale_denom
) != 2)
442 } else if (keymatch(arg
, "scans", 4)) {
443 /* Set scan script. */
444 #ifdef C_MULTISCAN_FILES_SUPPORTED
445 if (++argn
>= argc
) /* advance to next argument */
447 scansarg
= argv
[argn
];
448 /* We must postpone reading the file in case -progressive appears. */
450 fprintf(stderr
, "%s: sorry, multi-scan output was not compiled\n",
455 } else if (keymatch(arg
, "smooth", 2)) {
456 /* Set input smoothing factor. */
459 if (++argn
>= argc
) /* advance to next argument */
461 if (sscanf(argv
[argn
], "%d", &val
) != 1)
463 if (val
< 0 || val
> 100)
465 cinfo
->smoothing_factor
= val
;
467 } else if (keymatch(arg
, "targa", 1)) {
468 /* Input file is Targa format. */
472 usage(); /* bogus switch */
476 /* Post-switch-scanning cleanup */
480 /* Set quantization tables for selected quality. */
481 /* Some or all may be overridden if -qtables is present. */
482 if (qualityarg
!= NULL
) /* process -quality if it was present */
483 if (! set_quality_ratings(cinfo
, qualityarg
, force_baseline
))
486 if (qtablefile
!= NULL
) /* process -qtables if it was present */
487 if (! read_quant_tables(cinfo
, qtablefile
, force_baseline
))
490 if (qslotsarg
!= NULL
) /* process -qslots if it was present */
491 if (! set_quant_slots(cinfo
, qslotsarg
))
494 if (samplearg
!= NULL
) /* process -sample if it was present */
495 if (! set_sample_factors(cinfo
, samplearg
))
498 #ifdef C_PROGRESSIVE_SUPPORTED
499 if (simple_progressive
) /* process -progressive; -scans can override */
500 jpeg_simple_progression(cinfo
);
503 #ifdef C_MULTISCAN_FILES_SUPPORTED
504 if (scansarg
!= NULL
) /* process -scans if it was present */
505 if (! read_scan_script(cinfo
, scansarg
))
510 return argn
; /* return index of next arg (file name) */
519 main (int argc
, char **argv
)
521 struct jpeg_compress_struct cinfo
;
522 struct jpeg_error_mgr jerr
;
523 #ifdef PROGRESS_REPORT
524 struct cdjpeg_progress_mgr progress
;
527 cjpeg_source_ptr src_mgr
;
530 JDIMENSION num_scanlines
;
532 /* On Mac, fetch a command line. */
534 argc
= ccommand(&argv
);
538 if (progname
== NULL
|| progname
[0] == 0)
539 progname
= "cjpeg"; /* in case C library doesn't provide it */
541 /* Initialize the JPEG compression object with default error handling. */
542 cinfo
.err
= jpeg_std_error(&jerr
);
543 jpeg_create_compress(&cinfo
);
544 /* Add some application-specific error messages (from cderror.h) */
545 jerr
.addon_message_table
= cdjpeg_message_table
;
546 jerr
.first_addon_message
= JMSG_FIRSTADDONCODE
;
547 jerr
.last_addon_message
= JMSG_LASTADDONCODE
;
549 /* Now safe to enable signal catcher. */
550 #ifdef NEED_SIGNAL_CATCHER
551 enable_signal_catcher((j_common_ptr
) &cinfo
);
554 /* Initialize JPEG parameters.
555 * Much of this may be overridden later.
556 * In particular, we don't yet know the input file's color space,
557 * but we need to provide some value for jpeg_set_defaults() to work.
560 cinfo
.in_color_space
= JCS_RGB
; /* arbitrary guess */
561 jpeg_set_defaults(&cinfo
);
563 /* Scan command line to find file names.
564 * It is convenient to use just one switch-parsing routine, but the switch
565 * values read here are ignored; we will rescan the switches after opening
569 file_index
= parse_switches(&cinfo
, argc
, argv
, 0, FALSE
);
571 #ifdef TWO_FILE_COMMANDLINE
572 /* Must have either -outfile switch or explicit output file name */
573 if (outfilename
== NULL
) {
574 if (file_index
!= argc
-2) {
575 fprintf(stderr
, "%s: must name one input and one output file\n",
579 outfilename
= argv
[file_index
+1];
581 if (file_index
!= argc
-1) {
582 fprintf(stderr
, "%s: must name one input and one output file\n",
588 /* Unix style: expect zero or one file name */
589 if (file_index
< argc
-1) {
590 fprintf(stderr
, "%s: only one input file\n", progname
);
593 #endif /* TWO_FILE_COMMANDLINE */
595 /* Open the input file. */
596 if (file_index
< argc
) {
597 if ((input_file
= fopen(argv
[file_index
], READ_BINARY
)) == NULL
) {
598 fprintf(stderr
, "%s: can't open %s\n", progname
, argv
[file_index
]);
602 /* default input file is stdin */
603 input_file
= read_stdin();
606 /* Open the output file. */
607 if (outfilename
!= NULL
) {
608 if ((output_file
= fopen(outfilename
, WRITE_BINARY
)) == NULL
) {
609 fprintf(stderr
, "%s: can't open %s\n", progname
, outfilename
);
613 /* default output file is stdout */
614 output_file
= write_stdout();
617 #ifdef PROGRESS_REPORT
618 start_progress_monitor((j_common_ptr
) &cinfo
, &progress
);
621 /* Figure out the input file format, and set up to read it. */
622 src_mgr
= select_file_type(&cinfo
, input_file
);
623 src_mgr
->input_file
= input_file
;
625 /* Read the input file header to obtain file size & colorspace. */
626 (*src_mgr
->start_input
) (&cinfo
, src_mgr
);
628 /* Now that we know input colorspace, fix colorspace-dependent defaults */
629 jpeg_default_colorspace(&cinfo
);
631 /* Adjust default compression parameters by re-parsing the options */
632 file_index
= parse_switches(&cinfo
, argc
, argv
, 0, TRUE
);
634 /* Specify data destination for compression */
635 jpeg_stdio_dest(&cinfo
, output_file
);
637 /* Start compressor */
638 jpeg_start_compress(&cinfo
, TRUE
);
641 while (cinfo
.next_scanline
< cinfo
.image_height
) {
642 num_scanlines
= (*src_mgr
->get_pixel_rows
) (&cinfo
, src_mgr
);
643 (void) jpeg_write_scanlines(&cinfo
, src_mgr
->buffer
, num_scanlines
);
646 /* Finish compression and release memory */
647 (*src_mgr
->finish_input
) (&cinfo
, src_mgr
);
648 jpeg_finish_compress(&cinfo
);
649 jpeg_destroy_compress(&cinfo
);
651 /* Close files, if we opened them */
652 if (input_file
!= stdin
)
654 if (output_file
!= stdout
)
657 #ifdef PROGRESS_REPORT
658 end_progress_monitor((j_common_ptr
) &cinfo
);
662 exit(jerr
.num_warnings
? EXIT_WARNING
: EXIT_SUCCESS
);
663 return 0; /* suppress no-return-value warnings */