ReactOS  0.4.14-dev-552-g2fad488
djpeg.c File Reference
#include "cdjpeg.h"
#include "jversion.h"
#include <ctype.h>
#include "cderror.h"
Include dependency graph for djpeg.c:

Go to the source code of this file.

Macros

#define JMESSAGE(code, string)   string ,
 
#define DEFAULT_FMT   FMT_PPM
 

Enumerations

enum  IMAGE_FORMATS {
  FMT_BMP, FMT_GIF, FMT_OS2, FMT_PPM,
  FMT_RLE, FMT_TARGA, FMT_TIFF
}
 

Functions

 usage (void)
 
 parse_switches (j_decompress_ptr cinfo, int argc, char **argv, int last_file_arg_seen, boolean for_real)
 
 jpeg_getc (j_decompress_ptr cinfo)
 
 print_text_marker (j_decompress_ptr cinfo)
 
int main (int argc, char **argv)
 

Variables

static const char *const cdjpeg_message_table []
 
static IMAGE_FORMATS requested_fmt
 
static const charprogname
 
static charoutfilename
 

Macro Definition Documentation

◆ DEFAULT_FMT

#define DEFAULT_FMT   FMT_PPM

Definition at line 71 of file djpeg.c.

◆ JMESSAGE

#define JMESSAGE (   code,
  string 
)    string ,

Definition at line 45 of file djpeg.c.

Enumeration Type Documentation

◆ IMAGE_FORMATS

Enumerator
FMT_BMP 
FMT_GIF 
FMT_OS2 
FMT_PPM 
FMT_RLE 
FMT_TARGA 
FMT_TIFF 

Definition at line 60 of file djpeg.c.

