ReactOS  0.4.14-dev-376-gaedba84
cjpeg.c
Go to the documentation of this file.
1 /*
2  * cjpeg.c
3  *
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.
8  *
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.
11  *
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.
25  */
26 
27 #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
28 #include "jversion.h" /* for version message */
29 
30 #ifdef USE_CCOMMAND /* command-line reader for Macintosh */
31 #ifdef __MWERKS__
32 #include <SIOUX.h> /* Metrowerks needs this */
33 #include <console.h> /* ... and this */
34 #endif
35 #ifdef THINK_C
36 #include <console.h> /* Think declares it here */
37 #endif
38 #endif
39 
40 
41 /* Create the add-on message string table. */
42 
43 #define JMESSAGE(code,string) string ,
44 
45 static const char * const cdjpeg_message_table[] = {
46 #include "cderror.h"
47  NULL
48 };
49 
50 
51 /*
52  * This routine determines what format the input file is,
53  * and selects the appropriate input-reading module.
54  *
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.
67  *
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.
75  */
76 
77 static boolean is_targa; /* records user -targa switch */
78 
79 
82 {
83  int c;
84 
85  if (is_targa) {
86 #ifdef TARGA_SUPPORTED
87  return jinit_read_targa(cinfo);
88 #else
89  ERREXIT(cinfo, JERR_TGA_NOTCOMP);
90 #endif
91  }
92 
93  if ((c = getc(infile)) == EOF)
94  ERREXIT(cinfo, JERR_INPUT_EMPTY);
95  if (ungetc(c, infile) == EOF)
96  ERREXIT(cinfo, JERR_UNGETC_FAILED);
97 
98  switch (c) {
99 #ifdef BMP_SUPPORTED
100  case 'B':
101  return jinit_read_bmp(cinfo);
102 #endif
103 #ifdef GIF_SUPPORTED
104  case 'G':
105  return jinit_read_gif(cinfo);
106 #endif
107 #ifdef PPM_SUPPORTED
108  case 'P':
109  return jinit_read_ppm(cinfo);
110 #endif
111 #ifdef RLE_SUPPORTED
112  case 'R':
113  return jinit_read_rle(cinfo);
114 #endif
115 #ifdef TARGA_SUPPORTED
116  case 0x00:
117  return jinit_read_targa(cinfo);
118 #endif
119  default:
120  ERREXIT(cinfo, JERR_UNKNOWN_FORMAT);
121  break;
122  }
123 
124  return NULL; /* suppress compiler warnings */
125 }
126 
127 
128 /*
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...
134  */
135 
136 
137 static const char * progname; /* program name for error messages */
138 static char * outfilename; /* for -outfile switch */
139 
140 
141 LOCAL(void)
142 usage (void)
143 /* complain about bad command line */
144 {
145  fprintf(stderr, "usage: %s [switches] ", progname);
146 #ifdef TWO_FILE_COMMANDLINE
147  fprintf(stderr, "inputfile outputfile\n");
148 #else
149  fprintf(stderr, "[inputfile]\n");
150 #endif
151 
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");
158 #endif
159 #ifdef C_PROGRESSIVE_SUPPORTED
160  fprintf(stderr, " -progressive Create progressive JPEG file\n");
161 #endif
162 #ifdef DCT_SCALING_SUPPORTED
163  fprintf(stderr, " -scale M/N Scale image by fraction M/N, eg, 1/2\n");
164 #endif
165 #ifdef TARGA_SUPPORTED
166  fprintf(stderr, " -targa Input file is Targa format (usually not needed)\n");
167 #endif
168  fprintf(stderr, "Switches for advanced users:\n");
169 #ifdef C_ARITH_CODING_SUPPORTED
170  fprintf(stderr, " -arithmetic Use arithmetic coding\n");
171 #endif
172 #ifdef DCT_SCALING_SUPPORTED
173  fprintf(stderr, " -block N DCT block size (1..16; default is 8)\n");
174 #endif
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");
178 #endif
179 #ifdef DCT_ISLOW_SUPPORTED
180  fprintf(stderr, " -dct int Use integer DCT method%s\n",
181  (JDCT_DEFAULT == JDCT_ISLOW ? " (default)" : ""));
182 #endif
183 #ifdef DCT_IFAST_SUPPORTED
184  fprintf(stderr, " -dct fast Use fast integer DCT (less accurate)%s\n",
185  (JDCT_DEFAULT == JDCT_IFAST ? " (default)" : ""));
186 #endif
187 #ifdef DCT_FLOAT_SUPPORTED
188  fprintf(stderr, " -dct float Use floating-point DCT method%s\n",
189  (JDCT_DEFAULT == JDCT_FLOAT ? " (default)" : ""));
190 #endif
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");
195 #endif
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");
206 #endif
208 }
209 
210 
211 LOCAL(int)
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
220  * processing.
221  */
222 {
223  int argn;
224  char * arg;
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 */
232 
233  /* Set up default JPEG parameters. */
234 
235  force_baseline = FALSE; /* by default, allow 16-bit quantizers */
236  simple_progressive = FALSE;
237  is_targa = FALSE;
238  outfilename = NULL;
239  cinfo->err->trace_level = 0;
240 
241  /* Scan command line options, adjust parameters */
242 
243  for (argn = 1; argn < argc; argn++) {
244  arg = argv[argn];
245  if (*arg != '-') {
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 */
250  }
251  break; /* else done parsing switches */
252  }
253  arg++; /* advance past switch marker character */
254 
255  if (keymatch(arg, "arithmetic", 1)) {
256  /* Use arithmetic coding. */
257 #ifdef C_ARITH_CODING_SUPPORTED
258  cinfo->arith_code = TRUE;
259 #else
260  fprintf(stderr, "%s: sorry, arithmetic coding not supported\n",
261  progname);
263 #endif
264 
265  } else if (keymatch(arg, "baseline", 2)) {
266  /* Force baseline-compatible output (8-bit quantizer values). */
268 
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)
273  int val;
274 
275  if (++argn >= argc) /* advance to next argument */
276  usage();
277  if (sscanf(argv[argn], "%d", &val) != 1)
278  usage();
279  if (val < 1 || val > 16)
280  usage();
281  cinfo->block_size = val;
282 #else
283  fprintf(stderr, "%s: sorry, block size setting not supported\n",
284  progname);
286 #endif
287 
288  } else if (keymatch(arg, "dct", 2)) {
289  /* Select DCT algorithm. */
290  if (++argn >= argc) /* advance to next argument */
291  usage();
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;
298  } else
299  usage();
300 
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;
305 
306  if (! printed_version) {
307  fprintf(stderr, "Independent JPEG Group's CJPEG, version %s\n%s\n",
309  printed_version = TRUE;
310  }
311  cinfo->err->trace_level++;
312 
313  } else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) {
314  /* Force a monochrome JPEG file to be generated. */
316 
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.
322  */
323  cinfo->color_transform = arg[3] ? JCT_SUBTRACT_GREEN : JCT_NONE;
324 #endif
326 
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)
332 #else
333  fprintf(stderr, "%s: sorry, BG_YCC colorspace not supported\n",
334  progname);
336 #endif
337 
338  } else if (keymatch(arg, "maxmemory", 3)) {
339  /* Maximum memory in Kb (or Mb with 'm'). */
340  long lval;
341  char ch = 'x';
342 
343  if (++argn >= argc) /* advance to next argument */
344  usage();
345  if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
346  usage();
347  if (ch == 'm' || ch == 'M')
348  lval *= 1000L;
349  cinfo->mem->max_memory_to_use = lval * 1000L;
350 
351  } else if (keymatch(arg, "nosmooth", 3)) {
352  /* Suppress fancy downsampling. */
353  cinfo->do_fancy_downsampling = FALSE;
354 
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;
359 #else
360  fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n",
361  progname);
363 #endif
364 
365  } else if (keymatch(arg, "outfile", 4)) {
366  /* Set output file name. */
367  if (++argn >= argc) /* advance to next argument */
368  usage();
369  outfilename = argv[argn]; /* save it away for later use */
370 
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. */
376 #else
377  fprintf(stderr, "%s: sorry, progressive output was not compiled\n",
378  progname);
380 #endif
381 
382  } else if (keymatch(arg, "quality", 1)) {
383  /* Quality ratings (quantization table scaling factors). */
384  if (++argn >= argc) /* advance to next argument */
385  usage();
386  qualityarg = argv[argn];
387 
388  } else if (keymatch(arg, "qslots", 2)) {
389  /* Quantization table slot numbers. */
390  if (++argn >= argc) /* advance to next argument */
391  usage();
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.
396  */
397 
398  } else if (keymatch(arg, "qtables", 2)) {
399  /* Quantization tables fetched from file. */
400  if (++argn >= argc) /* advance to next argument */
401  usage();
402  qtablefile = argv[argn];
403  /* We postpone actually reading the file in case -quality comes later. */
404 
405  } else if (keymatch(arg, "restart", 1)) {
406  /* Restart interval in MCU rows (or in MCUs with 'b'). */
407  long lval;
408  char ch = 'x';
409 
410  if (++argn >= argc) /* advance to next argument */
411  usage();
412  if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
413  usage();
414  if (lval < 0 || lval > 65535L)
415  usage();
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 */
419  } else {
420  cinfo->restart_in_rows = (int) lval;
421  /* restart_interval will be computed during startup */
422  }
423 
424  } else if (keymatch(arg, "sample", 2)) {
425  /* Set sampling factors. */
426  if (++argn >= argc) /* advance to next argument */
427  usage();
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.
432  */
433 
434  } else if (keymatch(arg, "scale", 4)) {
435  /* Scale the image by a fraction M/N. */
436  if (++argn >= argc) /* advance to next argument */
437  usage();
438  if (sscanf(argv[argn], "%u/%u",
439  &cinfo->scale_num, &cinfo->scale_denom) != 2)
440  usage();
441 
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 */
446  usage();
447  scansarg = argv[argn];
448  /* We must postpone reading the file in case -progressive appears. */
449 #else
450  fprintf(stderr, "%s: sorry, multi-scan output was not compiled\n",
451  progname);
453 #endif
454 
455  } else if (keymatch(arg, "smooth", 2)) {
456  /* Set input smoothing factor. */
457  int val;
458 
459  if (++argn >= argc) /* advance to next argument */
460  usage();
461  if (sscanf(argv[argn], "%d", &val) != 1)
462  usage();
463  if (val < 0 || val > 100)
464  usage();
465  cinfo->smoothing_factor = val;
466 
467  } else if (keymatch(arg, "targa", 1)) {
468  /* Input file is Targa format. */
469  is_targa = TRUE;
470 
471  } else {
472  usage(); /* bogus switch */
473  }
474  }
475 
476  /* Post-switch-scanning cleanup */
477 
478  if (for_real) {
479 
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))
484  usage();
485 
486  if (qtablefile != NULL) /* process -qtables if it was present */
487  if (! read_quant_tables(cinfo, qtablefile, force_baseline))
488  usage();
489 
490  if (qslotsarg != NULL) /* process -qslots if it was present */
491  if (! set_quant_slots(cinfo, qslotsarg))
492  usage();
493 
494  if (samplearg != NULL) /* process -sample if it was present */
495  if (! set_sample_factors(cinfo, samplearg))
496  usage();
497 
498 #ifdef C_PROGRESSIVE_SUPPORTED
499  if (simple_progressive) /* process -progressive; -scans can override */
500  jpeg_simple_progression(cinfo);
501 #endif
502 
503 #ifdef C_MULTISCAN_FILES_SUPPORTED
504  if (scansarg != NULL) /* process -scans if it was present */
505  if (! read_scan_script(cinfo, scansarg))
506  usage();
507 #endif
508  }
509 
510  return argn; /* return index of next arg (file name) */
511 }
512 
513 
514 /*
515  * The main program.
516  */
517 
518 int
519 main (int argc, char **argv)
520 {
521  struct jpeg_compress_struct cinfo;
522  struct jpeg_error_mgr jerr;
523 #ifdef PROGRESS_REPORT
525 #endif
526  int file_index;
527  cjpeg_source_ptr src_mgr;
528  FILE * input_file;
529  FILE * output_file;
530  JDIMENSION num_scanlines;
531 
532  /* On Mac, fetch a command line. */
533 #ifdef USE_CCOMMAND
534  argc = ccommand(&argv);
535 #endif
536 
537  progname = argv[0];
538  if (progname == NULL || progname[0] == 0)
539  progname = "cjpeg"; /* in case C library doesn't provide it */
540 
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) */
546  jerr.first_addon_message = JMSG_FIRSTADDONCODE;
547  jerr.last_addon_message = JMSG_LASTADDONCODE;
548 
549  /* Now safe to enable signal catcher. */
550 #ifdef NEED_SIGNAL_CATCHER
551  enable_signal_catcher((j_common_ptr) &cinfo);
552 #endif
553 
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.
558  */
559 
560  cinfo.in_color_space = JCS_RGB; /* arbitrary guess */
561  jpeg_set_defaults(&cinfo);
562 
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
566  * the input file.
567  */
568 
569  file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
570 
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",
576  progname);
577  usage();
578  }
579  outfilename = argv[file_index+1];
580  } else {
581  if (file_index != argc-1) {
582  fprintf(stderr, "%s: must name one input and one output file\n",
583  progname);
584  usage();
585  }
586  }
587 #else
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);
591  usage();
592  }
593 #endif /* TWO_FILE_COMMANDLINE */
594 
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]);
600  }
601  } else {
602  /* default input file is stdin */
603  input_file = read_stdin();
604  }
605 
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);
611  }
612  } else {
613  /* default output file is stdout */
614  output_file = write_stdout();
615  }
616 
617 #ifdef PROGRESS_REPORT
618  start_progress_monitor((j_common_ptr) &cinfo, &progress);
619 #endif
620 
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;
624 
625  /* Read the input file header to obtain file size & colorspace. */
626  (*src_mgr->start_input) (&cinfo, src_mgr);
627 
628  /* Now that we know input colorspace, fix colorspace-dependent defaults */
629  jpeg_default_colorspace(&cinfo);
630 
631  /* Adjust default compression parameters by re-parsing the options */
632  file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
633 
634  /* Specify data destination for compression */
635  jpeg_stdio_dest(&cinfo, output_file);
636 
637  /* Start compressor */
638  jpeg_start_compress(&cinfo, TRUE);
639 
640  /* Process data */
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);
644  }
645 
646  /* Finish compression and release memory */
647  (*src_mgr->finish_input) (&cinfo, src_mgr);
648  jpeg_finish_compress(&cinfo);
649  jpeg_destroy_compress(&cinfo);
650 
651  /* Close files, if we opened them */
652  if (input_file != stdin)
653  fclose(input_file);
654  if (output_file != stdout)
655  fclose(output_file);
656 
657 #ifdef PROGRESS_REPORT
658  end_progress_monitor((j_common_ptr) &cinfo);
659 #endif
660 
661  /* All done. */
663  return 0; /* suppress no-return-value warnings */
664 }
#define READ_BINARY
Definition: jmemdos.c:77
set_quality_ratings(j_compress_ptr cinfo, char *arg, boolean force_baseline)
Definition: rdswitch.c:268
char boolean force_baseline
Definition: cdjpeg.h:134
jpeg_default_colorspace(j_compress_ptr cinfo)
Definition: jcparam.c:386
static int argc
Definition: ServiceArgs.c:12
long num_warnings
Definition: jpeglib.h:735
#define TRUE
Definition: types.h:120
read_quant_tables(j_compress_ptr cinfo, char *filename, boolean force_baseline)
Definition: rdswitch.c:75
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
jpeg_finish_compress(j_compress_ptr cinfo)
Definition: jcapimin.c:155
int last_addon_message
Definition: jpeglib.h:754
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
static char * outfilename
Definition: cjpeg.c:138
jpeg_destroy_compress(j_compress_ptr cinfo)
Definition: jcapimin.c:96
_Check_return_ _CRTIMP int __cdecl getc(_Inout_ FILE *_File)
static FILE * infile
Definition: rdjpgcom.c:65
FILE * stdin
#define JDCT_DEFAULT
Definition: jpeglib.h:247
void * arg
Definition: msvc.h:12
const char *const * addon_message_table
Definition: jpeglib.h:752
#define argv
Definition: mplay32.c:18
jpeg_stdio_dest(j_compress_ptr cinfo, FILE *outfile)
Definition: jdatadst.c:196
FILE * stdout
read_stdin(void)
Definition: cdjpeg.c:149
jpeg_start_compress(j_compress_ptr cinfo, boolean write_all_tables)
Definition: jcapistd.c:39
static const char * progname
Definition: cjpeg.c:137
#define EXIT_SUCCESS
Definition: rdjpgcom.c:55
select_file_type(j_compress_ptr cinfo, FILE *infile)
Definition: cjpeg.c:81
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#define EXIT_WARNING
Definition: cdjpeg.h:185
#define JCOPYRIGHT
Definition: jversion.h:14
parse_switches(j_compress_ptr cinfo, int argc, char **argv, int last_file_arg_seen, boolean for_real)
Definition: cjpeg.c:212
smooth NULL
Definition: ftsmooth.c:416
_Check_return_opt_ _CRTIMP_ALT int __cdecl ungetc(_In_ int _Ch, _Inout_ FILE *_File)
_Check_return_ _CRTIMP int __cdecl sscanf(_In_z_ const char *_Src, _In_z_ _Scanf_format_string_ const char *_Format,...)
set_sample_factors(j_compress_ptr cinfo, char *arg)
Definition: rdswitch.c:335
keymatch(char *arg, const char *keyword, int minchars)
Definition: cdjpeg.c:122
#define LOCAL(type)
Definition: jmorecfg.h:289
GLuint GLfloat * val
Definition: glext.h:7180
static boolean is_targa
Definition: cjpeg.c:77
int first_addon_message
Definition: jpeglib.h:753
jpeg_write_scanlines(j_compress_ptr cinfo, JSAMPARRAY scanlines, JDIMENSION num_lines)
Definition: jcapistd.c:78
const GLubyte * c
Definition: glext.h:8905
static const char *const cdjpeg_message_table[]
Definition: cjpeg.c:45
#define EXIT_FAILURE
Definition: jerror.c:33
JSAMPARRAY buffer
Definition: cdjpeg.h:36
static const WCHAR L[]
Definition: oid.c:1250
GLsizeiptr const GLvoid GLenum usage
Definition: glext.h:5919
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
#define WRITE_BINARY
Definition: wrjpgcom.c:47
FILE * input_file
Definition: cdjpeg.h:34
int main(int argc, char **argv)
Definition: cjpeg.c:519
jpeg_set_colorspace(j_compress_ptr cinfo, J_COLOR_SPACE colorspace)
Definition: jcparam.c:425
#define jpeg_create_compress(cinfo)
Definition: jpeglib.h:958
usage(void)
Definition: cjpeg.c:142
set_quant_slots(j_compress_ptr cinfo, char *arg)
Definition: rdswitch.c:300
cd_progress_ptr progress
Definition: cdjpeg.h:150
write_stdout(void)
Definition: cdjpeg.c:167
jpeg_set_defaults(j_compress_ptr cinfo)
Definition: jcparam.c:285
#define EOF
Definition: stdio.h:24
jpeg_std_error(struct jpeg_error_mgr *err)
Definition: jerror.c:232
unsigned int JDIMENSION
Definition: jmorecfg.h:229
#define c
Definition: ke_i.h:80
FILE * stderr
void exit(int exitcode)
Definition: _exit.c:33
#define JVERSION
Definition: jversion.h:12
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31