4 * Copyright (C) 1991-1998, Thomas G. Lane.
5 * Modified 2003-2008 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 #ifdef ENTROPY_OPT_SUPPORTED
156 fprintf(stderr
, " -optimize Optimize Huffman table (smaller file, but slow compression)\n");
158 #ifdef C_PROGRESSIVE_SUPPORTED
159 fprintf(stderr
, " -progressive Create progressive JPEG file\n");
161 #ifdef DCT_SCALING_SUPPORTED
162 fprintf(stderr
, " -scale M/N Scale image by fraction M/N, eg, 1/2\n");
164 #ifdef TARGA_SUPPORTED
165 fprintf(stderr
, " -targa Input file is Targa format (usually not needed)\n");
167 fprintf(stderr
, "Switches for advanced users:\n");
168 #ifdef DCT_ISLOW_SUPPORTED
169 fprintf(stderr
, " -dct int Use integer DCT method%s\n",
170 (JDCT_DEFAULT
== JDCT_ISLOW
? " (default)" : ""));
172 #ifdef DCT_IFAST_SUPPORTED
173 fprintf(stderr
, " -dct fast Use fast integer DCT (less accurate)%s\n",
174 (JDCT_DEFAULT
== JDCT_IFAST
? " (default)" : ""));
176 #ifdef DCT_FLOAT_SUPPORTED
177 fprintf(stderr
, " -dct float Use floating-point DCT method%s\n",
178 (JDCT_DEFAULT
== JDCT_FLOAT
? " (default)" : ""));
180 fprintf(stderr
, " -nosmooth Don't use high-quality downsampling\n");
181 fprintf(stderr
, " -restart N Set restart interval in rows, or in blocks with B\n");
182 #ifdef INPUT_SMOOTHING_SUPPORTED
183 fprintf(stderr
, " -smooth N Smooth dithered input (N=1..100 is strength)\n");
185 fprintf(stderr
, " -maxmemory N Maximum memory to use (in kbytes)\n");
186 fprintf(stderr
, " -outfile name Specify name for output file\n");
187 fprintf(stderr
, " -verbose or -debug Emit debug output\n");
188 fprintf(stderr
, "Switches for wizards:\n");
189 #ifdef C_ARITH_CODING_SUPPORTED
190 fprintf(stderr
, " -arithmetic Use arithmetic coding\n");
192 fprintf(stderr
, " -baseline Force baseline quantization tables\n");
193 fprintf(stderr
, " -qtables file Use quantization tables given in file\n");
194 fprintf(stderr
, " -qslots N[,...] Set component quantization tables\n");
195 fprintf(stderr
, " -sample HxV[,...] Set component sampling factors\n");
196 #ifdef C_MULTISCAN_FILES_SUPPORTED
197 fprintf(stderr
, " -scans file Create multi-scan JPEG per script file\n");
204 parse_switches (j_compress_ptr cinfo
, int argc
, char **argv
,
205 int last_file_arg_seen
, boolean for_real
)
206 /* Parse optional switches.
207 * Returns argv[] index of first file-name argument (== argc if none).
208 * Any file names with indexes <= last_file_arg_seen are ignored;
209 * they have presumably been processed in a previous iteration.
210 * (Pass 0 for last_file_arg_seen on the first or only iteration.)
211 * for_real is FALSE on the first (dummy) pass; we may skip any expensive
217 boolean force_baseline
;
218 boolean simple_progressive
;
219 char * qualityarg
= NULL
; /* saves -quality parm if any */
220 char * qtablefile
= NULL
; /* saves -qtables filename if any */
221 char * qslotsarg
= NULL
; /* saves -qslots parm if any */
222 char * samplearg
= NULL
; /* saves -sample parm if any */
223 char * scansarg
= NULL
; /* saves -scans parm if any */
225 /* Set up default JPEG parameters. */
227 force_baseline
= FALSE
; /* by default, allow 16-bit quantizers */
228 simple_progressive
= FALSE
;
231 cinfo
->err
->trace_level
= 0;
233 /* Scan command line options, adjust parameters */
235 for (argn
= 1; argn
< argc
; argn
++) {
238 /* Not a switch, must be a file name argument */
239 if (argn
<= last_file_arg_seen
) {
240 outfilename
= NULL
; /* -outfile applies to just one input file */
241 continue; /* ignore this name if previously processed */
243 break; /* else done parsing switches */
245 arg
++; /* advance past switch marker character */
247 if (keymatch(arg
, "arithmetic", 1)) {
248 /* Use arithmetic coding. */
249 #ifdef C_ARITH_CODING_SUPPORTED
250 cinfo
->arith_code
= TRUE
;
252 fprintf(stderr
, "%s: sorry, arithmetic coding not supported\n",
257 } else if (keymatch(arg
, "baseline", 1)) {
258 /* Force baseline-compatible output (8-bit quantizer values). */
259 force_baseline
= TRUE
;
261 } else if (keymatch(arg
, "dct", 2)) {
262 /* Select DCT algorithm. */
263 if (++argn
>= argc
) /* advance to next argument */
265 if (keymatch(argv
[argn
], "int", 1)) {
266 cinfo
->dct_method
= JDCT_ISLOW
;
267 } else if (keymatch(argv
[argn
], "fast", 2)) {
268 cinfo
->dct_method
= JDCT_IFAST
;
269 } else if (keymatch(argv
[argn
], "float", 2)) {
270 cinfo
->dct_method
= JDCT_FLOAT
;
274 } else if (keymatch(arg
, "debug", 1) || keymatch(arg
, "verbose", 1)) {
275 /* Enable debug printouts. */
276 /* On first -d, print version identification */
277 static boolean printed_version
= FALSE
;
279 if (! printed_version
) {
280 fprintf(stderr
, "Independent JPEG Group's CJPEG, version %s\n%s\n",
281 JVERSION
, JCOPYRIGHT
);
282 printed_version
= TRUE
;
284 cinfo
->err
->trace_level
++;
286 } else if (keymatch(arg
, "grayscale", 2) || keymatch(arg
, "greyscale",2)) {
287 /* Force a monochrome JPEG file to be generated. */
288 jpeg_set_colorspace(cinfo
, JCS_GRAYSCALE
);
290 } else if (keymatch(arg
, "maxmemory", 3)) {
291 /* Maximum memory in Kb (or Mb with 'm'). */
295 if (++argn
>= argc
) /* advance to next argument */
297 if (sscanf(argv
[argn
], "%ld%c", &lval
, &ch
) < 1)
299 if (ch
== 'm' || ch
== 'M')
301 cinfo
->mem
->max_memory_to_use
= lval
* 1000L;
303 } else if (keymatch(arg
, "nosmooth", 3)) {
304 /* Suppress fancy downsampling */
305 cinfo
->do_fancy_downsampling
= FALSE
;
307 } else if (keymatch(arg
, "optimize", 1) || keymatch(arg
, "optimise", 1)) {
308 /* Enable entropy parm optimization. */
309 #ifdef ENTROPY_OPT_SUPPORTED
310 cinfo
->optimize_coding
= TRUE
;
312 fprintf(stderr
, "%s: sorry, entropy optimization was not compiled\n",
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
, "progressive", 1)) {
324 /* Select simple progressive mode. */
325 #ifdef C_PROGRESSIVE_SUPPORTED
326 simple_progressive
= TRUE
;
327 /* We must postpone execution until num_components is known. */
329 fprintf(stderr
, "%s: sorry, progressive output was not compiled\n",
334 } else if (keymatch(arg
, "quality", 1)) {
335 /* Quality ratings (quantization table scaling factors). */
336 if (++argn
>= argc
) /* advance to next argument */
338 qualityarg
= argv
[argn
];
340 } else if (keymatch(arg
, "qslots", 2)) {
341 /* Quantization table slot numbers. */
342 if (++argn
>= argc
) /* advance to next argument */
344 qslotsarg
= argv
[argn
];
345 /* Must delay setting qslots until after we have processed any
346 * colorspace-determining switches, since jpeg_set_colorspace sets
347 * default quant table numbers.
350 } else if (keymatch(arg
, "qtables", 2)) {
351 /* Quantization tables fetched from file. */
352 if (++argn
>= argc
) /* advance to next argument */
354 qtablefile
= argv
[argn
];
355 /* We postpone actually reading the file in case -quality comes later. */
357 } else if (keymatch(arg
, "restart", 1)) {
358 /* Restart interval in MCU rows (or in MCUs with 'b'). */
362 if (++argn
>= argc
) /* advance to next argument */
364 if (sscanf(argv
[argn
], "%ld%c", &lval
, &ch
) < 1)
366 if (lval
< 0 || lval
> 65535L)
368 if (ch
== 'b' || ch
== 'B') {
369 cinfo
->restart_interval
= (unsigned int) lval
;
370 cinfo
->restart_in_rows
= 0; /* else prior '-restart n' overrides me */
372 cinfo
->restart_in_rows
= (int) lval
;
373 /* restart_interval will be computed during startup */
376 } else if (keymatch(arg
, "sample", 2)) {
377 /* Set sampling factors. */
378 if (++argn
>= argc
) /* advance to next argument */
380 samplearg
= argv
[argn
];
381 /* Must delay setting sample factors until after we have processed any
382 * colorspace-determining switches, since jpeg_set_colorspace sets
383 * default sampling factors.
386 } else if (keymatch(arg
, "scale", 4)) {
387 /* Scale the image by a fraction M/N. */
388 if (++argn
>= argc
) /* advance to next argument */
390 if (sscanf(argv
[argn
], "%d/%d",
391 &cinfo
->scale_num
, &cinfo
->scale_denom
) != 2)
394 } else if (keymatch(arg
, "scans", 4)) {
395 /* Set scan script. */
396 #ifdef C_MULTISCAN_FILES_SUPPORTED
397 if (++argn
>= argc
) /* advance to next argument */
399 scansarg
= argv
[argn
];
400 /* We must postpone reading the file in case -progressive appears. */
402 fprintf(stderr
, "%s: sorry, multi-scan output was not compiled\n",
407 } else if (keymatch(arg
, "smooth", 2)) {
408 /* Set input smoothing factor. */
411 if (++argn
>= argc
) /* advance to next argument */
413 if (sscanf(argv
[argn
], "%d", &val
) != 1)
415 if (val
< 0 || val
> 100)
417 cinfo
->smoothing_factor
= val
;
419 } else if (keymatch(arg
, "targa", 1)) {
420 /* Input file is Targa format. */
424 usage(); /* bogus switch */
428 /* Post-switch-scanning cleanup */
432 /* Set quantization tables for selected quality. */
433 /* Some or all may be overridden if -qtables is present. */
434 if (qualityarg
!= NULL
) /* process -quality if it was present */
435 if (! set_quality_ratings(cinfo
, qualityarg
, force_baseline
))
438 if (qtablefile
!= NULL
) /* process -qtables if it was present */
439 if (! read_quant_tables(cinfo
, qtablefile
, force_baseline
))
442 if (qslotsarg
!= NULL
) /* process -qslots if it was present */
443 if (! set_quant_slots(cinfo
, qslotsarg
))
446 if (samplearg
!= NULL
) /* process -sample if it was present */
447 if (! set_sample_factors(cinfo
, samplearg
))
450 #ifdef C_PROGRESSIVE_SUPPORTED
451 if (simple_progressive
) /* process -progressive; -scans can override */
452 jpeg_simple_progression(cinfo
);
455 #ifdef C_MULTISCAN_FILES_SUPPORTED
456 if (scansarg
!= NULL
) /* process -scans if it was present */
457 if (! read_scan_script(cinfo
, scansarg
))
462 return argn
; /* return index of next arg (file name) */
471 main (int argc
, char **argv
)
473 struct jpeg_compress_struct cinfo
;
474 struct jpeg_error_mgr jerr
;
475 #ifdef PROGRESS_REPORT
476 struct cdjpeg_progress_mgr progress
;
479 cjpeg_source_ptr src_mgr
;
482 JDIMENSION num_scanlines
;
484 /* On Mac, fetch a command line. */
486 argc
= ccommand(&argv
);
490 if (progname
== NULL
|| progname
[0] == 0)
491 progname
= "cjpeg"; /* in case C library doesn't provide it */
493 /* Initialize the JPEG compression object with default error handling. */
494 cinfo
.err
= jpeg_std_error(&jerr
);
495 jpeg_create_compress(&cinfo
);
496 /* Add some application-specific error messages (from cderror.h) */
497 jerr
.addon_message_table
= cdjpeg_message_table
;
498 jerr
.first_addon_message
= JMSG_FIRSTADDONCODE
;
499 jerr
.last_addon_message
= JMSG_LASTADDONCODE
;
501 /* Now safe to enable signal catcher. */
502 #ifdef NEED_SIGNAL_CATCHER
503 enable_signal_catcher((j_common_ptr
) &cinfo
);
506 /* Initialize JPEG parameters.
507 * Much of this may be overridden later.
508 * In particular, we don't yet know the input file's color space,
509 * but we need to provide some value for jpeg_set_defaults() to work.
512 cinfo
.in_color_space
= JCS_RGB
; /* arbitrary guess */
513 jpeg_set_defaults(&cinfo
);
515 /* Scan command line to find file names.
516 * It is convenient to use just one switch-parsing routine, but the switch
517 * values read here are ignored; we will rescan the switches after opening
521 file_index
= parse_switches(&cinfo
, argc
, argv
, 0, FALSE
);
523 #ifdef TWO_FILE_COMMANDLINE
524 /* Must have either -outfile switch or explicit output file name */
525 if (outfilename
== NULL
) {
526 if (file_index
!= argc
-2) {
527 fprintf(stderr
, "%s: must name one input and one output file\n",
531 outfilename
= argv
[file_index
+1];
533 if (file_index
!= argc
-1) {
534 fprintf(stderr
, "%s: must name one input and one output file\n",
540 /* Unix style: expect zero or one file name */
541 if (file_index
< argc
-1) {
542 fprintf(stderr
, "%s: only one input file\n", progname
);
545 #endif /* TWO_FILE_COMMANDLINE */
547 /* Open the input file. */
548 if (file_index
< argc
) {
549 if ((input_file
= fopen(argv
[file_index
], READ_BINARY
)) == NULL
) {
550 fprintf(stderr
, "%s: can't open %s\n", progname
, argv
[file_index
]);
554 /* default input file is stdin */
555 input_file
= read_stdin();
558 /* Open the output file. */
559 if (outfilename
!= NULL
) {
560 if ((output_file
= fopen(outfilename
, WRITE_BINARY
)) == NULL
) {
561 fprintf(stderr
, "%s: can't open %s\n", progname
, outfilename
);
565 /* default output file is stdout */
566 output_file
= write_stdout();
569 #ifdef PROGRESS_REPORT
570 start_progress_monitor((j_common_ptr
) &cinfo
, &progress
);
573 /* Figure out the input file format, and set up to read it. */
574 src_mgr
= select_file_type(&cinfo
, input_file
);
575 src_mgr
->input_file
= input_file
;
577 /* Read the input file header to obtain file size & colorspace. */
578 (*src_mgr
->start_input
) (&cinfo
, src_mgr
);
580 /* Now that we know input colorspace, fix colorspace-dependent defaults */
581 jpeg_default_colorspace(&cinfo
);
583 /* Adjust default compression parameters by re-parsing the options */
584 file_index
= parse_switches(&cinfo
, argc
, argv
, 0, TRUE
);
586 /* Specify data destination for compression */
587 jpeg_stdio_dest(&cinfo
, output_file
);
589 /* Start compressor */
590 jpeg_start_compress(&cinfo
, TRUE
);
593 while (cinfo
.next_scanline
< cinfo
.image_height
) {
594 num_scanlines
= (*src_mgr
->get_pixel_rows
) (&cinfo
, src_mgr
);
595 (void) jpeg_write_scanlines(&cinfo
, src_mgr
->buffer
, num_scanlines
);
598 /* Finish compression and release memory */
599 (*src_mgr
->finish_input
) (&cinfo
, src_mgr
);
600 jpeg_finish_compress(&cinfo
);
601 jpeg_destroy_compress(&cinfo
);
603 /* Close files, if we opened them */
604 if (input_file
!= stdin
)
606 if (output_file
!= stdout
)
609 #ifdef PROGRESS_REPORT
610 end_progress_monitor((j_common_ptr
) &cinfo
);
614 exit(jerr
.num_warnings
? EXIT_WARNING
: EXIT_SUCCESS
);
615 return 0; /* suppress no-return-value warnings */