60  {
61  FMT_BMP, /* BMP format (Windows flavor) */
62  FMT_GIF, /* GIF format */
63  FMT_OS2, /* BMP format (OS/2 flavor) */
64  FMT_PPM, /* PPM/PGM (PBMPLUS formats) */
65  FMT_RLE, /* RLE format */
66  FMT_TARGA, /* Targa format */
67  FMT_TIFF /* TIFF format */
Definition: djpeg.c:65
Definition: djpeg.c:63
Definition: djpeg.c:62
Definition: djpeg.c:64
Definition: djpeg.c:61
Definition: djpeg.c:67
IMAGE_FORMATS
Definition: djpeg.c:60

Function Documentation

◆ jpeg_getc()

jpeg_getc ( j_decompress_ptr  cinfo)

Definition at line 360 of file djpeg.c.

362 {
363  struct jpeg_source_mgr * datasrc = cinfo->src;
364 
365  if (datasrc->bytes_in_buffer == 0) {
366  if (! (*datasrc->fill_input_buffer) (cinfo))
367  ERREXIT(cinfo, JERR_CANT_SUSPEND);
368  }
369  datasrc->bytes_in_buffer--;
370  return GETJOCTET(*datasrc->next_input_byte++);
371 }
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
#define GETJOCTET(value)
Definition: jmorecfg.h:171
size_t bytes_in_buffer
Definition: jpeglib.h:786
struct jpeg_source_mgr * src
Definition: jpeglib.h:463
const JOCTET * next_input_byte
Definition: jpeglib.h:785

Referenced by print_text_marker().

◆ main()

int main ( int argc  ,
char **  argv 
)

Definition at line 430 of file djpeg.c.

431 {
432  struct jpeg_decompress_struct cinfo;
433  struct jpeg_error_mgr jerr;
434 #ifdef PROGRESS_REPORT
436 #endif
437  int file_index;
438  djpeg_dest_ptr dest_mgr = NULL;
439  FILE * input_file;
440  FILE * output_file;
441  JDIMENSION num_scanlines;
442 
443  /* On Mac, fetch a command line. */
444 #ifdef USE_CCOMMAND
445  argc = ccommand(&argv);
446 #endif
447 
448  progname = argv[0];
449  if (progname == NULL || progname[0] == 0)
450  progname = "djpeg"; /* in case C library doesn't provide it */
451 
452  /* Initialize the JPEG decompression object with default error handling. */
453  cinfo.err = jpeg_std_error(&jerr);
454  jpeg_create_decompress(&cinfo);
455  /* Add some application-specific error messages (from cderror.h) */
456  jerr.addon_message_table = cdjpeg_message_table;
457  jerr.first_addon_message = JMSG_FIRSTADDONCODE;
458  jerr.last_addon_message = JMSG_LASTADDONCODE;
459 
460  /* Insert custom marker processor for COM and APP12.
461  * APP12 is used by some digital camera makers for textual info,
462  * so we provide the ability to display it as text.
463  * If you like, additional APPn marker types can be selected for display,
464  * but don't try to override APP0 or APP14 this way (see libjpeg.doc).
465  */
468 
469  /* Now safe to enable signal catcher. */
470 #ifdef NEED_SIGNAL_CATCHER
471  enable_signal_catcher((j_common_ptr) &cinfo);
472 #endif
473 
474  /* Scan command line to find file names. */
475  /* It is convenient to use just one switch-parsing routine, but the switch
476  * values read here are ignored; we will rescan the switches after opening
477  * the input file.
478  * (Exception: tracing level set here controls verbosity for COM markers
479  * found during jpeg_read_header...)
480  */
481 
482  file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
483 
484 #ifdef TWO_FILE_COMMANDLINE
485  /* Must have either -outfile switch or explicit output file name */
486  if (outfilename == NULL) {
487  if (file_index != argc-2) {
488  fprintf(stderr, "%s: must name one input and one output file\n",
489  progname);
490  usage();
491  }
492  outfilename = argv[file_index+1];
493  } else {
494  if (file_index != argc-1) {
495  fprintf(stderr, "%s: must name one input and one output file\n",
496  progname);
497  usage();
498  }
499  }
500 #else
501  /* Unix style: expect zero or one file name */
502  if (file_index < argc-1) {
503  fprintf(stderr, "%s: only one input file\n", progname);
504  usage();
505  }
506 #endif /* TWO_FILE_COMMANDLINE */
507 
508  /* Open the input file. */
509  if (file_index < argc) {
510  if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
511  fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
513  }
514  } else {
515  /* default input file is stdin */
516  input_file = read_stdin();
517  }
518 
519  /* Open the output file. */
520  if (outfilename != NULL) {
521  if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
522  fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
524  }
525  } else {
526  /* default output file is stdout */
527  output_file = write_stdout();
528  }
529 
530 #ifdef PROGRESS_REPORT
531  start_progress_monitor((j_common_ptr) &cinfo, &progress);
532 #endif
533 
534  /* Specify data source for decompression */
535  jpeg_stdio_src(&cinfo, input_file);
536 
537  /* Read file header, set default decompression parameters */
538  (void) jpeg_read_header(&cinfo, TRUE);
539 
540  /* Adjust default decompression parameters by re-parsing the options */
541  file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
542 
543  /* Initialize the output module now to let it override any crucial
544  * option settings (for instance, GIF wants to force color quantization).
545  */
546  switch (requested_fmt) {
547 #ifdef BMP_SUPPORTED
548  case FMT_BMP:
549  dest_mgr = jinit_write_bmp(&cinfo, FALSE);
550  break;
551  case FMT_OS2:
552  dest_mgr = jinit_write_bmp(&cinfo, TRUE);
553  break;
554 #endif
555 #ifdef GIF_SUPPORTED
556  case FMT_GIF:
557  dest_mgr = jinit_write_gif(&cinfo);
558  break;
559 #endif
560 #ifdef PPM_SUPPORTED
561  case FMT_PPM:
562  dest_mgr = jinit_write_ppm(&cinfo);
563  break;
564 #endif
565 #ifdef RLE_SUPPORTED
566  case FMT_RLE:
567  dest_mgr = jinit_write_rle(&cinfo);
568  break;
569 #endif
570 #ifdef TARGA_SUPPORTED
571  case FMT_TARGA:
572  dest_mgr = jinit_write_targa(&cinfo);
573  break;
574 #endif
575  default:
576  ERREXIT(&cinfo, JERR_UNSUPPORTED_FORMAT);
577  break;
578  }
579  dest_mgr->output_file = output_file;
580 
581  /* Start decompressor */
582  (void) jpeg_start_decompress(&cinfo);
583 
584  /* Write output file header */
585  (*dest_mgr->start_output) (&cinfo, dest_mgr);
586 
587  /* Process data */
588  while (cinfo.output_scanline < cinfo.output_height) {
589  num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
590  dest_mgr->buffer_height);
591  (*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
592  }
593 
594 #ifdef PROGRESS_REPORT
595  /* Hack: count final pass as done in case finish_output does an extra pass.
596  * The library won't have updated completed_passes.
597  */
598  progress.pub.completed_passes = progress.pub.total_passes;
599 #endif
600 
601  /* Finish decompression and release memory.
602  * I must do it in this order because output module has allocated memory
603  * of lifespan JPOOL_IMAGE; it needs to finish before releasing memory.
604  */
605  (*dest_mgr->finish_output) (&cinfo, dest_mgr);
606  (void) jpeg_finish_decompress(&cinfo);
607  jpeg_destroy_decompress(&cinfo);
608 
609  /* Close files, if we opened them */
610  if (input_file != stdin)
611  fclose(input_file);
612  if (output_file != stdout)
613  fclose(output_file);
614 
615 #ifdef PROGRESS_REPORT
616  end_progress_monitor((j_common_ptr) &cinfo);
617 #endif
618 
619  /* All done. */
620  exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
621  return 0; /* suppress no-return-value warnings */
622 }
#define READ_BINARY
Definition: jmemdos.c:77
JSAMPARRAY buffer
Definition: cdjpeg.h:68
static int argc
Definition: ServiceArgs.c:12
jpeg_read_header(j_decompress_ptr cinfo, boolean require_image)
Definition: jdapimin.c:245
#define TRUE
Definition: types.h:120
Definition: djpeg.c:65
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
print_text_marker(j_decompress_ptr cinfo)
Definition: djpeg.c:375
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
static const char *const cdjpeg_message_table[]
Definition: djpeg.c:47
FILE * stdin
Definition: djpeg.c:63
#define argv
Definition: mplay32.c:18
FILE * stdout
read_stdin(void)
Definition: cdjpeg.c:149
#define EXIT_SUCCESS
Definition: rdjpgcom.c:55
#define jpeg_create_decompress(cinfo)
Definition: jpeglib.h:961
Definition: djpeg.c:62
_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 JPEG_APP0
Definition: jpeglib.h:1125
smooth NULL
Definition: ftsmooth.c:416
usage(void)
Definition: djpeg.c:91
Definition: djpeg.c:64
FILE * output_file
Definition: cdjpeg.h:62
Definition: djpeg.c:61
jpeg_stdio_src(j_decompress_ptr cinfo, FILE *infile)
Definition: jdatasrc.c:210
static char * outfilename
Definition: djpeg.c:87
#define EXIT_FAILURE
Definition: jerror.c:33
parse_switches(j_decompress_ptr cinfo, int argc, char **argv, int last_file_arg_seen, boolean for_real)
Definition: djpeg.c:164
struct jpeg_progress_mgr pub
Definition: cdjpeg.h:82
static IMAGE_FORMATS requested_fmt
Definition: djpeg.c:74
jpeg_finish_decompress(j_decompress_ptr cinfo)
Definition: jdapimin.c:373
jpeg_set_marker_processor(j_decompress_ptr cinfo, int marker_code, jpeg_marker_parser_method routine)
Definition: jdmarker.c:1500
_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)
jpeg_destroy_decompress(j_decompress_ptr cinfo)
Definition: jdapimin.c:92
#define WRITE_BINARY
Definition: wrjpgcom.c:47
jpeg_read_scanlines(j_decompress_ptr cinfo, JSAMPARRAY scanlines, JDIMENSION max_lines)
Definition: jdapistd.c:153
JDIMENSION buffer_height
Definition: cdjpeg.h:69
cd_progress_ptr progress
Definition: cdjpeg.h:150
write_stdout(void)
Definition: cdjpeg.c:167
jpeg_std_error(struct jpeg_error_mgr *err)
Definition: jerror.c:232
unsigned int JDIMENSION
Definition: jmorecfg.h:229
FILE * stderr
void exit(int exitcode)
Definition: _exit.c:33
static const char * progname
Definition: djpeg.c:86
#define JPEG_COM
Definition: jpeglib.h:1126

