Visualization Library 2.0.0-b5

A lightweight C++ OpenGL middleware for 2D/3D graphics

VL     Star     Watch     Fork     Issue

[Download] [Tutorials] [All Classes] [Grouped Classes]
djpeg.c
Go to the documentation of this file.
1 /*
2  * djpeg.c
3  *
4  * Copyright (C) 1991-1997, Thomas G. Lane.
5  * This file is part of the Independent JPEG Group's software.
6  * For conditions of distribution and use, see the accompanying README file.
7  *
8  * This file contains a command-line user interface for the JPEG decompressor.
9  * It should work on any system with Unix- or MS-DOS-style command lines.
10  *
11  * Two different command line styles are permitted, depending on the
12  * compile-time switch TWO_FILE_COMMANDLINE:
13  * djpeg [options] inputfile outputfile
14  * djpeg [options] [inputfile]
15  * In the second style, output is always to standard output, which you'd
16  * normally redirect to a file or pipe to some other program. Input is
17  * either from a named file or from standard input (typically redirected).
18  * The second style is convenient on Unix but is unhelpful on systems that
19  * don't support pipes. Also, you MUST use the first style if your system
20  * doesn't do binary I/O to stdin/stdout.
21  * To simplify script writing, the "-outfile" switch is provided. The syntax
22  * djpeg [options] -outfile outputfile inputfile
23  * works regardless of which command line style is used.
24  */
25 
26 #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
27 #include "jversion.h" /* for version message */
28 
29 #include <ctype.h> /* to declare isprint() */
30 
31 #ifdef USE_CCOMMAND /* command-line reader for Macintosh */
32 #ifdef __MWERKS__
33 #include <SIOUX.h> /* Metrowerks needs this */
34 #include <console.h> /* ... and this */
35 #endif
36 #ifdef THINK_C
37 #include <console.h> /* Think declares it here */
38 #endif
39 #endif
40 
41 
42 /* Create the add-on message string table. */
43 
44 #define JMESSAGE(code,string) string ,
45 
46 static const char * const cdjpeg_message_table[] = {
47 #include "cderror.h"
48  NULL
49 };
50 
51 
52 /*
53  * This list defines the known output image formats
54  * (not all of which need be supported by a given version).
55  * You can change the default output format by defining DEFAULT_FMT;
56  * indeed, you had better do so if you undefine PPM_SUPPORTED.
57  */
58 
59 typedef enum {
60  FMT_BMP, /* BMP format (Windows flavor) */
61  FMT_GIF, /* GIF format */
62  FMT_OS2, /* BMP format (OS/2 flavor) */
63  FMT_PPM, /* PPM/PGM (PBMPLUS formats) */
64  FMT_RLE, /* RLE format */
65  FMT_TARGA, /* Targa format */
66  FMT_TIFF /* TIFF format */
68 
69 #ifndef DEFAULT_FMT /* so can override from CFLAGS in Makefile */
70 #define DEFAULT_FMT FMT_PPM
71 #endif
72 
73 static IMAGE_FORMATS requested_fmt;
74 
75 
76 /*
77  * Argument-parsing code.
78  * The switch parser is designed to be useful with DOS-style command line
79  * syntax, ie, intermixed switches and file names, where only the switches
80  * to the left of a given file name affect processing of that file.
81  * The main program in this file doesn't actually use this capability...
82  */
83 
84 
85 static const char * progname; /* program name for error messages */
86 static char * outfilename; /* for -outfile switch */
87 
88 
89 LOCAL(void)
90 usage (void)
91 /* complain about bad command line */
92 {
93  fprintf(stderr, "usage: %s [switches] ", progname);
94 #ifdef TWO_FILE_COMMANDLINE
95  fprintf(stderr, "inputfile outputfile\n");
96 #else
97  fprintf(stderr, "[inputfile]\n");
98 #endif
99 
100  fprintf(stderr, "Switches (names may be abbreviated):\n");
101  fprintf(stderr, " -colors N Reduce image to no more than N colors\n");
102  fprintf(stderr, " -fast Fast, low-quality processing\n");
103  fprintf(stderr, " -grayscale Force grayscale output\n");
104 #ifdef IDCT_SCALING_SUPPORTED
105  fprintf(stderr, " -scale M/N Scale output image by fraction M/N, eg, 1/8\n");
106 #endif
107 #ifdef BMP_SUPPORTED
108  fprintf(stderr, " -bmp Select BMP output format (Windows style)%s\n",
109  (DEFAULT_FMT == FMT_BMP ? " (default)" : ""));
110 #endif
111 #ifdef GIF_SUPPORTED
112  fprintf(stderr, " -gif Select GIF output format%s\n",
113  (DEFAULT_FMT == FMT_GIF ? " (default)" : ""));
114 #endif
115 #ifdef BMP_SUPPORTED
116  fprintf(stderr, " -os2 Select BMP output format (OS/2 style)%s\n",
117  (DEFAULT_FMT == FMT_OS2 ? " (default)" : ""));
118 #endif
119 #ifdef PPM_SUPPORTED
120  fprintf(stderr, " -pnm Select PBMPLUS (PPM/PGM) output format%s\n",
121  (DEFAULT_FMT == FMT_PPM ? " (default)" : ""));
122 #endif
123 #ifdef RLE_SUPPORTED
124  fprintf(stderr, " -rle Select Utah RLE output format%s\n",
125  (DEFAULT_FMT == FMT_RLE ? " (default)" : ""));
126 #endif
127 #ifdef TARGA_SUPPORTED
128  fprintf(stderr, " -targa Select Targa output format%s\n",
129  (DEFAULT_FMT == FMT_TARGA ? " (default)" : ""));
130 #endif
131  fprintf(stderr, "Switches for advanced users:\n");
132 #ifdef DCT_ISLOW_SUPPORTED
133  fprintf(stderr, " -dct int Use integer DCT method%s\n",
134  (JDCT_DEFAULT == JDCT_ISLOW ? " (default)" : ""));
135 #endif
136 #ifdef DCT_IFAST_SUPPORTED
137  fprintf(stderr, " -dct fast Use fast integer DCT (less accurate)%s\n",
138  (JDCT_DEFAULT == JDCT_IFAST ? " (default)" : ""));
139 #endif
140 #ifdef DCT_FLOAT_SUPPORTED
141  fprintf(stderr, " -dct float Use floating-point DCT method%s\n",
142  (JDCT_DEFAULT == JDCT_FLOAT ? " (default)" : ""));
143 #endif
144  fprintf(stderr, " -dither fs Use F-S dithering (default)\n");
145  fprintf(stderr, " -dither none Don't use dithering in quantization\n");
146  fprintf(stderr, " -dither ordered Use ordered dither (medium speed, quality)\n");
147 #ifdef QUANT_2PASS_SUPPORTED
148  fprintf(stderr, " -map FILE Map to colors used in named image file\n");
149 #endif
150  fprintf(stderr, " -nosmooth Don't use high-quality upsampling\n");
151 #ifdef QUANT_1PASS_SUPPORTED
152  fprintf(stderr, " -onepass Use 1-pass quantization (fast, low quality)\n");
153 #endif
154  fprintf(stderr, " -maxmemory N Maximum memory to use (in kbytes)\n");
155  fprintf(stderr, " -outfile name Specify name for output file\n");
156  fprintf(stderr, " -verbose or -debug Emit debug output\n");
157  exit(EXIT_FAILURE);
158 }
159 
160 
161 LOCAL(int)
162 parse_switches (j_decompress_ptr cinfo, int argc, char **argv,
163  int last_file_arg_seen, boolean for_real)
164 /* Parse optional switches.
165  * Returns argv[] index of first file-name argument (== argc if none).
166  * Any file names with indexes <= last_file_arg_seen are ignored;
167  * they have presumably been processed in a previous iteration.
168  * (Pass 0 for last_file_arg_seen on the first or only iteration.)
169  * for_real is FALSE on the first (dummy) pass; we may skip any expensive
170  * processing.
171  */
172 {
173  int argn;
174  char * arg;
175 
176  /* Set up default JPEG parameters. */
177  requested_fmt = DEFAULT_FMT; /* set default output file format */
178  outfilename = NULL;
179  cinfo->err->trace_level = 0;
180 
181  /* Scan command line options, adjust parameters */
182 
183  for (argn = 1; argn < argc; argn++) {
184  arg = argv[argn];
185  if (*arg != '-') {
186  /* Not a switch, must be a file name argument */
187  if (argn <= last_file_arg_seen) {
188  outfilename = NULL; /* -outfile applies to just one input file */
189  continue; /* ignore this name if previously processed */
190  }
191  break; /* else done parsing switches */
192  }
193  arg++; /* advance past switch marker character */
194 
195  if (keymatch(arg, "bmp", 1)) {
196  /* BMP output format. */
197  requested_fmt = FMT_BMP;
198 
199  } else if (keymatch(arg, "colors", 1) || keymatch(arg, "colours", 1) ||
200  keymatch(arg, "quantize", 1) || keymatch(arg, "quantise", 1)) {
201  /* Do color quantization. */
202  int val;
203 
204  if (++argn >= argc) /* advance to next argument */
205  usage();
206  if (sscanf(argv[argn], "%d", &val) != 1)
207  usage();
208  cinfo->desired_number_of_colors = val;
209  cinfo->quantize_colors = TRUE;
210 
211  } else if (keymatch(arg, "dct", 2)) {
212  /* Select IDCT algorithm. */
213  if (++argn >= argc) /* advance to next argument */
214  usage();
215  if (keymatch(argv[argn], "int", 1)) {
216  cinfo->dct_method = JDCT_ISLOW;
217  } else if (keymatch(argv[argn], "fast", 2)) {
218  cinfo->dct_method = JDCT_IFAST;
219  } else if (keymatch(argv[argn], "float", 2)) {
220  cinfo->dct_method = JDCT_FLOAT;
221  } else
222  usage();
223 
224  } else if (keymatch(arg, "dither", 2)) {
225  /* Select dithering algorithm. */
226  if (++argn >= argc) /* advance to next argument */
227  usage();
228  if (keymatch(argv[argn], "fs", 2)) {
229  cinfo->dither_mode = JDITHER_FS;
230  } else if (keymatch(argv[argn], "none", 2)) {
231  cinfo->dither_mode = JDITHER_NONE;
232  } else if (keymatch(argv[argn], "ordered", 2)) {
233  cinfo->dither_mode = JDITHER_ORDERED;
234  } else
235  usage();
236 
237  } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {
238  /* Enable debug printouts. */
239  /* On first -d, print version identification */
240  static boolean printed_version = FALSE;
241 
242  if (! printed_version) {
243  fprintf(stderr, "Independent JPEG Group's DJPEG, version %s\n%s\n",
245  printed_version = TRUE;
246  }
247  cinfo->err->trace_level++;
248 
249  } else if (keymatch(arg, "fast", 1)) {
250  /* Select recommended processing options for quick-and-dirty output. */
251  cinfo->two_pass_quantize = FALSE;
252  cinfo->dither_mode = JDITHER_ORDERED;
253  if (! cinfo->quantize_colors) /* don't override an earlier -colors */
254  cinfo->desired_number_of_colors = 216;
255  cinfo->dct_method = JDCT_FASTEST;
256  cinfo->do_fancy_upsampling = FALSE;
257 
258  } else if (keymatch(arg, "gif", 1)) {
259  /* GIF output format. */
260  requested_fmt = FMT_GIF;
261 
262  } else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) {
263  /* Force monochrome output. */
264  cinfo->out_color_space = JCS_GRAYSCALE;
265 
266  } else if (keymatch(arg, "map", 3)) {
267  /* Quantize to a color map taken from an input file. */
268  if (++argn >= argc) /* advance to next argument */
269  usage();
270  if (for_real) { /* too expensive to do twice! */
271 #ifdef QUANT_2PASS_SUPPORTED /* otherwise can't quantize to supplied map */
272  FILE * mapfile;
273 
274  if ((mapfile = fopen(argv[argn], READ_BINARY)) == NULL) {
275  fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]);
276  exit(EXIT_FAILURE);
277  }
278  read_color_map(cinfo, mapfile);
279  fclose(mapfile);
280  cinfo->quantize_colors = TRUE;
281 #else
282  ERREXIT(cinfo, JERR_NOT_COMPILED);
283 #endif
284  }
285 
286  } else if (keymatch(arg, "maxmemory", 3)) {
287  /* Maximum memory in Kb (or Mb with 'm'). */
288  long lval;
289  char ch = 'x';
290 
291  if (++argn >= argc) /* advance to next argument */
292  usage();
293  if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
294  usage();
295  if (ch == 'm' || ch == 'M')
296  lval *= 1000L;
297  cinfo->mem->max_memory_to_use = lval * 1000L;
298 
299  } else if (keymatch(arg, "nosmooth", 3)) {
300  /* Suppress fancy upsampling */
301  cinfo->do_fancy_upsampling = FALSE;
302 
303  } else if (keymatch(arg, "onepass", 3)) {
304  /* Use fast one-pass quantization. */
305  cinfo->two_pass_quantize = FALSE;
306 
307  } else if (keymatch(arg, "os2", 3)) {
308  /* BMP output format (OS/2 flavor). */
309  requested_fmt = FMT_OS2;
310 
311  } else if (keymatch(arg, "outfile", 4)) {
312  /* Set output file name. */
313  if (++argn >= argc) /* advance to next argument */
314  usage();
315  outfilename = argv[argn]; /* save it away for later use */
316 
317  } else if (keymatch(arg, "pnm", 1) || keymatch(arg, "ppm", 1)) {
318  /* PPM/PGM output format. */
319  requested_fmt = FMT_PPM;
320 
321  } else if (keymatch(arg, "rle", 1)) {
322  /* RLE output format. */
323  requested_fmt = FMT_RLE;
324 
325  } else if (keymatch(arg, "scale", 1)) {
326  /* Scale the output image by a fraction M/N. */
327  if (++argn >= argc) /* advance to next argument */
328  usage();
329  if (sscanf(argv[argn], "%d/%d",
330  &cinfo->scale_num, &cinfo->scale_denom) != 2)
331  usage();
332 
333  } else if (keymatch(arg, "targa", 1)) {
334  /* Targa output format. */
335  requested_fmt = FMT_TARGA;
336 
337  } else {
338  usage(); /* bogus switch */
339  }
340  }
341 
342  return argn; /* return index of next arg (file name) */
343 }
344 
345 
346 /*
347  * Marker processor for COM and interesting APPn markers.
348  * This replaces the library's built-in processor, which just skips the marker.
349  * We want to print out the marker as text, to the extent possible.
350  * Note this code relies on a non-suspending data source.
351  */
352 
353 LOCAL(unsigned int)
355 /* Read next byte */
356 {
357  struct jpeg_source_mgr * datasrc = cinfo->src;
358 
359  if (datasrc->bytes_in_buffer == 0) {
360  if (! (*datasrc->fill_input_buffer) (cinfo))
361  ERREXIT(cinfo, JERR_CANT_SUSPEND);
362  }
363  datasrc->bytes_in_buffer--;
364  return GETJOCTET(*datasrc->next_input_byte++);
365 }
366 
367 
368 METHODDEF(boolean)
370 {
371  boolean traceit = (cinfo->err->trace_level >= 1);
372  INT32 length;
373  unsigned int ch;
374  unsigned int lastch = 0;
375 
376  length = jpeg_getc(cinfo) << 8;
377  length += jpeg_getc(cinfo);
378  length -= 2; /* discount the length word itself */
379 
380  if (traceit) {
381  if (cinfo->unread_marker == JPEG_COM)
382  fprintf(stderr, "Comment, length %ld:\n", (long) length);
383  else /* assume it is an APPn otherwise */
384  fprintf(stderr, "APP%d, length %ld:\n",
385  cinfo->unread_marker - JPEG_APP0, (long) length);
386  }
387 
388  while (--length >= 0) {
389  ch = jpeg_getc(cinfo);
390  if (traceit) {
391  /* Emit the character in a readable form.
392  * Nonprintables are converted to \nnn form,
393  * while \ is converted to \\.
394  * Newlines in CR, CR/LF, or LF form will be printed as one newline.
395  */
396  if (ch == '\r') {
397  fprintf(stderr, "\n");
398  } else if (ch == '\n') {
399  if (lastch != '\r')
400  fprintf(stderr, "\n");
401  } else if (ch == '\\') {
402  fprintf(stderr, "\\\\");
403  } else if (isprint(ch)) {
404  putc(ch, stderr);
405  } else {
406  fprintf(stderr, "\\%03o", ch);
407  }
408  lastch = ch;
409  }
410  }
411 
412  if (traceit)
413  fprintf(stderr, "\n");
414 
415  return TRUE;
416 }
417 
418 
419 /*
420  * The main program.
421  */
422 
423 int
424 main (int argc, char **argv)
425 {
426  struct jpeg_decompress_struct cinfo;
427  struct jpeg_error_mgr jerr;
428 #ifdef PROGRESS_REPORT
429  struct cdjpeg_progress_mgr progress;
430 #endif
431  int file_index;
432  djpeg_dest_ptr dest_mgr = NULL;
433  FILE * input_file;
434  FILE * output_file;
435  JDIMENSION num_scanlines;
436 
437  /* On Mac, fetch a command line. */
438 #ifdef USE_CCOMMAND
439  argc = ccommand(&argv);
440 #endif
441 
442  progname = argv[0];
443  if (progname == NULL || progname[0] == 0)
444  progname = "djpeg"; /* in case C library doesn't provide it */
445 
446  /* Initialize the JPEG decompression object with default error handling. */
447  cinfo.err = jpeg_std_error(&jerr);
448  jpeg_create_decompress(&cinfo);
449  /* Add some application-specific error messages (from cderror.h) */
450  jerr.addon_message_table = cdjpeg_message_table;
451  jerr.first_addon_message = JMSG_FIRSTADDONCODE;
452  jerr.last_addon_message = JMSG_LASTADDONCODE;
453 
454  /* Insert custom marker processor for COM and APP12.
455  * APP12 is used by some digital camera makers for textual info,
456  * so we provide the ability to display it as text.
457  * If you like, additional APPn marker types can be selected for display,
458  * but don't try to override APP0 or APP14 this way (see libjpeg.doc).
459  */
462 
463  /* Now safe to enable signal catcher. */
464 #ifdef NEED_SIGNAL_CATCHER
465  enable_signal_catcher((j_common_ptr) &cinfo);
466 #endif
467 
468  /* Scan command line to find file names. */
469  /* It is convenient to use just one switch-parsing routine, but the switch
470  * values read here are ignored; we will rescan the switches after opening
471  * the input file.
472  * (Exception: tracing level set here controls verbosity for COM markers
473  * found during jpeg_read_header...)
474  */
475 
476  file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
477 
478 #ifdef TWO_FILE_COMMANDLINE
479  /* Must have either -outfile switch or explicit output file name */
480  if (outfilename == NULL) {
481  if (file_index != argc-2) {
482  fprintf(stderr, "%s: must name one input and one output file\n",
483  progname);
484  usage();
485  }
486  outfilename = argv[file_index+1];
487  } else {
488  if (file_index != argc-1) {
489  fprintf(stderr, "%s: must name one input and one output file\n",
490  progname);
491  usage();
492  }
493  }
494 #else
495  /* Unix style: expect zero or one file name */
496  if (file_index < argc-1) {
497  fprintf(stderr, "%s: only one input file\n", progname);
498  usage();
499  }
500 #endif /* TWO_FILE_COMMANDLINE */
501 
502  /* Open the input file. */
503  if (file_index < argc) {
504  if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
505  fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
506  exit(EXIT_FAILURE);
507  }
508  } else {
509  /* default input file is stdin */
510  input_file = read_stdin();
511  }
512 
513  /* Open the output file. */
514  if (outfilename != NULL) {
515  if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
516  fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
517  exit(EXIT_FAILURE);
518  }
519  } else {
520  /* default output file is stdout */
521  output_file = write_stdout();
522  }
523 
524 #ifdef PROGRESS_REPORT
525  start_progress_monitor((j_common_ptr) &cinfo, &progress);
526 #endif
527 
528  /* Specify data source for decompression */
529  jpeg_stdio_src(&cinfo, input_file);
530 
531  /* Read file header, set default decompression parameters */
532  (void) jpeg_read_header(&cinfo, TRUE);
533 
534  /* Adjust default decompression parameters by re-parsing the options */
535  file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
536 
537  /* Initialize the output module now to let it override any crucial
538  * option settings (for instance, GIF wants to force color quantization).
539  */
540  switch (requested_fmt) {
541 #ifdef BMP_SUPPORTED
542  case FMT_BMP:
543  dest_mgr = jinit_write_bmp(&cinfo, FALSE);
544  break;
545  case FMT_OS2:
546  dest_mgr = jinit_write_bmp(&cinfo, TRUE);
547  break;
548 #endif
549 #ifdef GIF_SUPPORTED
550  case FMT_GIF:
551  dest_mgr = jinit_write_gif(&cinfo);
552  break;
553 #endif
554 #ifdef PPM_SUPPORTED
555  case FMT_PPM:
556  dest_mgr = jinit_write_ppm(&cinfo);
557  break;
558 #endif
559 #ifdef RLE_SUPPORTED
560  case FMT_RLE:
561  dest_mgr = jinit_write_rle(&cinfo);
562  break;
563 #endif
564 #ifdef TARGA_SUPPORTED
565  case FMT_TARGA:
566  dest_mgr = jinit_write_targa(&cinfo);
567  break;
568 #endif
569  default:
570  ERREXIT(&cinfo, JERR_UNSUPPORTED_FORMAT);
571  break;
572  }
573  dest_mgr->output_file = output_file;
574 
575  /* Start decompressor */
576  (void) jpeg_start_decompress(&cinfo);
577 
578  /* Write output file header */
579  (*dest_mgr->start_output) (&cinfo, dest_mgr);
580 
581  /* Process data */
582  while (cinfo.output_scanline < cinfo.output_height) {
583  num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
584  dest_mgr->buffer_height);
585  (*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
586  }
587 
588 #ifdef PROGRESS_REPORT
589  /* Hack: count final pass as done in case finish_output does an extra pass.
590  * The library won't have updated completed_passes.
591  */
592  progress.pub.completed_passes = progress.pub.total_passes;
593 #endif
594 
595  /* Finish decompression and release memory.
596  * I must do it in this order because output module has allocated memory
597  * of lifespan JPOOL_IMAGE; it needs to finish before releasing memory.
598  */
599  (*dest_mgr->finish_output) (&cinfo, dest_mgr);
600  (void) jpeg_finish_decompress(&cinfo);
601  jpeg_destroy_decompress(&cinfo);
602 
603  /* Close files, if we opened them */
604  if (input_file != stdin)
605  fclose(input_file);
606  if (output_file != stdout)
607  fclose(output_file);
608 
609 #ifdef PROGRESS_REPORT
610  end_progress_monitor((j_common_ptr) &cinfo);
611 #endif
612 
613  /* All done. */
614  exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
615  return 0; /* suppress no-return-value warnings */
616 }
GLenum GLuint GLenum GLsizei length
JSAMPARRAY buffer
Definition: cdjpeg.h:68
#define JDCT_FASTEST
Definition: jpeglib.h:227
jpeg_read_header(j_decompress_ptr cinfo, boolean require_image)
Definition: jdapimin.c:241
long num_warnings
Definition: jpeglib.h:676
Definition: djpeg.c:64
int last_addon_message
Definition: jpeglib.h:695
print_text_marker(j_decompress_ptr cinfo)
Definition: djpeg.c:369
int completed_passes
Definition: jpeglib.h:706
int main(int argc, char **argv)
Definition: djpeg.c:424
#define GETJOCTET(value)
Definition: jmorecfg.h:119
#define NULL
Definition: ftobjs.h:61
#define DEFAULT_FMT
Definition: djpeg.c:70
#define JDCT_DEFAULT
Definition: jpeglib.h:224
Definition: djpeg.c:62
const char *const * addon_message_table
Definition: jpeglib.h:693
#define ERREXIT(cinfo, code)
Definition: jerror.h:205
#define WRITE_BINARY
Definition: cdjpeg.h:164
read_color_map(j_decompress_ptr cinfo, FILE *infile)
Definition: rdcolmap.c:231
#define EXIT_SUCCESS
Definition: cdjpeg.h:175
typedef void(APIENTRY *GLDEBUGPROCARB)(GLenum source
long INT32
Definition: jmorecfg.h:164
read_stdin(void)
Definition: cdjpeg.c:149
#define jpeg_create_decompress(cinfo)
Definition: jpeglib.h:897
Definition: djpeg.c:61
jinit_write_gif(j_decompress_ptr cinfo)
Definition: wrgif.c:360
#define EXIT_WARNING
Definition: cdjpeg.h:182
#define JPEG_APP0
Definition: jpeglib.h:1047
#define JCOPYRIGHT
Definition: jversion.h:14
GLsizeiptr const GLvoid GLenum usage
#define READ_BINARY
Definition: cdjpeg.h:163
usage(void)
Definition: djpeg.c:90
Definition: djpeg.c:63
keymatch(char *arg, const char *keyword, int minchars)
Definition: cdjpeg.c:122
#define LOCAL(type)
Definition: jmorecfg.h:189
FILE * output_file
Definition: cdjpeg.h:62
jinit_write_ppm(j_decompress_ptr cinfo)
Definition: wrppm.c:219
int first_addon_message
Definition: jpeglib.h:694
Definition: djpeg.c:60
jpeg_stdio_src(j_decompress_ptr cinfo, FILE *infile)
Definition: jdatasrc.c:182
size_t bytes_in_buffer
Definition: jpeglib.h:727
GLuint GLfloat * val
parse_switches(j_decompress_ptr cinfo, int argc, char **argv, int last_file_arg_seen, boolean for_real)
Definition: djpeg.c:162
struct jpeg_progress_mgr pub
Definition: cdjpeg.h:82
jpeg_getc(j_decompress_ptr cinfo)
Definition: djpeg.c:354
jpeg_finish_decompress(j_decompress_ptr cinfo)
Definition: jdapimin.c:369
#define FALSE
Definition: ftobjs.h:57
Definition: djpeg.c:66
jpeg_set_marker_processor(j_decompress_ptr cinfo, int marker_code, jpeg_marker_parser_method routine)
Definition: jdmarker.c:1349
jpeg_destroy_decompress(j_decompress_ptr cinfo)
Definition: jdapimin.c:91
jpeg_read_scanlines(j_decompress_ptr cinfo, JSAMPARRAY scanlines, JDIMENSION max_lines)
Definition: jdapistd.c:152
#define METHODDEF(type)
Definition: jmorecfg.h:187
IMAGE_FORMATS
Definition: djpeg.c:59
JDIMENSION buffer_height
Definition: cdjpeg.h:69
write_stdout(void)
Definition: cdjpeg.c:167
jinit_write_bmp(j_decompress_ptr cinfo, boolean is_os2)
Definition: wrbmp.c:390
char * arg
Definition: cdjpeg.h:136
jpeg_std_error(struct jpeg_error_mgr *err)
Definition: jerror.c:231
unsigned int JDIMENSION
Definition: jmorecfg.h:174
#define EXIT_FAILURE
Definition: cdjpeg.h:169
const JOCTET * next_input_byte
Definition: jpeglib.h:726
#define TRUE
Definition: ftobjs.h:53
#define JPEG_COM
Definition: jpeglib.h:1048
#define JVERSION
Definition: jversion.h:12
jinit_write_targa(j_decompress_ptr cinfo)
Definition: wrtarga.c:225