#include "StdAfx.h"
#include "cdjpeg.h"
#include "jversion.h"
#ifdef USE_CCOMMAND /* command-line reader for Macintosh */
#ifdef __MWERKS__
#include <sioux.h>
#include <console.h>
#endif
#ifdef THINK_C
#include <console.h>
#endif
#endif
#define JMESSAGE(code,string) string ,
static const char * const cdjpeg_message_table[] = {
#include "cderror.h"
NULL
};
LOCAL(cjpeg_source_ptr) select_file_type (j_compress_ptr cinfo, FILE * infile)
{
int c;
if (is_targa)
{
#ifdef TARGA_SUPPORTED
return jinit_read_targa(cinfo);
#else
ERREXIT(cinfo, JERR_TGA_NOTCOMP);
#endif
}
if ((c = getc(infile)) == EOF)
ERREXIT(cinfo, JERR_INPUT_EMPTY);
if (ungetc(c, infile) == EOF)
ERREXIT(cinfo, JERR_UNGETC_FAILED);
switch (c)
{
#ifdef BMP_SUPPORTED
case 'B':
return jinit_read_bmp(cinfo);
#endif
#ifdef GIF_SUPPORTED
case 'G':
return jinit_read_gif(cinfo);
#endif
#ifdef PPM_SUPPORTED
case 'P':
return jinit_read_ppm(cinfo);
#endif
#ifdef RLE_SUPPORTED
case 'R':
return jinit_read_rle(cinfo);
#endif
#ifdef TARGA_SUPPORTED
case 0x00:
return jinit_read_targa(cinfo);
#endif*/
default:
ERREXIT(cinfo, JERR_UNKNOWN_FORMAT);
break;
}
return NULL;
}
static const char * progname;
static char * outfilename;
void usage ()
{
fprintf(stderr, "usage: %s [switches] ", progname);
#ifdef TWO_FILE_COMMANDLINE
fprintf(stderr, "inputfile outputfile\n");
#else
fprintf(stderr, "[inputfile]\n");
#endif
fprintf(stderr, "Switches (names may be abbreviated):\n");
fprintf(stderr, " -quality N Compression quality (0..100; 5-95 is useful range)\n");
fprintf(stderr, " -grayscale Create monochrome JPEG file\n");
#ifdef ENTROPY_OPT_SUPPORTED
fprintf(stderr, " -optimize Optimize Huffman table (smaller file, but slow compression)\n");
#endif
#ifdef C_PROGRESSIVE_SUPPORTED
fprintf(stderr, " -progressive Create progressive JPEG file\n");
#endif
#ifdef TARGA_SUPPORTED
fprintf(stderr, " -targa Input file is Targa format (usually not needed)\n");
#endif
fprintf(stderr, "Switches for advanced users:\n");
#ifdef DCT_ISLOW_SUPPORTED
fprintf(stderr, " -dct int Use integer DCT method%s\n",
(JDCT_DEFAULT == JDCT_ISLOW ? " (default)" : ""));
#endif
#ifdef DCT_IFAST_SUPPORTED
fprintf(stderr, " -dct fast Use fast integer DCT (less accurate)%s\n",
(JDCT_DEFAULT == JDCT_IFAST ? " (default)" : ""));
#endif
#ifdef DCT_FLOAT_SUPPORTED
fprintf(stderr, " -dct float Use floating-point DCT method%s\n",
(JDCT_DEFAULT == JDCT_FLOAT ? " (default)" : ""));
#endif
fprintf(stderr, " -restart N Set restart interval in rows, or in blocks with B\n");
#ifdef INPUT_SMOOTHING_SUPPORTED
fprintf(stderr, " -smooth N Smooth dithered input (N=1..100 is strength)\n");
#endif
fprintf(stderr, " -maxmemory N Maximum memory to use (in kbytes)\n");
fprintf(stderr, " -outfile name Specify name for output file\n");
fprintf(stderr, " -verbose or -debug Emit debug output\n");
fprintf(stderr, "Switches for wizards:\n");
#ifdef C_ARITH_CODING_SUPPORTED
fprintf(stderr, " -arithmetic Use arithmetic coding\n");
#endif
fprintf(stderr, " -baseline Force baseline quantization tables\n");
fprintf(stderr, " -qtables file Use quantization tables given in file\n");
fprintf(stderr, " -qslots N[,...] Set component quantization tables\n");
fprintf(stderr, " -sample HxV[,...] Set component sampling factors\n");
#ifdef C_MULTISCAN_FILES_SUPPORTED
fprintf(stderr, " -scans file Create multi-scan JPEG per script file\n");
#endif
exit(EXIT_FAILURE);
}
int parse_switches (j_compress_ptr cinfo, int argc, char **argv,
int last_file_arg_seen, boolean for_real)
{
int argn;
char * arg;
int quality;
int q_scale_factor;
boolean force_baseline;
boolean simple_progressive;
char * qtablefile = NULL;
char * qslotsarg = NULL;
char * samplearg = NULL;
char * scansarg = NULL;
quality = 75;
q_scale_factor = 100;
force_baseline = FALSE;
simple_progressive = FALSE;
outfilename = NULL;
cinfo->err->trace_level = 0;
for (argn = 1; argn < argc; argn++)
{
arg = argv[argn];
if (*arg != '-')
{
if (argn <= last_file_arg_seen)
{
outfilename = NULL;
continue;
}
break;
}
arg++;
if (keymatch(arg, "arithmetic", 1))
{
#ifdef C_ARITH_CODING_SUPPORTED
cinfo->arith_code = TRUE;
#else
fprintf(stderr, "%s: sorry, arithmetic coding not supported\n",
progname);
exit_1(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "baseline", 1))
{
force_baseline = TRUE;
#ifndef JSIMD_MASKFUNC_NOT_SUPPORTED
} else if (keymatch(arg, "nosimd" , 4)) {
jpeg_simd_mask((j_common_ptr) cinfo, JSIMD_NONE, JSIMD_ALL);
} else if (keymatch(arg, "nommx" , 3)) {
jpeg_simd_mask((j_common_ptr) cinfo, JSIMD_NONE, JSIMD_MMX);
} else if (keymatch(arg, "no3dnow", 3)) {
jpeg_simd_mask((j_common_ptr) cinfo, JSIMD_NONE, JSIMD_3DNOW);
} else if (keymatch(arg, "nosse" , 4)) {
jpeg_simd_mask((j_common_ptr) cinfo, JSIMD_NONE, JSIMD_SSE);
} else if (keymatch(arg, "nosse2" , 6)) {
jpeg_simd_mask((j_common_ptr) cinfo, JSIMD_NONE, JSIMD_SSE2);
#endif /* !JSIMD_MASKFUNC_NOT_SUPPORTED */
} else if (keymatch(arg, "dct", 2)) {
if (++argn >= argc)
usage();
if (keymatch(argv[argn], "int", 1)) {
cinfo->dct_method = JDCT_ISLOW;
} else if (keymatch(argv[argn], "fast", 2)) {
cinfo->dct_method = JDCT_IFAST;
} else if (keymatch(argv[argn], "float", 2)) {
cinfo->dct_method = JDCT_FLOAT;
} else
usage();
} else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {
static boolean printed_version = FALSE;
if (! printed_version) {
fprintf(stderr, "Independent JPEG Group's CJPEG, version %s\n%s\n",
JVERSION, JCOPYRIGHT);
fprintf(stderr,
"\nx86 SIMD extension for IJG JPEG library, version %s\n\n",
JPEG_SIMDEXT_VER_STR);
printed_version = TRUE;
}
cinfo->err->trace_level++;
} else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) {
jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
} else if (keymatch(arg, "maxmemory", 3)) {
long lval;
char ch = 'x';
if (++argn >= argc)
usage();
if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
usage();
if (ch == 'm' || ch == 'M')
lval *= 1000L;
cinfo->mem->max_memory_to_use = lval * 1000L;
} else if (keymatch(arg, "optimize", 1) || keymatch(arg, "optimise", 1)) {
#ifdef ENTROPY_OPT_SUPPORTED
cinfo->optimize_coding = TRUE;
#else
fprintf(stderr, "%s: sorry, entropy optimization was not compiled\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "outfile", 4)) {
if (++argn >= argc)
usage();
outfilename = argv[argn];
} else if (keymatch(arg, "progressive", 1)) {
#ifdef C_PROGRESSIVE_SUPPORTED
simple_progressive = TRUE;
#else
fprintf(stderr, "%s: sorry, progressive output was not compiled\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "quality", 1)) {
if (++argn >= argc)
usage();
if (sscanf(argv[argn], "%d", &quality) != 1)
usage();
q_scale_factor = jpeg_quality_scaling(quality);
} else if (keymatch(arg, "qslots", 2)) {
if (++argn >= argc)
usage();
qslotsarg = argv[argn];
} else if (keymatch(arg, "qtables", 2)) {
if (++argn >= argc)
usage();
qtablefile = argv[argn];
} else if (keymatch(arg, "restart", 1)) {
long lval;
char ch = 'x';
if (++argn >= argc)
usage();
if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
usage();
if (lval < 0 || lval > 65535L)
usage();
if (ch == 'b' || ch == 'B') {
cinfo->restart_interval = (unsigned int) lval;
cinfo->restart_in_rows = 0;
} else {
cinfo->restart_in_rows = (int) lval;
}
} else if (keymatch(arg, "sample", 2)) {
if (++argn >= argc)
usage();
samplearg = argv[argn];
} else if (keymatch(arg, "scans", 2)) {
#ifdef C_MULTISCAN_FILES_SUPPORTED
if (++argn >= argc)
usage();
scansarg = argv[argn];
#else
fprintf(stderr, "%s: sorry, multi-scan output was not compiled\n",
progname);
exit(EXIT_FAILURE);
#endif
} else if (keymatch(arg, "smooth", 2)) {
int val;
if (++argn >= argc)
usage();
if (sscanf(argv[argn], "%d", &val) != 1)
usage();
if (val < 0 || val > 100)
usage();
cinfo->smoothing_factor = val;
usage();
}
}
if (for_real) {
jpeg_set_quality(cinfo, quality, force_baseline);
if (qtablefile != NULL)
if (! read_quant_tables(cinfo, qtablefile,
q_scale_factor, force_baseline))
usage();
if (qslotsarg != NULL)
if (! set_quant_slots(cinfo, qslotsarg))
usage();
if (samplearg != NULL)
if (! set_sample_factors(cinfo, samplearg))
usage();
#ifdef C_PROGRESSIVE_SUPPORTED
if (simple_progressive)
jpeg_simple_progression(cinfo);
#endif
#ifdef C_MULTISCAN_FILES_SUPPORTED
if (scansarg != NULL)
if (! read_scan_script(cinfo, scansarg))
usage();
#endif
}
return argn;
}
int main (int argc, char **argv)
{
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
#ifdef PROGRESS_REPORT
struct cdjpeg_progress_mgr progress;
#endif
int file_index;
cjpeg_source_ptr src_mgr;
FILE * input_file;
FILE * output_file;
JDIMENSION num_scanlines;
#ifdef USE_CCOMMAND
argc = ccommand(&argv);
#endif
progname = argv[0];
if (progname == NULL || progname[0] == 0)
progname = "cjpeg";
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo);
jerr.addon_message_table = cdjpeg_message_table;
jerr.first_addon_message = JMSG_FIRSTADDONCODE;
jerr.last_addon_message = JMSG_LASTADDONCODE;
#ifdef NEED_SIGNAL_CATCHER
enable_signal_catcher((j_common_ptr) &cinfo);
#endif
cinfo.in_color_space = JCS_RGB;
jpeg_set_defaults(&cinfo);
file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
#ifdef TWO_FILE_COMMANDLINE
if (outfilename == NULL)
{
if (file_index != argc-2)
{
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
outfilename = argv[file_index+1];
}
else
{
if (file_index != argc-1)
{
fprintf(stderr, "%s: must name one input and one output file\n",
progname);
usage();
}
}
#endif /* TWO_FILE_COMMANDLINE */
if (file_index < argc)
{
if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL)
{
fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
exit(EXIT_FAILURE);
}
}
if (outfilename != NULL)
{
if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL)
{
fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
exit(EXIT_FAILURE);
}
}
#ifdef PROGRESS_REPORT
start_progress_monitor((j_common_ptr) &cinfo, &progress);
#endif
src_mgr = select_file_type(&cinfo, input_file);
src_mgr->input_file = input_file;
(*src_mgr->start_input) (&cinfo, src_mgr);
jpeg_default_colorspace(&cinfo);
file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
jpeg_stdio_dest(&cinfo, output_file);
jpeg_start_compress(&cinfo, TRUE);
while (cinfo.next_scanline < cinfo.image_height)
{
num_scanlines = (*src_mgr->get_pixel_rows) (&cinfo, src_mgr);
(void) jpeg_write_scanlines(&cinfo, src_mgr->buffer, num_scanlines);
}
(*src_mgr->finish_input) (&cinfo, src_mgr);
jpeg_finish_compress(&cinfo);
jpeg_destroy_compress(&cinfo);
if (input_file != stdin)
fclose(input_file);
if (output_file != stdout)
fclose(output_file);
#ifdef PROGRESS_REPORT
end_progress_monitor((j_common_ptr) &cinfo);
#endif
return 0;
}
What I have tried:
i have tried by # define EXIT_FAILURE and exit_1(EXIT_FAILURE)