◆ parse_switches()

parse_switches ( j_decompress_ptr  cinfo,
int  argc,
char **  argv,
int  last_file_arg_seen,
boolean  for_real 
)

Definition at line 164 of file djpeg.c.

174 {
175  int argn;
176  char * arg;
177 
178  /* Set up default JPEG parameters. */
179  requested_fmt = DEFAULT_FMT; /* set default output file format */
180  outfilename = NULL;
181  cinfo->err->trace_level = 0;
182 
183  /* Scan command line options, adjust parameters */
184 
185  for (argn = 1; argn < argc; argn++) {
186  arg = argv[argn];
187  if (*arg != '-') {
188  /* Not a switch, must be a file name argument */
189  if (argn <= last_file_arg_seen) {
190  outfilename = NULL; /* -outfile applies to just one input file */
191  continue; /* ignore this name if previously processed */
192  }
193  break; /* else done parsing switches */
194  }
195  arg++; /* advance past switch marker character */
196 
197  if (keymatch(arg, "bmp", 1)) {
198  /* BMP output format. */
200 
201  } else if (keymatch(arg, "colors", 1) || keymatch(arg, "colours", 1) ||
202  keymatch(arg, "quantize", 1) || keymatch(arg, "quantise", 1)) {
203  /* Do color quantization. */
204  int val;
205 
206  if (++argn >= argc) /* advance to next argument */
207  usage();
208  if (sscanf(argv[argn], "%d", &val) != 1)
209  usage();
210  cinfo->desired_number_of_colors = val;
211  cinfo->quantize_colors = TRUE;
212 
213  } else if (keymatch(arg, "dct", 2)) {
214  /* Select IDCT algorithm. */
215  if (++argn >= argc) /* advance to next argument */
216  usage();
217  if (keymatch(argv[argn], "int", 1)) {
218  cinfo->dct_method = JDCT_ISLOW;
219  } else if (keymatch(argv[argn], "fast", 2)) {
220  cinfo->dct_method = JDCT_IFAST;
221  } else if (keymatch(argv[argn], "float", 2)) {
222  cinfo->dct_method = JDCT_FLOAT;
223  } else
224  usage();
225 
226  } else if (keymatch(arg, "dither", 2)) {
227  /* Select dithering algorithm. */
228  if (++argn >= argc) /* advance to next argument */
229  usage();
230  if (keymatch(argv[argn], "fs", 2)) {
231  cinfo->dither_mode = JDITHER_FS;
232  } else if (keymatch(argv[argn], "none", 2)) {
233  cinfo->dither_mode = JDITHER_NONE;
234  } else if (keymatch(argv[argn], "ordered", 2)) {
235  cinfo->dither_mode = JDITHER_ORDERED;
236  } else
237  usage();
238 
239  } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {
240  /* Enable debug printouts. */
241  /* On first -d, print version identification */
242  static boolean printed_version = FALSE;
243 
244  if (! printed_version) {
245  fprintf(stderr, "Independent JPEG Group's DJPEG, version %s\n%s\n",
247  printed_version = TRUE;
248  }
249  cinfo->err->trace_level++;
250 
251  } else if (keymatch(arg, "fast", 1)) {
252  /* Select recommended processing options for quick-and-dirty output. */
253  cinfo->two_pass_quantize = FALSE;
254  cinfo->dither_mode = JDITHER_ORDERED;
255  if (! cinfo->quantize_colors) /* don't override an earlier -colors */
256  cinfo->desired_number_of_colors = 216;
257  cinfo->dct_method = JDCT_FASTEST;
258  cinfo->do_fancy_upsampling = FALSE;
259 
260  } else if (keymatch(arg, "gif", 1)) {
261  /* GIF output format. */
263 
264  } else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) {
265  /* Force monochrome output. */
267 
268  } else if (keymatch(arg, "rgb", 3)) {
269  /* Force RGB output. */
270  cinfo->out_color_space = JCS_RGB;
271 
272  } else if (keymatch(arg, "map", 3)) {
273  /* Quantize to a color map taken from an input file. */
274  if (++argn >= argc) /* advance to next argument */
275  usage();
276  if (for_real) { /* too expensive to do twice! */
277 #ifdef QUANT_2PASS_SUPPORTED /* otherwise can't quantize to supplied map */
278  FILE * mapfile;
279 
280  if ((mapfile = fopen(argv[argn], READ_BINARY)) == NULL) {
281  fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]);
283  }
284  read_color_map(cinfo, mapfile);
285  fclose(mapfile);
286  cinfo->quantize_colors = TRUE;
287 #else
288  ERREXIT(cinfo, JERR_NOT_COMPILED);
289 #endif
290  }
291 
292  } else if (keymatch(arg, "maxmemory", 3)) {
293  /* Maximum memory in Kb (or Mb with 'm'). */
294  long lval;
295  char ch = 'x';
296 
297  if (++argn >= argc) /* advance to next argument */
298  usage();
299  if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
300  usage();
301  if (ch == 'm' || ch == 'M')
302  lval *= 1000L;
303  cinfo->mem->max_memory_to_use = lval * 1000L;
304 
305  } else if (keymatch(arg, "nosmooth", 3)) {
306  /* Suppress fancy upsampling. */
307  cinfo->do_fancy_upsampling = FALSE;
308 
309  } else if (keymatch(arg, "onepass", 3)) {
310  /* Use fast one-pass quantization. */
311  cinfo->two_pass_quantize = FALSE;
312 
313  } else if (keymatch(arg, "os2", 3)) {
314  /* BMP output format (OS/2 flavor). */
316 
317  } else if (keymatch(arg, "outfile", 4)) {
318  /* Set output file name. */
319  if (++argn >= argc) /* advance to next argument */
320  usage();
321  outfilename = argv[argn]; /* save it away for later use */
322 
323  } else if (keymatch(arg, "pnm", 1) || keymatch(arg, "ppm", 1)) {
324  /* PPM/PGM output format. */
326 
327  } else if (keymatch(arg, "rle", 1)) {
328  /* RLE output format. */
330 
331  } else if (keymatch(arg, "scale", 1)) {
332  /* Scale the output image by a fraction M/N. */
333  if (++argn >= argc) /* advance to next argument */
334  usage();
335  if (sscanf(argv[argn], "%u/%u",
336  &cinfo->scale_num, &cinfo->scale_denom) < 1)
337  usage();
338 
339  } else if (keymatch(arg, "targa", 1)) {
340  /* Targa output format. */
342 
343  } else {
344  usage(); /* bogus switch */
345  }
346  }
347 
348  return argn; /* return index of next arg (file name) */
349 }
#define READ_BINARY
Definition: jmemdos.c:77
#define JDCT_FASTEST
Definition: jpeglib.h:250
static int argc
Definition: ServiceArgs.c:12
#define TRUE
Definition: types.h:120
Definition: djpeg.c:65
#define ERREXIT(msg)
Definition: rdjpgcom.c:72
boolean do_fancy_upsampling
Definition: jpeglib.h:488
boolean quantize_colors
Definition: jpeglib.h:491
#define DEFAULT_FMT
Definition: djpeg.c:71
Definition: djpeg.c:63
void * arg
Definition: msvc.h:12
#define argv
Definition: mplay32.c:18
boolean two_pass_quantize
Definition: jpeglib.h:494
Definition: djpeg.c:62
J_COLOR_SPACE out_color_space
Definition: jpeglib.h:478
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#define JCOPYRIGHT
Definition: jversion.h:14
smooth NULL
Definition: ftsmooth.c:416
_Check_return_ _CRTIMP int __cdecl sscanf(_In_z_ const char *_Src, _In_z_ _Scanf_format_string_ const char *_Format,...)
usage(void)
Definition: djpeg.c:91
Definition: djpeg.c:64
keymatch(char *arg, const char *keyword, int minchars)
Definition: cdjpeg.c:122
GLuint GLfloat * val
Definition: glext.h:7180
J_DCT_METHOD dct_method
Definition: jpeglib.h:487
Definition: djpeg.c:61
static char * outfilename
Definition: djpeg.c:87
unsigned int scale_denom
Definition: jpeglib.h:480
#define EXIT_FAILURE
Definition: jerror.c:33
J_DITHER_MODE dither_mode
Definition: jpeglib.h:493
static IMAGE_FORMATS requested_fmt
Definition: djpeg.c:74
static const WCHAR L[]
Definition: oid.c:1250
_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)
FILE * stderr
unsigned int scale_num
Definition: jpeglib.h:480
void exit(int exitcode)
Definition: _exit.c:33
static const char * progname
Definition: djpeg.c:86
#define JVERSION
Definition: jversion.h:12

