JPEGTRAN.c
上传用户:cjw5120
上传日期:2022-05-11
资源大小:5032k
文件大小:12k
源码类别:

网络截获/分析

开发平台:

Visual C++

  1. ////////////////////////////////////////////////////////////////////////
  2. //
  3. // Note : this file is included as part of the Smaller Animals Software
  4. // JpegFile package. Though this file has not been modified from it's 
  5. // original IJG 6a form, it is not the responsibility on the Independent
  6. // JPEG Group to answer questions regarding this code.
  7. //
  8. // Any questions you have about this code should be addressed to :
  9. //
  10. // CHRISDL@PAGESZ.NET - the distributor of this package.
  11. //
  12. // Remember, by including this code in the JpegFile package, Smaller 
  13. // Animals Software assumes all responsibilities for answering questions
  14. // about it. If we (SA Software) can't answer your questions ourselves, we 
  15. // will direct you to people who can.
  16. //
  17. // Thanks, CDL.
  18. //
  19. ////////////////////////////////////////////////////////////////////////
  20. /*
  21.  * jpegtran.c
  22.  *
  23.  * Copyright (C) 1995-1996, Thomas G. Lane.
  24.  * This file is part of the Independent JPEG Group's software.
  25.  * For conditions of distribution and use, see the accompanying README file.
  26.  *
  27.  * This file contains a command-line user interface for JPEG transcoding.
  28.  * It is very similar to cjpeg.c, but provides lossless transcoding between
  29.  * different JPEG file formats.
  30.  */
  31. #include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
  32. #include "jversion.h" /* for version message */
  33. #ifdef USE_CCOMMAND /* command-line reader for Macintosh */
  34. #ifdef __MWERKS__
  35. #include <SIOUX.h>              /* Metrowerks needs this */
  36. #include <console.h> /* ... and this */
  37. #endif
  38. #ifdef THINK_C
  39. #include <console.h> /* Think declares it here */
  40. #endif
  41. #endif
  42. /*
  43.  * Argument-parsing code.
  44.  * The switch parser is designed to be useful with DOS-style command line
  45.  * syntax, ie, intermixed switches and file names, where only the switches
  46.  * to the left of a given file name affect processing of that file.
  47.  * The main program in this file doesn't actually use this capability...
  48.  */
  49. static const char * progname; /* program name for error messages */
  50. static char * outfilename; /* for -outfile switch */
  51. LOCAL(void)
  52. usage (void)
  53. /* complain about bad command line */
  54. {
  55.   fprintf(stderr, "usage: %s [switches] ", progname);
  56. #ifdef TWO_FILE_COMMANDLINE
  57.   fprintf(stderr, "inputfile outputfilen");
  58. #else
  59.   fprintf(stderr, "[inputfile]n");
  60. #endif
  61.   fprintf(stderr, "Switches (names may be abbreviated):n");
  62. #ifdef ENTROPY_OPT_SUPPORTED
  63.   fprintf(stderr, "  -optimize      Optimize Huffman table (smaller file, but slow compression)n");
  64. #endif
  65. #ifdef C_PROGRESSIVE_SUPPORTED
  66.   fprintf(stderr, "  -progressive   Create progressive JPEG filen");
  67. #endif
  68.   fprintf(stderr, "Switches for advanced users:n");
  69.   fprintf(stderr, "  -restart N     Set restart interval in rows, or in blocks with Bn");
  70.   fprintf(stderr, "  -maxmemory N   Maximum memory to use (in kbytes)n");
  71.   fprintf(stderr, "  -outfile name  Specify name for output filen");
  72.   fprintf(stderr, "  -verbose  or  -debug   Emit debug outputn");
  73.   fprintf(stderr, "Switches for wizards:n");
  74. #ifdef C_ARITH_CODING_SUPPORTED
  75.   fprintf(stderr, "  -arithmetic    Use arithmetic codingn");
  76. #endif
  77. #ifdef C_MULTISCAN_FILES_SUPPORTED
  78.   fprintf(stderr, "  -scans file    Create multi-scan JPEG per script filen");
  79. #endif
  80.   exit(EXIT_FAILURE);
  81. }
  82. LOCAL(int)
  83. parse_switches (j_compress_ptr cinfo, int argc, char **argv,
  84. int last_file_arg_seen, unsigned int for_real)
  85. /* Parse optional switches.
  86.  * Returns argv[] index of first file-name argument (== argc if none).
  87.  * Any file names with indexes <= last_file_arg_seen are ignored;
  88.  * they have presumably been processed in a previous iteration.
  89.  * (Pass 0 for last_file_arg_seen on the first or only iteration.)
  90.  * for_real is FALSE on the first (dummy) pass; we may skip any expensive
  91.  * processing.
  92.  */
  93. {
  94.   int argn;
  95.   char * arg;
  96.   unsigned int simple_progressive;
  97.   char * scansarg = NULL; /* saves -scans parm if any */
  98.   /* Set up default JPEG parameters. */
  99.   simple_progressive = FALSE;
  100.   outfilename = NULL;
  101.   cinfo->err->trace_level = 0;
  102.   /* Scan command line options, adjust parameters */
  103.   for (argn = 1; argn < argc; argn++) {
  104.     arg = argv[argn];
  105.     if (*arg != '-') {
  106.       /* Not a switch, must be a file name argument */
  107.       if (argn <= last_file_arg_seen) {
  108. outfilename = NULL; /* -outfile applies to just one input file */
  109. continue; /* ignore this name if previously processed */
  110.       }
  111.       break; /* else done parsing switches */
  112.     }
  113.     arg++; /* advance past switch marker character */
  114.     if (keymatch(arg, "arithmetic", 1)) {
  115.       /* Use arithmetic coding. */
  116. #ifdef C_ARITH_CODING_SUPPORTED
  117.       cinfo->arith_code = TRUE;
  118. #else
  119.       fprintf(stderr, "%s: sorry, arithmetic coding not supportedn",
  120.       progname);
  121.       exit(EXIT_FAILURE);
  122. #endif
  123.     } else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {
  124.       /* Enable debug printouts. */
  125.       /* On first -d, print version identification */
  126.       static unsigned int printed_version = FALSE;
  127.       if (! printed_version) {
  128. fprintf(stderr, "Independent JPEG Group's JPEGTRAN, version %sn%sn",
  129. JVERSION, JCOPYRIGHT);
  130. printed_version = TRUE;
  131.       }
  132.       cinfo->err->trace_level++;
  133.     } else if (keymatch(arg, "maxmemory", 3)) {
  134.       /* Maximum memory in Kb (or Mb with 'm'). */
  135.       long lval;
  136.       char ch = 'x';
  137.       if (++argn >= argc) /* advance to next argument */
  138. usage();
  139.       if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
  140. usage();
  141.       if (ch == 'm' || ch == 'M')
  142. lval *= 1000L;
  143.       cinfo->mem->max_memory_to_use = lval * 1000L;
  144.     } else if (keymatch(arg, "optimize", 1) || keymatch(arg, "optimise", 1)) {
  145.       /* Enable entropy parm optimization. */
  146. #ifdef ENTROPY_OPT_SUPPORTED
  147.       cinfo->optimize_coding = TRUE;
  148. #else
  149.       fprintf(stderr, "%s: sorry, entropy optimization was not compiledn",
  150.       progname);
  151.       exit(EXIT_FAILURE);
  152. #endif
  153.     } else if (keymatch(arg, "outfile", 4)) {
  154.       /* Set output file name. */
  155.       if (++argn >= argc) /* advance to next argument */
  156. usage();
  157.       outfilename = argv[argn]; /* save it away for later use */
  158.     } else if (keymatch(arg, "progressive", 1)) {
  159.       /* Select simple progressive mode. */
  160. #ifdef C_PROGRESSIVE_SUPPORTED
  161.       simple_progressive = TRUE;
  162.       /* We must postpone execution until num_components is known. */
  163. #else
  164.       fprintf(stderr, "%s: sorry, progressive output was not compiledn",
  165.       progname);
  166.       exit(EXIT_FAILURE);
  167. #endif
  168.     } else if (keymatch(arg, "restart", 1)) {
  169.       /* Restart interval in MCU rows (or in MCUs with 'b'). */
  170.       long lval;
  171.       char ch = 'x';
  172.       if (++argn >= argc) /* advance to next argument */
  173. usage();
  174.       if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
  175. usage();
  176.       if (lval < 0 || lval > 65535L)
  177. usage();
  178.       if (ch == 'b' || ch == 'B') {
  179. cinfo->restart_interval = (unsigned int) lval;
  180. cinfo->restart_in_rows = 0; /* else prior '-restart n' overrides me */
  181.       } else {
  182. cinfo->restart_in_rows = (int) lval;
  183. /* restart_interval will be computed during startup */
  184.       }
  185.     } else if (keymatch(arg, "scans", 2)) {
  186.       /* Set scan script. */
  187. #ifdef C_MULTISCAN_FILES_SUPPORTED
  188.       if (++argn >= argc) /* advance to next argument */
  189. usage();
  190.       scansarg = argv[argn];
  191.       /* We must postpone reading the file in case -progressive appears. */
  192. #else
  193.       fprintf(stderr, "%s: sorry, multi-scan output was not compiledn",
  194.       progname);
  195.       exit(EXIT_FAILURE);
  196. #endif
  197.     } else {
  198.       usage(); /* bogus switch */
  199.     }
  200.   }
  201.   /* Post-switch-scanning cleanup */
  202.   if (for_real) {
  203. #ifdef C_PROGRESSIVE_SUPPORTED
  204.     if (simple_progressive) /* process -progressive; -scans can override */
  205.       jpeg_simple_progression(cinfo);
  206. #endif
  207. #ifdef C_MULTISCAN_FILES_SUPPORTED
  208.     if (scansarg != NULL) /* process -scans if it was present */
  209.       if (! read_scan_script(cinfo, scansarg))
  210. usage();
  211. #endif
  212.   }
  213.   return argn; /* return index of next arg (file name) */
  214. }
  215. /*
  216.  * The main program.
  217.  */
  218. int
  219. main (int argc, char **argv)
  220. {
  221.   struct jpeg_decompress_struct srcinfo;
  222.   struct jpeg_compress_struct dstinfo;
  223.   struct jpeg_error_mgr jsrcerr, jdsterr;
  224. #ifdef PROGRESS_REPORT
  225.   struct cdjpeg_progress_mgr progress;
  226. #endif
  227.   jvirt_barray_ptr * coef_arrays;
  228.   int file_index;
  229.   FILE * input_file;
  230.   FILE * output_file;
  231.   /* On Mac, fetch a command line. */
  232. #ifdef USE_CCOMMAND
  233.   argc = ccommand(&argv);
  234. #endif
  235.   progname = argv[0];
  236.   if (progname == NULL || progname[0] == 0)
  237.     progname = "jpegtran"; /* in case C library doesn't provide it */
  238.   /* Initialize the JPEG decompression object with default error handling. */
  239.   srcinfo.err = jpeg_std_error(&jsrcerr);
  240.   jpeg_create_decompress(&srcinfo);
  241.   /* Initialize the JPEG compression object with default error handling. */
  242.   dstinfo.err = jpeg_std_error(&jdsterr);
  243.   jpeg_create_compress(&dstinfo);
  244.   /* Now safe to enable signal catcher.
  245.    * Note: we assume only the decompression object will have virtual arrays.
  246.    */
  247. #ifdef NEED_SIGNAL_CATCHER
  248.   enable_signal_catcher((j_common_ptr) &srcinfo);
  249. #endif
  250.   /* Scan command line to find file names.
  251.    * It is convenient to use just one switch-parsing routine, but the switch
  252.    * values read here are ignored; we will rescan the switches after opening
  253.    * the input file.
  254.    */
  255.   file_index = parse_switches(&dstinfo, argc, argv, 0, FALSE);
  256.   jsrcerr.trace_level = jdsterr.trace_level;
  257.   srcinfo.mem->max_memory_to_use = dstinfo.mem->max_memory_to_use;
  258. #ifdef TWO_FILE_COMMANDLINE
  259.   /* Must have either -outfile switch or explicit output file name */
  260.   if (outfilename == NULL) {
  261.     if (file_index != argc-2) {
  262.       fprintf(stderr, "%s: must name one input and one output filen",
  263.       progname);
  264.       usage();
  265.     }
  266.     outfilename = argv[file_index+1];
  267.   } else {
  268.     if (file_index != argc-1) {
  269.       fprintf(stderr, "%s: must name one input and one output filen",
  270.       progname);
  271.       usage();
  272.     }
  273.   }
  274. #else
  275.   /* Unix style: expect zero or one file name */
  276.   if (file_index < argc-1) {
  277.     fprintf(stderr, "%s: only one input filen", progname);
  278.     usage();
  279.   }
  280. #endif /* TWO_FILE_COMMANDLINE */
  281.   /* Open the input file. */
  282.   if (file_index < argc) {
  283.     if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
  284.       fprintf(stderr, "%s: can't open %sn", progname, argv[file_index]);
  285.       exit(EXIT_FAILURE);
  286.     }
  287.   } else {
  288.     /* default input file is stdin */
  289.     input_file = read_stdin();
  290.   }
  291.   /* Open the output file. */
  292.   if (outfilename != NULL) {
  293.     if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
  294.       fprintf(stderr, "%s: can't open %sn", progname, outfilename);
  295.       exit(EXIT_FAILURE);
  296.     }
  297.   } else {
  298.     /* default output file is stdout */
  299.     output_file = write_stdout();
  300.   }
  301. #ifdef PROGRESS_REPORT
  302.   start_progress_monitor((j_common_ptr) &dstinfo, &progress);
  303. #endif
  304.   /* Specify data source for decompression */
  305.   jpeg_stdio_src(&srcinfo, input_file);
  306.   /* Read file header */
  307.   (void) jpeg_read_header(&srcinfo, TRUE);
  308.   /* Read source file as DCT coefficients */
  309.   coef_arrays = jpeg_read_coefficients(&srcinfo);
  310.   /* Initialize destination compression parameters from source values */
  311.   jpeg_copy_critical_parameters(&srcinfo, &dstinfo);
  312.   /* Adjust default compression parameters by re-parsing the options */
  313.   file_index = parse_switches(&dstinfo, argc, argv, 0, TRUE);
  314.   /* Specify data destination for compression */
  315.   jpeg_stdio_dest(&dstinfo, output_file);
  316.   /* Start compressor */
  317.   jpeg_write_coefficients(&dstinfo, coef_arrays);
  318.   /* ought to copy source comments here... */
  319.   /* Finish compression and release memory */
  320.   jpeg_finish_compress(&dstinfo);
  321.   jpeg_destroy_compress(&dstinfo);
  322.   (void) jpeg_finish_decompress(&srcinfo);
  323.   jpeg_destroy_decompress(&srcinfo);
  324.   /* Close files, if we opened them */
  325.   if (input_file != stdin)
  326.     fclose(input_file);
  327.   if (output_file != stdout)
  328.     fclose(output_file);
  329. #ifdef PROGRESS_REPORT
  330.   end_progress_monitor((j_common_ptr) &dstinfo);
  331. #endif
  332.   /* All done. */
  333.   exit(jsrcerr.num_warnings + jdsterr.num_warnings ?EXIT_WARNING:EXIT_SUCCESS);
  334.   return 0; /* suppress no-return-value warnings */
  335. }