#include "cdjpeg.h"
#include "jversion.h"
#include "cderror.h"
Go to the source code of this file.
Defines | |
#define | JMESSAGE(code, string) string , |
Functions | |
int | main (int argc, char **argv) |
parse_switches (j_compress_ptr cinfo, int argc, char **argv, int last_file_arg_seen, boolean for_real) | |
select_file_type (j_compress_ptr cinfo, FILE *infile) | |
usage (void) | |
Variables | |
static const char *const | cdjpeg_message_table [] |
static boolean | is_targa |
static char * | outfilename |
static const char * | progname |
int main | ( | int | argc, | |
char ** | argv | |||
) |
Definition at line 461 of file cjpeg.c.
References jpeg_error_mgr::addon_message_table, cjpeg_source_struct::buffer, cdjpeg_message_table, EXIT_FAILURE, EXIT_SUCCESS, EXIT_WARNING, FALSE, jpeg_error_mgr::first_addon_message, cjpeg_source_struct::input_file, JCS_RGB, jpeg_create_compress, jpeg_default_colorspace(), jpeg_destroy_compress(), jpeg_finish_compress(), jpeg_set_defaults(), jpeg_start_compress(), jpeg_std_error(), jpeg_stdio_dest(), jpeg_write_scanlines(), jpeg_error_mgr::last_addon_message, jpeg_error_mgr::num_warnings, outfilename, parse_switches(), progname, READ_BINARY, read_stdin(), select_file_type(), TRUE, usage(), WRITE_BINARY, and write_stdout().
00462 { 00463 struct jpeg_compress_struct cinfo; 00464 struct jpeg_error_mgr jerr; 00465 #ifdef PROGRESS_REPORT 00466 struct cdjpeg_progress_mgr progress; 00467 #endif 00468 int file_index; 00469 cjpeg_source_ptr src_mgr; 00470 FILE * input_file; 00471 FILE * output_file; 00472 JDIMENSION num_scanlines; 00473 00474 /* On Mac, fetch a command line. */ 00475 #ifdef USE_CCOMMAND 00476 argc = ccommand(&argv); 00477 #endif 00478 00479 progname = argv[0]; 00480 if (progname == NULL || progname[0] == 0) 00481 progname = "cjpeg"; /* in case C library doesn't provide it */ 00482 00483 /* Initialize the JPEG compression object with default error handling. */ 00484 cinfo.err = jpeg_std_error(&jerr); 00485 jpeg_create_compress(&cinfo); 00486 /* Add some application-specific error messages (from cderror.h) */ 00487 jerr.addon_message_table = cdjpeg_message_table; 00488 jerr.first_addon_message = JMSG_FIRSTADDONCODE; 00489 jerr.last_addon_message = JMSG_LASTADDONCODE; 00490 00491 /* Now safe to enable signal catcher. */ 00492 #ifdef NEED_SIGNAL_CATCHER 00493 enable_signal_catcher((j_common_ptr) &cinfo); 00494 #endif 00495 00496 /* Initialize JPEG parameters. 00497 * Much of this may be overridden later. 00498 * In particular, we don't yet know the input file's color space, 00499 * but we need to provide some value for jpeg_set_defaults() to work. 00500 */ 00501 00502 cinfo.in_color_space = JCS_RGB; /* arbitrary guess */ 00503 jpeg_set_defaults(&cinfo); 00504 00505 /* Scan command line to find file names. 00506 * It is convenient to use just one switch-parsing routine, but the switch 00507 * values read here are ignored; we will rescan the switches after opening 00508 * the input file. 00509 */ 00510 00511 file_index = parse_switches(&cinfo, argc, argv, 0, FALSE); 00512 00513 #ifdef TWO_FILE_COMMANDLINE 00514 /* Must have either -outfile switch or explicit output file name */ 00515 if (outfilename == NULL) { 00516 if (file_index != argc-2) { 00517 fprintf(stderr, "%s: must name one input and one output file\n", 00518 progname); 00519 usage(); 00520 } 00521 outfilename = argv[file_index+1]; 00522 } else { 00523 if (file_index != argc-1) { 00524 fprintf(stderr, "%s: must name one input and one output file\n", 00525 progname); 00526 usage(); 00527 } 00528 } 00529 #else 00530 /* Unix style: expect zero or one file name */ 00531 if (file_index < argc-1) { 00532 fprintf(stderr, "%s: only one input file\n", progname); 00533 usage(); 00534 } 00535 #endif /* TWO_FILE_COMMANDLINE */ 00536 00537 /* Open the input file. */ 00538 if (file_index < argc) { 00539 if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) { 00540 fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]); 00541 exit(EXIT_FAILURE); 00542 } 00543 } else { 00544 /* default input file is stdin */ 00545 input_file = read_stdin(); 00546 } 00547 00548 /* Open the output file. */ 00549 if (outfilename != NULL) { 00550 if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) { 00551 fprintf(stderr, "%s: can't open %s\n", progname, outfilename); 00552 exit(EXIT_FAILURE); 00553 } 00554 } else { 00555 /* default output file is stdout */ 00556 output_file = write_stdout(); 00557 } 00558 00559 #ifdef PROGRESS_REPORT 00560 start_progress_monitor((j_common_ptr) &cinfo, &progress); 00561 #endif 00562 00563 /* Figure out the input file format, and set up to read it. */ 00564 src_mgr = select_file_type(&cinfo, input_file); 00565 src_mgr->input_file = input_file; 00566 00567 /* Read the input file header to obtain file size & colorspace. */ 00568 (*src_mgr->start_input) (&cinfo, src_mgr); 00569 00570 /* Now that we know input colorspace, fix colorspace-dependent defaults */ 00571 jpeg_default_colorspace(&cinfo); 00572 00573 /* Adjust default compression parameters by re-parsing the options */ 00574 file_index = parse_switches(&cinfo, argc, argv, 0, TRUE); 00575 00576 /* Specify data destination for compression */ 00577 jpeg_stdio_dest(&cinfo, output_file); 00578 00579 /* Start compressor */ 00580 jpeg_start_compress(&cinfo, TRUE); 00581 00582 /* Process data */ 00583 while (cinfo.next_scanline < cinfo.image_height) { 00584 num_scanlines = (*src_mgr->get_pixel_rows) (&cinfo, src_mgr); 00585 (void) jpeg_write_scanlines(&cinfo, src_mgr->buffer, num_scanlines); 00586 } 00587 00588 /* Finish compression and release memory */ 00589 (*src_mgr->finish_input) (&cinfo, src_mgr); 00590 jpeg_finish_compress(&cinfo); 00591 jpeg_destroy_compress(&cinfo); 00592 00593 /* Close files, if we opened them */ 00594 if (input_file != stdin) 00595 fclose(input_file); 00596 if (output_file != stdout) 00597 fclose(output_file); 00598 00599 #ifdef PROGRESS_REPORT 00600 end_progress_monitor((j_common_ptr) &cinfo); 00601 #endif 00602 00603 /* All done. */ 00604 exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS); 00605 return 0; /* suppress no-return-value warnings */ 00606 }
parse_switches | ( | j_compress_ptr | cinfo, | |
int | argc, | |||
char ** | argv, | |||
int | last_file_arg_seen, | |||
boolean | for_real | |||
) |
Definition at line 199 of file cjpeg.c.
References arg, EXIT_FAILURE, FALSE, force_baseline, is_targa, JCOPYRIGHT, JCS_GRAYSCALE, JDCT_FLOAT, JDCT_IFAST, JDCT_ISLOW, jpeg_quality_scaling(), jpeg_set_colorspace(), jpeg_set_quality(), JVERSION, keymatch(), outfilename, progname, quality, read_quant_tables(), set_quant_slots(), set_sample_factors(), TRUE, usage(), and val.
Referenced by main().
00209 { 00210 int argn; 00211 char * arg; 00212 int quality; /* -quality parameter */ 00213 int q_scale_factor; /* scaling percentage for -qtables */ 00214 boolean force_baseline; 00215 boolean simple_progressive; 00216 char * qtablefile = NULL; /* saves -qtables filename if any */ 00217 char * qslotsarg = NULL; /* saves -qslots parm if any */ 00218 char * samplearg = NULL; /* saves -sample parm if any */ 00219 char * scansarg = NULL; /* saves -scans parm if any */ 00220 00221 /* Set up default JPEG parameters. */ 00222 /* Note that default -quality level need not, and does not, 00223 * match the default scaling for an explicit -qtables argument. 00224 */ 00225 quality = 75; /* default -quality value */ 00226 q_scale_factor = 100; /* default to no scaling for -qtables */ 00227 force_baseline = FALSE; /* by default, allow 16-bit quantizers */ 00228 simple_progressive = FALSE; 00229 is_targa = FALSE; 00230 outfilename = NULL; 00231 cinfo->err->trace_level = 0; 00232 00233 /* Scan command line options, adjust parameters */ 00234 00235 for (argn = 1; argn < argc; argn++) { 00236 arg = argv[argn]; 00237 if (*arg != '-') { 00238 /* Not a switch, must be a file name argument */ 00239 if (argn <= last_file_arg_seen) { 00240 outfilename = NULL; /* -outfile applies to just one input file */ 00241 continue; /* ignore this name if previously processed */ 00242 } 00243 break; /* else done parsing switches */ 00244 } 00245 arg++; /* advance past switch marker character */ 00246 00247 if (keymatch(arg, "arithmetic", 1)) { 00248 /* Use arithmetic coding. */ 00249 #ifdef C_ARITH_CODING_SUPPORTED 00250 cinfo->arith_code = TRUE; 00251 #else 00252 fprintf(stderr, "%s: sorry, arithmetic coding not supported\n", 00253 progname); 00254 exit(EXIT_FAILURE); 00255 #endif 00256 00257 } else if (keymatch(arg, "baseline", 1)) { 00258 /* Force baseline-compatible output (8-bit quantizer values). */ 00259 force_baseline = TRUE; 00260 00261 } else if (keymatch(arg, "dct", 2)) { 00262 /* Select DCT algorithm. */ 00263 if (++argn >= argc) /* advance to next argument */ 00264 usage(); 00265 if (keymatch(argv[argn], "int", 1)) { 00266 cinfo->dct_method = JDCT_ISLOW; 00267 } else if (keymatch(argv[argn], "fast", 2)) { 00268 cinfo->dct_method = JDCT_IFAST; 00269 } else if (keymatch(argv[argn], "float", 2)) { 00270 cinfo->dct_method = JDCT_FLOAT; 00271 } else 00272 usage(); 00273 00274 } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) { 00275 /* Enable debug printouts. */ 00276 /* On first -d, print version identification */ 00277 static boolean printed_version = FALSE; 00278 00279 if (! printed_version) { 00280 fprintf(stderr, "Independent JPEG Group's CJPEG, version %s\n%s\n", 00281 JVERSION, JCOPYRIGHT); 00282 printed_version = TRUE; 00283 } 00284 cinfo->err->trace_level++; 00285 00286 } else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) { 00287 /* Force a monochrome JPEG file to be generated. */ 00288 jpeg_set_colorspace(cinfo, JCS_GRAYSCALE); 00289 00290 } else if (keymatch(arg, "maxmemory", 3)) { 00291 /* Maximum memory in Kb (or Mb with 'm'). */ 00292 long lval; 00293 char ch = 'x'; 00294 00295 if (++argn >= argc) /* advance to next argument */ 00296 usage(); 00297 if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1) 00298 usage(); 00299 if (ch == 'm' || ch == 'M') 00300 lval *= 1000L; 00301 cinfo->mem->max_memory_to_use = lval * 1000L; 00302 00303 } else if (keymatch(arg, "optimize", 1) || keymatch(arg, "optimise", 1)) { 00304 /* Enable entropy parm optimization. */ 00305 #ifdef ENTROPY_OPT_SUPPORTED 00306 cinfo->optimize_coding = TRUE; 00307 #else 00308 fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n", 00309 progname); 00310 exit(EXIT_FAILURE); 00311 #endif 00312 00313 } else if (keymatch(arg, "outfile", 4)) { 00314 /* Set output file name. */ 00315 if (++argn >= argc) /* advance to next argument */ 00316 usage(); 00317 outfilename = argv[argn]; /* save it away for later use */ 00318 00319 } else if (keymatch(arg, "progressive", 1)) { 00320 /* Select simple progressive mode. */ 00321 #ifdef C_PROGRESSIVE_SUPPORTED 00322 simple_progressive = TRUE; 00323 /* We must postpone execution until num_components is known. */ 00324 #else 00325 fprintf(stderr, "%s: sorry, progressive output was not compiled\n", 00326 progname); 00327 exit(EXIT_FAILURE); 00328 #endif 00329 00330 } else if (keymatch(arg, "quality", 1)) { 00331 /* Quality factor (quantization table scaling factor). */ 00332 if (++argn >= argc) /* advance to next argument */ 00333 usage(); 00334 if (sscanf(argv[argn], "%d", &quality) != 1) 00335 usage(); 00336 /* Change scale factor in case -qtables is present. */ 00337 q_scale_factor = jpeg_quality_scaling(quality); 00338 00339 } else if (keymatch(arg, "qslots", 2)) { 00340 /* Quantization table slot numbers. */ 00341 if (++argn >= argc) /* advance to next argument */ 00342 usage(); 00343 qslotsarg = argv[argn]; 00344 /* Must delay setting qslots until after we have processed any 00345 * colorspace-determining switches, since jpeg_set_colorspace sets 00346 * default quant table numbers. 00347 */ 00348 00349 } else if (keymatch(arg, "qtables", 2)) { 00350 /* Quantization tables fetched from file. */ 00351 if (++argn >= argc) /* advance to next argument */ 00352 usage(); 00353 qtablefile = argv[argn]; 00354 /* We postpone actually reading the file in case -quality comes later. */ 00355 00356 } else if (keymatch(arg, "restart", 1)) { 00357 /* Restart interval in MCU rows (or in MCUs with 'b'). */ 00358 long lval; 00359 char ch = 'x'; 00360 00361 if (++argn >= argc) /* advance to next argument */ 00362 usage(); 00363 if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1) 00364 usage(); 00365 if (lval < 0 || lval > 65535L) 00366 usage(); 00367 if (ch == 'b' || ch == 'B') { 00368 cinfo->restart_interval = (unsigned int) lval; 00369 cinfo->restart_in_rows = 0; /* else prior '-restart n' overrides me */ 00370 } else { 00371 cinfo->restart_in_rows = (int) lval; 00372 /* restart_interval will be computed during startup */ 00373 } 00374 00375 } else if (keymatch(arg, "sample", 2)) { 00376 /* Set sampling factors. */ 00377 if (++argn >= argc) /* advance to next argument */ 00378 usage(); 00379 samplearg = argv[argn]; 00380 /* Must delay setting sample factors until after we have processed any 00381 * colorspace-determining switches, since jpeg_set_colorspace sets 00382 * default sampling factors. 00383 */ 00384 00385 } else if (keymatch(arg, "scans", 2)) { 00386 /* Set scan script. */ 00387 #ifdef C_MULTISCAN_FILES_SUPPORTED 00388 if (++argn >= argc) /* advance to next argument */ 00389 usage(); 00390 scansarg = argv[argn]; 00391 /* We must postpone reading the file in case -progressive appears. */ 00392 #else 00393 fprintf(stderr, "%s: sorry, multi-scan output was not compiled\n", 00394 progname); 00395 exit(EXIT_FAILURE); 00396 #endif 00397 00398 } else if (keymatch(arg, "smooth", 2)) { 00399 /* Set input smoothing factor. */ 00400 int val; 00401 00402 if (++argn >= argc) /* advance to next argument */ 00403 usage(); 00404 if (sscanf(argv[argn], "%d", &val) != 1) 00405 usage(); 00406 if (val < 0 || val > 100) 00407 usage(); 00408 cinfo->smoothing_factor = val; 00409 00410 } else if (keymatch(arg, "targa", 1)) { 00411 /* Input file is Targa format. */ 00412 is_targa = TRUE; 00413 00414 } else { 00415 usage(); /* bogus switch */ 00416 } 00417 } 00418 00419 /* Post-switch-scanning cleanup */ 00420 00421 if (for_real) { 00422 00423 /* Set quantization tables for selected quality. */ 00424 /* Some or all may be overridden if -qtables is present. */ 00425 jpeg_set_quality(cinfo, quality, force_baseline); 00426 00427 if (qtablefile != NULL) /* process -qtables if it was present */ 00428 if (! read_quant_tables(cinfo, qtablefile, 00429 q_scale_factor, force_baseline)) 00430 usage(); 00431 00432 if (qslotsarg != NULL) /* process -qslots if it was present */ 00433 if (! set_quant_slots(cinfo, qslotsarg)) 00434 usage(); 00435 00436 if (samplearg != NULL) /* process -sample if it was present */ 00437 if (! set_sample_factors(cinfo, samplearg)) 00438 usage(); 00439 00440 #ifdef C_PROGRESSIVE_SUPPORTED 00441 if (simple_progressive) /* process -progressive; -scans can override */ 00442 jpeg_simple_progression(cinfo); 00443 #endif 00444 00445 #ifdef C_MULTISCAN_FILES_SUPPORTED 00446 if (scansarg != NULL) /* process -scans if it was present */ 00447 if (! read_scan_script(cinfo, scansarg)) 00448 usage(); 00449 #endif 00450 } 00451 00452 return argn; /* return index of next arg (file name) */ 00453 }
select_file_type | ( | j_compress_ptr | cinfo, | |
FILE * | infile | |||
) |
Definition at line 80 of file cjpeg.c.
References ERREXIT, and is_targa.
Referenced by main().
00081 { 00082 int c; 00083 00084 if (is_targa) { 00085 #ifdef TARGA_SUPPORTED 00086 return jinit_read_targa(cinfo); 00087 #else 00088 ERREXIT(cinfo, JERR_TGA_NOTCOMP); 00089 #endif 00090 } 00091 00092 if ((c = getc(infile)) == EOF) 00093 ERREXIT(cinfo, JERR_INPUT_EMPTY); 00094 if (ungetc(c, infile) == EOF) 00095 ERREXIT(cinfo, JERR_UNGETC_FAILED); 00096 00097 switch (c) { 00098 #ifdef BMP_SUPPORTED 00099 case 'B': 00100 return jinit_read_bmp(cinfo); 00101 #endif 00102 #ifdef GIF_SUPPORTED 00103 case 'G': 00104 return jinit_read_gif(cinfo); 00105 #endif 00106 #ifdef PPM_SUPPORTED 00107 case 'P': 00108 return jinit_read_ppm(cinfo); 00109 #endif 00110 #ifdef RLE_SUPPORTED 00111 case 'R': 00112 return jinit_read_rle(cinfo); 00113 #endif 00114 #ifdef TARGA_SUPPORTED 00115 case 0x00: 00116 return jinit_read_targa(cinfo); 00117 #endif 00118 default: 00119 ERREXIT(cinfo, JERR_UNKNOWN_FORMAT); 00120 break; 00121 } 00122 00123 return NULL; /* suppress compiler warnings */ 00124 }
usage | ( | void | ) |
Definition at line 141 of file cjpeg.c.
References EXIT_FAILURE, JDCT_DEFAULT, JDCT_FLOAT, JDCT_IFAST, JDCT_ISLOW, and progname.
Referenced by main(), parse_switches(), and select_transform().
00143 { 00144 fprintf(stderr, "usage: %s [switches] ", progname); 00145 #ifdef TWO_FILE_COMMANDLINE 00146 fprintf(stderr, "inputfile outputfile\n"); 00147 #else 00148 fprintf(stderr, "[inputfile]\n"); 00149 #endif 00150 00151 fprintf(stderr, "Switches (names may be abbreviated):\n"); 00152 fprintf(stderr, " -quality N Compression quality (0..100; 5-95 is useful range)\n"); 00153 fprintf(stderr, " -grayscale Create monochrome JPEG file\n"); 00154 #ifdef ENTROPY_OPT_SUPPORTED 00155 fprintf(stderr, " -optimize Optimize Huffman table (smaller file, but slow compression)\n"); 00156 #endif 00157 #ifdef C_PROGRESSIVE_SUPPORTED 00158 fprintf(stderr, " -progressive Create progressive JPEG file\n"); 00159 #endif 00160 #ifdef TARGA_SUPPORTED 00161 fprintf(stderr, " -targa Input file is Targa format (usually not needed)\n"); 00162 #endif 00163 fprintf(stderr, "Switches for advanced users:\n"); 00164 #ifdef DCT_ISLOW_SUPPORTED 00165 fprintf(stderr, " -dct int Use integer DCT method%s\n", 00166 (JDCT_DEFAULT == JDCT_ISLOW ? " (default)" : "")); 00167 #endif 00168 #ifdef DCT_IFAST_SUPPORTED 00169 fprintf(stderr, " -dct fast Use fast integer DCT (less accurate)%s\n", 00170 (JDCT_DEFAULT == JDCT_IFAST ? " (default)" : "")); 00171 #endif 00172 #ifdef DCT_FLOAT_SUPPORTED 00173 fprintf(stderr, " -dct float Use floating-point DCT method%s\n", 00174 (JDCT_DEFAULT == JDCT_FLOAT ? " (default)" : "")); 00175 #endif 00176 fprintf(stderr, " -restart N Set restart interval in rows, or in blocks with B\n"); 00177 #ifdef INPUT_SMOOTHING_SUPPORTED 00178 fprintf(stderr, " -smooth N Smooth dithered input (N=1..100 is strength)\n"); 00179 #endif 00180 fprintf(stderr, " -maxmemory N Maximum memory to use (in kbytes)\n"); 00181 fprintf(stderr, " -outfile name Specify name for output file\n"); 00182 fprintf(stderr, " -verbose or -debug Emit debug output\n"); 00183 fprintf(stderr, "Switches for wizards:\n"); 00184 #ifdef C_ARITH_CODING_SUPPORTED 00185 fprintf(stderr, " -arithmetic Use arithmetic coding\n"); 00186 #endif 00187 fprintf(stderr, " -baseline Force baseline quantization tables\n"); 00188 fprintf(stderr, " -qtables file Use quantization tables given in file\n"); 00189 fprintf(stderr, " -qslots N[,...] Set component quantization tables\n"); 00190 fprintf(stderr, " -sample HxV[,...] Set component sampling factors\n"); 00191 #ifdef C_MULTISCAN_FILES_SUPPORTED 00192 fprintf(stderr, " -scans file Create multi-scan JPEG per script file\n"); 00193 #endif 00194 exit(EXIT_FAILURE); 00195 }
const char* const cdjpeg_message_table[] [static] |
char* outfilename [static] |
const char* progname [static] |
Definition at line 136 of file cjpeg.c.
Referenced by main(), parse_switches(), select_transform(), and usage().