Referenced by main().

◆ print_text_marker()

print_text_marker ( j_decompress_ptr  cinfo)

Definition at line 375 of file djpeg.c.

376 {
377  boolean traceit = (cinfo->err->trace_level >= 1);
378  INT32 length;
379  unsigned int ch;
380  unsigned int lastch = 0;
381 
382  length = jpeg_getc(cinfo) << 8;
383  length += jpeg_getc(cinfo);
384  length -= 2; /* discount the length word itself */
385 
386  if (traceit) {
387  if (cinfo->unread_marker == JPEG_COM)
388  fprintf(stderr, "Comment, length %ld:\n", (long) length);
389  else /* assume it is an APPn otherwise */
390  fprintf(stderr, "APP%d, length %ld:\n",
391  cinfo->unread_marker - JPEG_APP0, (long) length);
392  }
393 
394  while (--length >= 0) {
395  ch = jpeg_getc(cinfo);
396  if (traceit) {
397  /* Emit the character in a readable form.
398  * Nonprintables are converted to \nnn form,
399  * while \ is converted to \\.
400  * Newlines in CR, CR/LF, or LF form will be printed as one newline.
401  */
402  if (ch == '\r') {
403  fprintf(stderr, "\n");
404  } else if (ch == '\n') {
405  if (lastch != '\r')
406  fprintf(stderr, "\n");
407  } else if (ch == '\\') {
408  fprintf(stderr, "\\\\");
409  } else if (isprint(ch)) {
410  putc(ch, stderr);
411  } else {
412  fprintf(stderr, "\\%03o", ch);
413  }
414  lastch = ch;
415  }
416  }
417 
418  if (traceit)
419  fprintf(stderr, "\n");
420 
421  return TRUE;
422 }
#define TRUE
Definition: types.h:120
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#define JPEG_APP0
Definition: jpeglib.h:1125
_Check_return_opt_ _CRTIMP int __cdecl putc(_In_ int _Ch, _Inout_ FILE *_File)
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
jpeg_getc(j_decompress_ptr cinfo)
Definition: djpeg.c:360
#define isprint(c)
Definition: acclib.h:73
FILE * stderr
signed int INT32
#define JPEG_COM
Definition: jpeglib.h:1126

Referenced by main().

◆ usage()

usage ( void  )

Definition at line 91 of file djpeg.c.

93 {
94  fprintf(stderr, "usage: %s [switches] ", progname);
95 #ifdef TWO_FILE_COMMANDLINE
96  fprintf(stderr, "inputfile outputfile\n");
97 #else
98  fprintf(stderr, "[inputfile]\n");
99 #endif
100 
101  fprintf(stderr, "Switches (names may be abbreviated):\n");
102  fprintf(stderr, " -colors N Reduce image to no more than N colors\n");
103  fprintf(stderr, " -fast Fast, low-quality processing\n");
104  fprintf(stderr, " -grayscale Force grayscale output\n");
105  fprintf(stderr, " -rgb Force RGB output\n");
106 #ifdef IDCT_SCALING_SUPPORTED
107  fprintf(stderr, " -scale M/N Scale output image by fraction M/N, eg, 1/8\n");
108 #endif
109 #ifdef BMP_SUPPORTED
110  fprintf(stderr, " -bmp Select BMP output format (Windows style)%s\n",
111  (DEFAULT_FMT == FMT_BMP ? " (default)" : ""));
112 #endif
113 #ifdef GIF_SUPPORTED
114  fprintf(stderr, " -gif Select GIF output format%s\n",
115  (DEFAULT_FMT == FMT_GIF ? " (default)" : ""));
116 #endif
117 #ifdef BMP_SUPPORTED
118  fprintf(stderr, " -os2 Select BMP output format (OS/2 style)%s\n",
119  (DEFAULT_FMT == FMT_OS2 ? " (default)" : ""));
120 #endif
121 #ifdef PPM_SUPPORTED
122  fprintf(stderr, " -pnm Select PBMPLUS (PPM/PGM) output format%s\n",
123  (DEFAULT_FMT == FMT_PPM ? " (default)" : ""));
124 #endif
125 #ifdef RLE_SUPPORTED
126  fprintf(stderr, " -rle Select Utah RLE output format%s\n",
127  (DEFAULT_FMT == FMT_RLE ? " (default)" : ""));
128 #endif
129 #ifdef TARGA_SUPPORTED
130  fprintf(stderr, " -targa Select Targa output format%s\n",
131  (DEFAULT_FMT == FMT_TARGA ? " (default)" : ""));
132 #endif
133  fprintf(stderr, "Switches for advanced users:\n");
134 #ifdef DCT_ISLOW_SUPPORTED
135  fprintf(stderr, " -dct int Use integer DCT method%s\n",
136  (JDCT_DEFAULT == JDCT_ISLOW ? " (default)" : ""));
137 #endif
138 #ifdef DCT_IFAST_SUPPORTED
139  fprintf(stderr, " -dct fast Use fast integer DCT (less accurate)%s\n",
140  (JDCT_DEFAULT == JDCT_IFAST ? " (default)" : ""));
141 #endif
142 #ifdef DCT_FLOAT_SUPPORTED
143  fprintf(stderr, " -dct float Use floating-point DCT method%s\n",
144  (JDCT_DEFAULT == JDCT_FLOAT ? " (default)" : ""));
145 #endif
146  fprintf(stderr, " -dither fs Use F-S dithering (default)\n");
147  fprintf(stderr, " -dither none Don't use dithering in quantization\n");
148  fprintf(stderr, " -dither ordered Use ordered dither (medium speed, quality)\n");
149 #ifdef QUANT_2PASS_SUPPORTED
150  fprintf(stderr, " -map FILE Map to colors used in named image file\n");
151 #endif
152  fprintf(stderr, " -nosmooth Don't use high-quality upsampling\n");
153 #ifdef QUANT_1PASS_SUPPORTED
154  fprintf(stderr, " -onepass Use 1-pass quantization (fast, low quality)\n");
155 #endif
156  fprintf(stderr, " -maxmemory N Maximum memory to use (in kbytes)\n");
157  fprintf(stderr, " -outfile name Specify name for output file\n");
158  fprintf(stderr, " -verbose or -debug Emit debug output\n");
160 }
Definition: djpeg.c:65
#define DEFAULT_FMT
Definition: djpeg.c:71
#define JDCT_DEFAULT
Definition: jpeglib.h:247
Definition: djpeg.c:63
Definition: djpeg.c:62
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
Definition: djpeg.c:64
Definition: djpeg.c:61
#define EXIT_FAILURE
Definition: jerror.c:33
FILE * stderr
void exit(int exitcode)
Definition: _exit.c:33
static const char * progname
Definition: djpeg.c:86

Referenced by main(), and parse_switches().

Variable Documentation

◆ cdjpeg_message_table

const char* const cdjpeg_message_table[]
static
Initial value:
= {
}
smooth NULL
Definition: ftsmooth.c:416

Definition at line 47 of file djpeg.c.

Referenced by main().

◆ outfilename

char* outfilename
static

Definition at line 87 of file djpeg.c.

Referenced by main(), and parse_switches().

◆ progname

const char* progname
static

Definition at line 86 of file djpeg.c.

Referenced by main(), parse_switches(), and usage().

◆ requested_fmt

IMAGE_FORMATS requested_fmt
static

Definition at line 74 of file djpeg.c.

Referenced by main(), and parse_switches().