зеркало из https://github.com/mozilla/mozjpeg.git
Add back in cjpeg and djpeg utilities for testing purposes
git-svn-id: svn+ssh://svn.code.sf.net/p/libjpeg-turbo/code/trunk@46 632fc199-4ca6-4c93-a231-07263d6284db
This commit is contained in:
DRC
Коммит
73de982473
18
Makefile.am
18
Makefile.am
|
|
@ -22,7 +22,7 @@ endif
|
|||
|
||||
TSTHDRS = turbojpeg.h rrutil.h rrtimer.h
|
||||
|
||||
noinst_PROGRAMS = jpgtest jpegut
|
||||
noinst_PROGRAMS = jpgtest jpegut cjpeg djpeg
|
||||
|
||||
jpgtest_SOURCES = $(TSTHDRS) jpgtest.cxx bmp.c turbojpegl.c
|
||||
|
||||
|
|
@ -31,3 +31,19 @@ jpgtest_LDADD = $(top_srcdir)/libjpeg.la
|
|||
jpegut_SOURCES = $(TSTHDRS) jpegut.c bmp.c turbojpegl.c
|
||||
|
||||
jpegut_LDADD = $(top_srcdir)/libjpeg.la
|
||||
|
||||
cjpeg_SOURCES = cdjpeg.h cderror.h cdjpeg.c cjpeg.c rdbmp.c rdgif.c \
|
||||
rdppm.c rdswitch.c rdtarga.c
|
||||
|
||||
cjpeg_LDADD = $(top_srcdir)/libjpeg.la
|
||||
|
||||
cjpeg_CFLAGS = -DBMP_SUPPORTED -DGIF_SUPPORTED -DPPM_SUPPORTED \
|
||||
-DTARGA_SUPPORTED
|
||||
|
||||
djpeg_SOURCES = cdjpeg.h cderror.h cdjpeg.c djpeg.c rdcolmap.c rdswitch.c \
|
||||
wrbmp.c wrgif.c wrppm.c wrtarga.c
|
||||
|
||||
djpeg_LDADD = $(top_srcdir)/libjpeg.la
|
||||
|
||||
djpeg_CFLAGS = -DBMP_SUPPORTED -DGIF_SUPPORTED -DPPM_SUPPORTED \
|
||||
-DTARGA_SUPPORTED
|
||||
|
|
|
|||
|
|
@ -0,0 +1,132 @@
|
|||
/*
|
||||
* cderror.h
|
||||
*
|
||||
* Copyright (C) 1994-1997, Thomas G. Lane.
|
||||
* This file is part of the Independent JPEG Group's software.
|
||||
* For conditions of distribution and use, see the accompanying README file.
|
||||
*
|
||||
* This file defines the error and message codes for the cjpeg/djpeg
|
||||
* applications. These strings are not needed as part of the JPEG library
|
||||
* proper.
|
||||
* Edit this file to add new codes, or to translate the message strings to
|
||||
* some other language.
|
||||
*/
|
||||
|
||||
/*
|
||||
* To define the enum list of message codes, include this file without
|
||||
* defining macro JMESSAGE. To create a message string table, include it
|
||||
* again with a suitable JMESSAGE definition (see jerror.c for an example).
|
||||
*/
|
||||
#ifndef JMESSAGE
|
||||
#ifndef CDERROR_H
|
||||
#define CDERROR_H
|
||||
/* First time through, define the enum list */
|
||||
#define JMAKE_ENUM_LIST
|
||||
#else
|
||||
/* Repeated inclusions of this file are no-ops unless JMESSAGE is defined */
|
||||
#define JMESSAGE(code,string)
|
||||
#endif /* CDERROR_H */
|
||||
#endif /* JMESSAGE */
|
||||
|
||||
#ifdef JMAKE_ENUM_LIST
|
||||
|
||||
typedef enum {
|
||||
|
||||
#define JMESSAGE(code,string) code ,
|
||||
|
||||
#endif /* JMAKE_ENUM_LIST */
|
||||
|
||||
JMESSAGE(JMSG_FIRSTADDONCODE=1000, NULL) /* Must be first entry! */
|
||||
|
||||
#ifdef BMP_SUPPORTED
|
||||
JMESSAGE(JERR_BMP_BADCMAP, "Unsupported BMP colormap format")
|
||||
JMESSAGE(JERR_BMP_BADDEPTH, "Only 8- and 24-bit BMP files are supported")
|
||||
JMESSAGE(JERR_BMP_BADHEADER, "Invalid BMP file: bad header length")
|
||||
JMESSAGE(JERR_BMP_BADPLANES, "Invalid BMP file: biPlanes not equal to 1")
|
||||
JMESSAGE(JERR_BMP_COLORSPACE, "BMP output must be grayscale or RGB")
|
||||
JMESSAGE(JERR_BMP_COMPRESSED, "Sorry, compressed BMPs not yet supported")
|
||||
JMESSAGE(JERR_BMP_NOT, "Not a BMP file - does not start with BM")
|
||||
JMESSAGE(JTRC_BMP, "%ux%u 24-bit BMP image")
|
||||
JMESSAGE(JTRC_BMP_MAPPED, "%ux%u 8-bit colormapped BMP image")
|
||||
JMESSAGE(JTRC_BMP_OS2, "%ux%u 24-bit OS2 BMP image")
|
||||
JMESSAGE(JTRC_BMP_OS2_MAPPED, "%ux%u 8-bit colormapped OS2 BMP image")
|
||||
#endif /* BMP_SUPPORTED */
|
||||
|
||||
#ifdef GIF_SUPPORTED
|
||||
JMESSAGE(JERR_GIF_BUG, "GIF output got confused")
|
||||
JMESSAGE(JERR_GIF_CODESIZE, "Bogus GIF codesize %d")
|
||||
JMESSAGE(JERR_GIF_COLORSPACE, "GIF output must be grayscale or RGB")
|
||||
JMESSAGE(JERR_GIF_IMAGENOTFOUND, "Too few images in GIF file")
|
||||
JMESSAGE(JERR_GIF_NOT, "Not a GIF file")
|
||||
JMESSAGE(JTRC_GIF, "%ux%ux%d GIF image")
|
||||
JMESSAGE(JTRC_GIF_BADVERSION,
|
||||
"Warning: unexpected GIF version number '%c%c%c'")
|
||||
JMESSAGE(JTRC_GIF_EXTENSION, "Ignoring GIF extension block of type 0x%02x")
|
||||
JMESSAGE(JTRC_GIF_NONSQUARE, "Caution: nonsquare pixels in input")
|
||||
JMESSAGE(JWRN_GIF_BADDATA, "Corrupt data in GIF file")
|
||||
JMESSAGE(JWRN_GIF_CHAR, "Bogus char 0x%02x in GIF file, ignoring")
|
||||
JMESSAGE(JWRN_GIF_ENDCODE, "Premature end of GIF image")
|
||||
JMESSAGE(JWRN_GIF_NOMOREDATA, "Ran out of GIF bits")
|
||||
#endif /* GIF_SUPPORTED */
|
||||
|
||||
#ifdef PPM_SUPPORTED
|
||||
JMESSAGE(JERR_PPM_COLORSPACE, "PPM output must be grayscale or RGB")
|
||||
JMESSAGE(JERR_PPM_NONNUMERIC, "Nonnumeric data in PPM file")
|
||||
JMESSAGE(JERR_PPM_NOT, "Not a PPM/PGM file")
|
||||
JMESSAGE(JTRC_PGM, "%ux%u PGM image")
|
||||
JMESSAGE(JTRC_PGM_TEXT, "%ux%u text PGM image")
|
||||
JMESSAGE(JTRC_PPM, "%ux%u PPM image")
|
||||
JMESSAGE(JTRC_PPM_TEXT, "%ux%u text PPM image")
|
||||
#endif /* PPM_SUPPORTED */
|
||||
|
||||
#ifdef RLE_SUPPORTED
|
||||
JMESSAGE(JERR_RLE_BADERROR, "Bogus error code from RLE library")
|
||||
JMESSAGE(JERR_RLE_COLORSPACE, "RLE output must be grayscale or RGB")
|
||||
JMESSAGE(JERR_RLE_DIMENSIONS, "Image dimensions (%ux%u) too large for RLE")
|
||||
JMESSAGE(JERR_RLE_EMPTY, "Empty RLE file")
|
||||
JMESSAGE(JERR_RLE_EOF, "Premature EOF in RLE header")
|
||||
JMESSAGE(JERR_RLE_MEM, "Insufficient memory for RLE header")
|
||||
JMESSAGE(JERR_RLE_NOT, "Not an RLE file")
|
||||
JMESSAGE(JERR_RLE_TOOMANYCHANNELS, "Cannot handle %d output channels for RLE")
|
||||
JMESSAGE(JERR_RLE_UNSUPPORTED, "Cannot handle this RLE setup")
|
||||
JMESSAGE(JTRC_RLE, "%ux%u full-color RLE file")
|
||||
JMESSAGE(JTRC_RLE_FULLMAP, "%ux%u full-color RLE file with map of length %d")
|
||||
JMESSAGE(JTRC_RLE_GRAY, "%ux%u grayscale RLE file")
|
||||
JMESSAGE(JTRC_RLE_MAPGRAY, "%ux%u grayscale RLE file with map of length %d")
|
||||
JMESSAGE(JTRC_RLE_MAPPED, "%ux%u colormapped RLE file with map of length %d")
|
||||
#endif /* RLE_SUPPORTED */
|
||||
|
||||
#ifdef TARGA_SUPPORTED
|
||||
JMESSAGE(JERR_TGA_BADCMAP, "Unsupported Targa colormap format")
|
||||
JMESSAGE(JERR_TGA_BADPARMS, "Invalid or unsupported Targa file")
|
||||
JMESSAGE(JERR_TGA_COLORSPACE, "Targa output must be grayscale or RGB")
|
||||
JMESSAGE(JTRC_TGA, "%ux%u RGB Targa image")
|
||||
JMESSAGE(JTRC_TGA_GRAY, "%ux%u grayscale Targa image")
|
||||
JMESSAGE(JTRC_TGA_MAPPED, "%ux%u colormapped Targa image")
|
||||
#else
|
||||
JMESSAGE(JERR_TGA_NOTCOMP, "Targa support was not compiled")
|
||||
#endif /* TARGA_SUPPORTED */
|
||||
|
||||
JMESSAGE(JERR_BAD_CMAP_FILE,
|
||||
"Color map file is invalid or of unsupported format")
|
||||
JMESSAGE(JERR_TOO_MANY_COLORS,
|
||||
"Output file format cannot handle %d colormap entries")
|
||||
JMESSAGE(JERR_UNGETC_FAILED, "ungetc failed")
|
||||
#ifdef TARGA_SUPPORTED
|
||||
JMESSAGE(JERR_UNKNOWN_FORMAT,
|
||||
"Unrecognized input file format --- perhaps you need -targa")
|
||||
#else
|
||||
JMESSAGE(JERR_UNKNOWN_FORMAT, "Unrecognized input file format")
|
||||
#endif
|
||||
JMESSAGE(JERR_UNSUPPORTED_FORMAT, "Unsupported output file format")
|
||||
|
||||
#ifdef JMAKE_ENUM_LIST
|
||||
|
||||
JMSG_LASTADDONCODE
|
||||
} ADDON_MESSAGE_CODE;
|
||||
|
||||
#undef JMAKE_ENUM_LIST
|
||||
#endif /* JMAKE_ENUM_LIST */
|
||||
|
||||
/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */
|
||||
#undef JMESSAGE
|
||||
|
|
@ -0,0 +1,181 @@
|
|||
/*
|
||||
* cdjpeg.c
|
||||
*
|
||||
* Copyright (C) 1991-1997, Thomas G. Lane.
|
||||
* This file is part of the Independent JPEG Group's software.
|
||||
* For conditions of distribution and use, see the accompanying README file.
|
||||
*
|
||||
* This file contains common support routines used by the IJG application
|
||||
* programs (cjpeg, djpeg, jpegtran).
|
||||
*/
|
||||
|
||||
#include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
|
||||
#include <ctype.h> /* to declare isupper(), tolower() */
|
||||
#ifdef NEED_SIGNAL_CATCHER
|
||||
#include <signal.h> /* to declare signal() */
|
||||
#endif
|
||||
#ifdef USE_SETMODE
|
||||
#include <fcntl.h> /* to declare setmode()'s parameter macros */
|
||||
/* If you have setmode() but not <io.h>, just delete this line: */
|
||||
#include <io.h> /* to declare setmode() */
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* Signal catcher to ensure that temporary files are removed before aborting.
|
||||
* NB: for Amiga Manx C this is actually a global routine named _abort();
|
||||
* we put "#define signal_catcher _abort" in jconfig.h. Talk about bogus...
|
||||
*/
|
||||
|
||||
#ifdef NEED_SIGNAL_CATCHER
|
||||
|
||||
static j_common_ptr sig_cinfo;
|
||||
|
||||
void /* must be global for Manx C */
|
||||
signal_catcher (int signum)
|
||||
{
|
||||
if (sig_cinfo != NULL) {
|
||||
if (sig_cinfo->err != NULL) /* turn off trace output */
|
||||
sig_cinfo->err->trace_level = 0;
|
||||
jpeg_destroy(sig_cinfo); /* clean up memory allocation & temp files */
|
||||
}
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
|
||||
GLOBAL(void)
|
||||
enable_signal_catcher (j_common_ptr cinfo)
|
||||
{
|
||||
sig_cinfo = cinfo;
|
||||
#ifdef SIGINT /* not all systems have SIGINT */
|
||||
signal(SIGINT, signal_catcher);
|
||||
#endif
|
||||
#ifdef SIGTERM /* not all systems have SIGTERM */
|
||||
signal(SIGTERM, signal_catcher);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* Optional progress monitor: display a percent-done figure on stderr.
|
||||
*/
|
||||
|
||||
#ifdef PROGRESS_REPORT
|
||||
|
||||
METHODDEF(void)
|
||||
progress_monitor (j_common_ptr cinfo)
|
||||
{
|
||||
cd_progress_ptr prog = (cd_progress_ptr) cinfo->progress;
|
||||
int total_passes = prog->pub.total_passes + prog->total_extra_passes;
|
||||
int percent_done = (int) (prog->pub.pass_counter*100L/prog->pub.pass_limit);
|
||||
|
||||
if (percent_done != prog->percent_done) {
|
||||
prog->percent_done = percent_done;
|
||||
if (total_passes > 1) {
|
||||
fprintf(stderr, "\rPass %d/%d: %3d%% ",
|
||||
prog->pub.completed_passes + prog->completed_extra_passes + 1,
|
||||
total_passes, percent_done);
|
||||
} else {
|
||||
fprintf(stderr, "\r %3d%% ", percent_done);
|
||||
}
|
||||
fflush(stderr);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
GLOBAL(void)
|
||||
start_progress_monitor (j_common_ptr cinfo, cd_progress_ptr progress)
|
||||
{
|
||||
/* Enable progress display, unless trace output is on */
|
||||
if (cinfo->err->trace_level == 0) {
|
||||
progress->pub.progress_monitor = progress_monitor;
|
||||
progress->completed_extra_passes = 0;
|
||||
progress->total_extra_passes = 0;
|
||||
progress->percent_done = -1;
|
||||
cinfo->progress = &progress->pub;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
GLOBAL(void)
|
||||
end_progress_monitor (j_common_ptr cinfo)
|
||||
{
|
||||
/* Clear away progress display */
|
||||
if (cinfo->err->trace_level == 0) {
|
||||
fprintf(stderr, "\r \r");
|
||||
fflush(stderr);
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* Case-insensitive matching of possibly-abbreviated keyword switches.
|
||||
* keyword is the constant keyword (must be lower case already),
|
||||
* minchars is length of minimum legal abbreviation.
|
||||
*/
|
||||
|
||||
GLOBAL(boolean)
|
||||
keymatch (char * arg, const char * keyword, int minchars)
|
||||
{
|
||||
register int ca, ck;
|
||||
register int nmatched = 0;
|
||||
|
||||
while ((ca = *arg++) != '\0') {
|
||||
if ((ck = *keyword++) == '\0')
|
||||
return FALSE; /* arg longer than keyword, no good */
|
||||
if (isupper(ca)) /* force arg to lcase (assume ck is already) */
|
||||
ca = tolower(ca);
|
||||
if (ca != ck)
|
||||
return FALSE; /* no good */
|
||||
nmatched++; /* count matched characters */
|
||||
}
|
||||
/* reached end of argument; fail if it's too short for unique abbrev */
|
||||
if (nmatched < minchars)
|
||||
return FALSE;
|
||||
return TRUE; /* A-OK */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Routines to establish binary I/O mode for stdin and stdout.
|
||||
* Non-Unix systems often require some hacking to get out of text mode.
|
||||
*/
|
||||
|
||||
GLOBAL(FILE *)
|
||||
read_stdin (void)
|
||||
{
|
||||
FILE * input_file = stdin;
|
||||
|
||||
#ifdef USE_SETMODE /* need to hack file mode? */
|
||||
setmode(fileno(stdin), O_BINARY);
|
||||
#endif
|
||||
#ifdef USE_FDOPEN /* need to re-open in binary mode? */
|
||||
if ((input_file = fdopen(fileno(stdin), READ_BINARY)) == NULL) {
|
||||
fprintf(stderr, "Cannot reopen stdin\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
#endif
|
||||
return input_file;
|
||||
}
|
||||
|
||||
|
||||
GLOBAL(FILE *)
|
||||
write_stdout (void)
|
||||
{
|
||||
FILE * output_file = stdout;
|
||||
|
||||
#ifdef USE_SETMODE /* need to hack file mode? */
|
||||
setmode(fileno(stdout), O_BINARY);
|
||||
#endif
|
||||
#ifdef USE_FDOPEN /* need to re-open in binary mode? */
|
||||
if ((output_file = fdopen(fileno(stdout), WRITE_BINARY)) == NULL) {
|
||||
fprintf(stderr, "Cannot reopen stdout\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
#endif
|
||||
return output_file;
|
||||
}
|
||||
|
|
@ -0,0 +1,184 @@
|
|||
/*
|
||||
* cdjpeg.h
|
||||
*
|
||||
* Copyright (C) 1994-1997, Thomas G. Lane.
|
||||
* This file is part of the Independent JPEG Group's software.
|
||||
* For conditions of distribution and use, see the accompanying README file.
|
||||
*
|
||||
* This file contains common declarations for the sample applications
|
||||
* cjpeg and djpeg. It is NOT used by the core JPEG library.
|
||||
*/
|
||||
|
||||
#define JPEG_CJPEG_DJPEG /* define proper options in jconfig.h */
|
||||
#define JPEG_INTERNAL_OPTIONS /* cjpeg.c,djpeg.c need to see xxx_SUPPORTED */
|
||||
#include "jinclude.h"
|
||||
#include "jpeglib.h"
|
||||
#include "jerror.h" /* get library error codes too */
|
||||
#include "cderror.h" /* get application-specific error codes */
|
||||
|
||||
|
||||
/*
|
||||
* Object interface for cjpeg's source file decoding modules
|
||||
*/
|
||||
|
||||
typedef struct cjpeg_source_struct * cjpeg_source_ptr;
|
||||
|
||||
struct cjpeg_source_struct {
|
||||
JMETHOD(void, start_input, (j_compress_ptr cinfo,
|
||||
cjpeg_source_ptr sinfo));
|
||||
JMETHOD(JDIMENSION, get_pixel_rows, (j_compress_ptr cinfo,
|
||||
cjpeg_source_ptr sinfo));
|
||||
JMETHOD(void, finish_input, (j_compress_ptr cinfo,
|
||||
cjpeg_source_ptr sinfo));
|
||||
|
||||
FILE *input_file;
|
||||
|
||||
JSAMPARRAY buffer;
|
||||
JDIMENSION buffer_height;
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Object interface for djpeg's output file encoding modules
|
||||
*/
|
||||
|
||||
typedef struct djpeg_dest_struct * djpeg_dest_ptr;
|
||||
|
||||
struct djpeg_dest_struct {
|
||||
/* start_output is called after jpeg_start_decompress finishes.
|
||||
* The color map will be ready at this time, if one is needed.
|
||||
*/
|
||||
JMETHOD(void, start_output, (j_decompress_ptr cinfo,
|
||||
djpeg_dest_ptr dinfo));
|
||||
/* Emit the specified number of pixel rows from the buffer. */
|
||||
JMETHOD(void, put_pixel_rows, (j_decompress_ptr cinfo,
|
||||
djpeg_dest_ptr dinfo,
|
||||
JDIMENSION rows_supplied));
|
||||
/* Finish up at the end of the image. */
|
||||
JMETHOD(void, finish_output, (j_decompress_ptr cinfo,
|
||||
djpeg_dest_ptr dinfo));
|
||||
|
||||
/* Target file spec; filled in by djpeg.c after object is created. */
|
||||
FILE * output_file;
|
||||
|
||||
/* Output pixel-row buffer. Created by module init or start_output.
|
||||
* Width is cinfo->output_width * cinfo->output_components;
|
||||
* height is buffer_height.
|
||||
*/
|
||||
JSAMPARRAY buffer;
|
||||
JDIMENSION buffer_height;
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* cjpeg/djpeg may need to perform extra passes to convert to or from
|
||||
* the source/destination file format. The JPEG library does not know
|
||||
* about these passes, but we'd like them to be counted by the progress
|
||||
* monitor. We use an expanded progress monitor object to hold the
|
||||
* additional pass count.
|
||||
*/
|
||||
|
||||
struct cdjpeg_progress_mgr {
|
||||
struct jpeg_progress_mgr pub; /* fields known to JPEG library */
|
||||
int completed_extra_passes; /* extra passes completed */
|
||||
int total_extra_passes; /* total extra */
|
||||
/* last printed percentage stored here to avoid multiple printouts */
|
||||
int percent_done;
|
||||
};
|
||||
|
||||
typedef struct cdjpeg_progress_mgr * cd_progress_ptr;
|
||||
|
||||
|
||||
/* Short forms of external names for systems with brain-damaged linkers. */
|
||||
|
||||
#ifdef NEED_SHORT_EXTERNAL_NAMES
|
||||
#define jinit_read_bmp jIRdBMP
|
||||
#define jinit_write_bmp jIWrBMP
|
||||
#define jinit_read_gif jIRdGIF
|
||||
#define jinit_write_gif jIWrGIF
|
||||
#define jinit_read_ppm jIRdPPM
|
||||
#define jinit_write_ppm jIWrPPM
|
||||
#define jinit_read_rle jIRdRLE
|
||||
#define jinit_write_rle jIWrRLE
|
||||
#define jinit_read_targa jIRdTarga
|
||||
#define jinit_write_targa jIWrTarga
|
||||
#define read_quant_tables RdQTables
|
||||
#define read_scan_script RdScnScript
|
||||
#define set_quant_slots SetQSlots
|
||||
#define set_sample_factors SetSFacts
|
||||
#define read_color_map RdCMap
|
||||
#define enable_signal_catcher EnSigCatcher
|
||||
#define start_progress_monitor StProgMon
|
||||
#define end_progress_monitor EnProgMon
|
||||
#define read_stdin RdStdin
|
||||
#define write_stdout WrStdout
|
||||
#endif /* NEED_SHORT_EXTERNAL_NAMES */
|
||||
|
||||
/* Module selection routines for I/O modules. */
|
||||
|
||||
EXTERN(cjpeg_source_ptr) jinit_read_bmp JPP((j_compress_ptr cinfo));
|
||||
EXTERN(djpeg_dest_ptr) jinit_write_bmp JPP((j_decompress_ptr cinfo,
|
||||
boolean is_os2));
|
||||
EXTERN(cjpeg_source_ptr) jinit_read_gif JPP((j_compress_ptr cinfo));
|
||||
EXTERN(djpeg_dest_ptr) jinit_write_gif JPP((j_decompress_ptr cinfo));
|
||||
EXTERN(cjpeg_source_ptr) jinit_read_ppm JPP((j_compress_ptr cinfo));
|
||||
EXTERN(djpeg_dest_ptr) jinit_write_ppm JPP((j_decompress_ptr cinfo));
|
||||
EXTERN(cjpeg_source_ptr) jinit_read_rle JPP((j_compress_ptr cinfo));
|
||||
EXTERN(djpeg_dest_ptr) jinit_write_rle JPP((j_decompress_ptr cinfo));
|
||||
EXTERN(cjpeg_source_ptr) jinit_read_targa JPP((j_compress_ptr cinfo));
|
||||
EXTERN(djpeg_dest_ptr) jinit_write_targa JPP((j_decompress_ptr cinfo));
|
||||
|
||||
/* cjpeg support routines (in rdswitch.c) */
|
||||
|
||||
EXTERN(boolean) read_quant_tables JPP((j_compress_ptr cinfo, char * filename,
|
||||
int scale_factor, boolean force_baseline));
|
||||
EXTERN(boolean) read_scan_script JPP((j_compress_ptr cinfo, char * filename));
|
||||
EXTERN(boolean) set_quant_slots JPP((j_compress_ptr cinfo, char *arg));
|
||||
EXTERN(boolean) set_sample_factors JPP((j_compress_ptr cinfo, char *arg));
|
||||
|
||||
/* djpeg support routines (in rdcolmap.c) */
|
||||
|
||||
EXTERN(void) read_color_map JPP((j_decompress_ptr cinfo, FILE * infile));
|
||||
|
||||
/* common support routines (in cdjpeg.c) */
|
||||
|
||||
EXTERN(void) enable_signal_catcher JPP((j_common_ptr cinfo));
|
||||
EXTERN(void) start_progress_monitor JPP((j_common_ptr cinfo,
|
||||
cd_progress_ptr progress));
|
||||
EXTERN(void) end_progress_monitor JPP((j_common_ptr cinfo));
|
||||
EXTERN(boolean) keymatch JPP((char * arg, const char * keyword, int minchars));
|
||||
EXTERN(FILE *) read_stdin JPP((void));
|
||||
EXTERN(FILE *) write_stdout JPP((void));
|
||||
|
||||
/* miscellaneous useful macros */
|
||||
|
||||
#ifdef DONT_USE_B_MODE /* define mode parameters for fopen() */
|
||||
#define READ_BINARY "r"
|
||||
#define WRITE_BINARY "w"
|
||||
#else
|
||||
#ifdef VMS /* VMS is very nonstandard */
|
||||
#define READ_BINARY "rb", "ctx=stm"
|
||||
#define WRITE_BINARY "wb", "ctx=stm"
|
||||
#else /* standard ANSI-compliant case */
|
||||
#define READ_BINARY "rb"
|
||||
#define WRITE_BINARY "wb"
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef EXIT_FAILURE /* define exit() codes if not provided */
|
||||
#define EXIT_FAILURE 1
|
||||
#endif
|
||||
#ifndef EXIT_SUCCESS
|
||||
#ifdef VMS
|
||||
#define EXIT_SUCCESS 1 /* VMS is very nonstandard */
|
||||
#else
|
||||
#define EXIT_SUCCESS 0
|
||||
#endif
|
||||
#endif
|
||||
#ifndef EXIT_WARNING
|
||||
#ifdef VMS
|
||||
#define EXIT_WARNING 1 /* VMS is very nonstandard */
|
||||
#else
|
||||
#define EXIT_WARNING 2
|
||||
#endif
|
||||
#endif
|
||||
|
|
@ -0,0 +1,606 @@
|
|||
/*
|
||||
* cjpeg.c
|
||||
*
|
||||
* Copyright (C) 1991-1998, Thomas G. Lane.
|
||||
* This file is part of the Independent JPEG Group's software.
|
||||
* For conditions of distribution and use, see the accompanying README file.
|
||||
*
|
||||
* This file contains a command-line user interface for the JPEG compressor.
|
||||
* It should work on any system with Unix- or MS-DOS-style command lines.
|
||||
*
|
||||
* Two different command line styles are permitted, depending on the
|
||||
* compile-time switch TWO_FILE_COMMANDLINE:
|
||||
* cjpeg [options] inputfile outputfile
|
||||
* cjpeg [options] [inputfile]
|
||||
* In the second style, output is always to standard output, which you'd
|
||||
* normally redirect to a file or pipe to some other program. Input is
|
||||
* either from a named file or from standard input (typically redirected).
|
||||
* The second style is convenient on Unix but is unhelpful on systems that
|
||||
* don't support pipes. Also, you MUST use the first style if your system
|
||||
* doesn't do binary I/O to stdin/stdout.
|
||||
* To simplify script writing, the "-outfile" switch is provided. The syntax
|
||||
* cjpeg [options] -outfile outputfile inputfile
|
||||
* works regardless of which command line style is used.
|
||||
*/
|
||||
|
||||
#include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
|
||||
#include "jversion.h" /* for version message */
|
||||
|
||||
#ifdef USE_CCOMMAND /* command-line reader for Macintosh */
|
||||
#ifdef __MWERKS__
|
||||
#include <SIOUX.h> /* Metrowerks needs this */
|
||||
#include <console.h> /* ... and this */
|
||||
#endif
|
||||
#ifdef THINK_C
|
||||
#include <console.h> /* Think declares it here */
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
/* Create the add-on message string table. */
|
||||
|
||||
#define JMESSAGE(code,string) string ,
|
||||
|
||||
static const char * const cdjpeg_message_table[] = {
|
||||
#include "cderror.h"
|
||||
NULL
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* This routine determines what format the input file is,
|
||||
* and selects the appropriate input-reading module.
|
||||
*
|
||||
* To determine which family of input formats the file belongs to,
|
||||
* we may look only at the first byte of the file, since C does not
|
||||
* guarantee that more than one character can be pushed back with ungetc.
|
||||
* Looking at additional bytes would require one of these approaches:
|
||||
* 1) assume we can fseek() the input file (fails for piped input);
|
||||
* 2) assume we can push back more than one character (works in
|
||||
* some C implementations, but unportable);
|
||||
* 3) provide our own buffering (breaks input readers that want to use
|
||||
* stdio directly, such as the RLE library);
|
||||
* or 4) don't put back the data, and modify the input_init methods to assume
|
||||
* they start reading after the start of file (also breaks RLE library).
|
||||
* #1 is attractive for MS-DOS but is untenable on Unix.
|
||||
*
|
||||
* The most portable solution for file types that can't be identified by their
|
||||
* first byte is to make the user tell us what they are. This is also the
|
||||
* only approach for "raw" file types that contain only arbitrary values.
|
||||
* We presently apply this method for Targa files. Most of the time Targa
|
||||
* files start with 0x00, so we recognize that case. Potentially, however,
|
||||
* a Targa file could start with any byte value (byte 0 is the length of the
|
||||
* seldom-used ID field), so we provide a switch to force Targa input mode.
|
||||
*/
|
||||
|
||||
static boolean is_targa; /* records user -targa switch */
|
||||
|
||||
|
||||
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; /* suppress compiler warnings */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Argument-parsing code.
|
||||
* The switch parser is designed to be useful with DOS-style command line
|
||||
* syntax, ie, intermixed switches and file names, where only the switches
|
||||
* to the left of a given file name affect processing of that file.
|
||||
* The main program in this file doesn't actually use this capability...
|
||||
*/
|
||||
|
||||
|
||||
static const char * progname; /* program name for error messages */
|
||||
static char * outfilename; /* for -outfile switch */
|
||||
|
||||
|
||||
LOCAL(void)
|
||||
usage (void)
|
||||
/* complain about bad command line */
|
||||
{
|
||||
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);
|
||||
}
|
||||
|
||||
|
||||
LOCAL(int)
|
||||
parse_switches (j_compress_ptr cinfo, int argc, char **argv,
|
||||
int last_file_arg_seen, boolean for_real)
|
||||
/* Parse optional switches.
|
||||
* Returns argv[] index of first file-name argument (== argc if none).
|
||||
* Any file names with indexes <= last_file_arg_seen are ignored;
|
||||
* they have presumably been processed in a previous iteration.
|
||||
* (Pass 0 for last_file_arg_seen on the first or only iteration.)
|
||||
* for_real is FALSE on the first (dummy) pass; we may skip any expensive
|
||||
* processing.
|
||||
*/
|
||||
{
|
||||
int argn;
|
||||
char * arg;
|
||||
int quality; /* -quality parameter */
|
||||
int q_scale_factor; /* scaling percentage for -qtables */
|
||||
boolean force_baseline;
|
||||
boolean simple_progressive;
|
||||
char * qtablefile = NULL; /* saves -qtables filename if any */
|
||||
char * qslotsarg = NULL; /* saves -qslots parm if any */
|
||||
char * samplearg = NULL; /* saves -sample parm if any */
|
||||
char * scansarg = NULL; /* saves -scans parm if any */
|
||||
|
||||
/* Set up default JPEG parameters. */
|
||||
/* Note that default -quality level need not, and does not,
|
||||
* match the default scaling for an explicit -qtables argument.
|
||||
*/
|
||||
quality = 75; /* default -quality value */
|
||||
q_scale_factor = 100; /* default to no scaling for -qtables */
|
||||
force_baseline = FALSE; /* by default, allow 16-bit quantizers */
|
||||
simple_progressive = FALSE;
|
||||
is_targa = FALSE;
|
||||
outfilename = NULL;
|
||||
cinfo->err->trace_level = 0;
|
||||
|
||||
/* Scan command line options, adjust parameters */
|
||||
|
||||
for (argn = 1; argn < argc; argn++) {
|
||||
arg = argv[argn];
|
||||
if (*arg != '-') {
|
||||
/* Not a switch, must be a file name argument */
|
||||
if (argn <= last_file_arg_seen) {
|
||||
outfilename = NULL; /* -outfile applies to just one input file */
|
||||
continue; /* ignore this name if previously processed */
|
||||
}
|
||||
break; /* else done parsing switches */
|
||||
}
|
||||
arg++; /* advance past switch marker character */
|
||||
|
||||
if (keymatch(arg, "arithmetic", 1)) {
|
||||
/* Use arithmetic coding. */
|
||||
#ifdef C_ARITH_CODING_SUPPORTED
|
||||
cinfo->arith_code = TRUE;
|
||||
#else
|
||||
fprintf(stderr, "%s: sorry, arithmetic coding not supported\n",
|
||||
progname);
|
||||
exit(EXIT_FAILURE);
|
||||
#endif
|
||||
|
||||
} else if (keymatch(arg, "baseline", 1)) {
|
||||
/* Force baseline-compatible output (8-bit quantizer values). */
|
||||
force_baseline = TRUE;
|
||||
|
||||
} else if (keymatch(arg, "dct", 2)) {
|
||||
/* Select DCT algorithm. */
|
||||
if (++argn >= argc) /* advance to next argument */
|
||||
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)) {
|
||||
/* Enable debug printouts. */
|
||||
/* On first -d, print version identification */
|
||||
static boolean printed_version = FALSE;
|
||||
|
||||
if (! printed_version) {
|
||||
fprintf(stderr, "Independent JPEG Group's CJPEG, version %s\n%s\n",
|
||||
JVERSION, JCOPYRIGHT);
|
||||
printed_version = TRUE;
|
||||
}
|
||||
cinfo->err->trace_level++;
|
||||
|
||||
} else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) {
|
||||
/* Force a monochrome JPEG file to be generated. */
|
||||
jpeg_set_colorspace(cinfo, JCS_GRAYSCALE);
|
||||
|
||||
} else if (keymatch(arg, "maxmemory", 3)) {
|
||||
/* Maximum memory in Kb (or Mb with 'm'). */
|
||||
long lval;
|
||||
char ch = 'x';
|
||||
|
||||
if (++argn >= argc) /* advance to next argument */
|
||||
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)) {
|
||||
/* Enable entropy parm optimization. */
|
||||
#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)) {
|
||||
/* Set output file name. */
|
||||
if (++argn >= argc) /* advance to next argument */
|
||||
usage();
|
||||
outfilename = argv[argn]; /* save it away for later use */
|
||||
|
||||
} else if (keymatch(arg, "progressive", 1)) {
|
||||
/* Select simple progressive mode. */
|
||||
#ifdef C_PROGRESSIVE_SUPPORTED
|
||||
simple_progressive = TRUE;
|
||||
/* We must postpone execution until num_components is known. */
|
||||
#else
|
||||
fprintf(stderr, "%s: sorry, progressive output was not compiled\n",
|
||||
progname);
|
||||
exit(EXIT_FAILURE);
|
||||
#endif
|
||||
|
||||
} else if (keymatch(arg, "quality", 1)) {
|
||||
/* Quality factor (quantization table scaling factor). */
|
||||
if (++argn >= argc) /* advance to next argument */
|
||||
usage();
|
||||
if (sscanf(argv[argn], "%d", &quality) != 1)
|
||||
usage();
|
||||
/* Change scale factor in case -qtables is present. */
|
||||
q_scale_factor = jpeg_quality_scaling(quality);
|
||||
|
||||
} else if (keymatch(arg, "qslots", 2)) {
|
||||
/* Quantization table slot numbers. */
|
||||
if (++argn >= argc) /* advance to next argument */
|
||||
usage();
|
||||
qslotsarg = argv[argn];
|
||||
/* Must delay setting qslots until after we have processed any
|
||||
* colorspace-determining switches, since jpeg_set_colorspace sets
|
||||
* default quant table numbers.
|
||||
*/
|
||||
|
||||
} else if (keymatch(arg, "qtables", 2)) {
|
||||
/* Quantization tables fetched from file. */
|
||||
if (++argn >= argc) /* advance to next argument */
|
||||
usage();
|
||||
qtablefile = argv[argn];
|
||||
/* We postpone actually reading the file in case -quality comes later. */
|
||||
|
||||
} else if (keymatch(arg, "restart", 1)) {
|
||||
/* Restart interval in MCU rows (or in MCUs with 'b'). */
|
||||
long lval;
|
||||
char ch = 'x';
|
||||
|
||||
if (++argn >= argc) /* advance to next argument */
|
||||
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 prior '-restart n' overrides me */
|
||||
} else {
|
||||
cinfo->restart_in_rows = (int) lval;
|
||||
/* restart_interval will be computed during startup */
|
||||
}
|
||||
|
||||
} else if (keymatch(arg, "sample", 2)) {
|
||||
/* Set sampling factors. */
|
||||
if (++argn >= argc) /* advance to next argument */
|
||||
usage();
|
||||
samplearg = argv[argn];
|
||||
/* Must delay setting sample factors until after we have processed any
|
||||
* colorspace-determining switches, since jpeg_set_colorspace sets
|
||||
* default sampling factors.
|
||||
*/
|
||||
|
||||
} else if (keymatch(arg, "scans", 2)) {
|
||||
/* Set scan script. */
|
||||
#ifdef C_MULTISCAN_FILES_SUPPORTED
|
||||
if (++argn >= argc) /* advance to next argument */
|
||||
usage();
|
||||
scansarg = argv[argn];
|
||||
/* We must postpone reading the file in case -progressive appears. */
|
||||
#else
|
||||
fprintf(stderr, "%s: sorry, multi-scan output was not compiled\n",
|
||||
progname);
|
||||
exit(EXIT_FAILURE);
|
||||
#endif
|
||||
|
||||
} else if (keymatch(arg, "smooth", 2)) {
|
||||
/* Set input smoothing factor. */
|
||||
int val;
|
||||
|
||||
if (++argn >= argc) /* advance to next argument */
|
||||
usage();
|
||||
if (sscanf(argv[argn], "%d", &val) != 1)
|
||||
usage();
|
||||
if (val < 0 || val > 100)
|
||||
usage();
|
||||
cinfo->smoothing_factor = val;
|
||||
|
||||
} else if (keymatch(arg, "targa", 1)) {
|
||||
/* Input file is Targa format. */
|
||||
is_targa = TRUE;
|
||||
|
||||
} else {
|
||||
usage(); /* bogus switch */
|
||||
}
|
||||
}
|
||||
|
||||
/* Post-switch-scanning cleanup */
|
||||
|
||||
if (for_real) {
|
||||
|
||||
/* Set quantization tables for selected quality. */
|
||||
/* Some or all may be overridden if -qtables is present. */
|
||||
jpeg_set_quality(cinfo, quality, force_baseline);
|
||||
|
||||
if (qtablefile != NULL) /* process -qtables if it was present */
|
||||
if (! read_quant_tables(cinfo, qtablefile,
|
||||
q_scale_factor, force_baseline))
|
||||
usage();
|
||||
|
||||
if (qslotsarg != NULL) /* process -qslots if it was present */
|
||||
if (! set_quant_slots(cinfo, qslotsarg))
|
||||
usage();
|
||||
|
||||
if (samplearg != NULL) /* process -sample if it was present */
|
||||
if (! set_sample_factors(cinfo, samplearg))
|
||||
usage();
|
||||
|
||||
#ifdef C_PROGRESSIVE_SUPPORTED
|
||||
if (simple_progressive) /* process -progressive; -scans can override */
|
||||
jpeg_simple_progression(cinfo);
|
||||
#endif
|
||||
|
||||
#ifdef C_MULTISCAN_FILES_SUPPORTED
|
||||
if (scansarg != NULL) /* process -scans if it was present */
|
||||
if (! read_scan_script(cinfo, scansarg))
|
||||
usage();
|
||||
#endif
|
||||
}
|
||||
|
||||
return argn; /* return index of next arg (file name) */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* The main program.
|
||||
*/
|
||||
|
||||
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;
|
||||
|
||||
/* On Mac, fetch a command line. */
|
||||
#ifdef USE_CCOMMAND
|
||||
argc = ccommand(&argv);
|
||||
#endif
|
||||
|
||||
progname = argv[0];
|
||||
if (progname == NULL || progname[0] == 0)
|
||||
progname = "cjpeg"; /* in case C library doesn't provide it */
|
||||
|
||||
/* Initialize the JPEG compression object with default error handling. */
|
||||
cinfo.err = jpeg_std_error(&jerr);
|
||||
jpeg_create_compress(&cinfo);
|
||||
/* Add some application-specific error messages (from cderror.h) */
|
||||
jerr.addon_message_table = cdjpeg_message_table;
|
||||
jerr.first_addon_message = JMSG_FIRSTADDONCODE;
|
||||
jerr.last_addon_message = JMSG_LASTADDONCODE;
|
||||
|
||||
/* Now safe to enable signal catcher. */
|
||||
#ifdef NEED_SIGNAL_CATCHER
|
||||
enable_signal_catcher((j_common_ptr) &cinfo);
|
||||
#endif
|
||||
|
||||
/* Initialize JPEG parameters.
|
||||
* Much of this may be overridden later.
|
||||
* In particular, we don't yet know the input file's color space,
|
||||
* but we need to provide some value for jpeg_set_defaults() to work.
|
||||
*/
|
||||
|
||||
cinfo.in_color_space = JCS_RGB; /* arbitrary guess */
|
||||
jpeg_set_defaults(&cinfo);
|
||||
|
||||
/* Scan command line to find file names.
|
||||
* It is convenient to use just one switch-parsing routine, but the switch
|
||||
* values read here are ignored; we will rescan the switches after opening
|
||||
* the input file.
|
||||
*/
|
||||
|
||||
file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
|
||||
|
||||
#ifdef TWO_FILE_COMMANDLINE
|
||||
/* Must have either -outfile switch or explicit output file name */
|
||||
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();
|
||||
}
|
||||
}
|
||||
#else
|
||||
/* Unix style: expect zero or one file name */
|
||||
if (file_index < argc-1) {
|
||||
fprintf(stderr, "%s: only one input file\n", progname);
|
||||
usage();
|
||||
}
|
||||
#endif /* TWO_FILE_COMMANDLINE */
|
||||
|
||||
/* Open the input file. */
|
||||
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);
|
||||
}
|
||||
} else {
|
||||
/* default input file is stdin */
|
||||
input_file = read_stdin();
|
||||
}
|
||||
|
||||
/* Open the output file. */
|
||||
if (outfilename != NULL) {
|
||||
if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
|
||||
fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
} else {
|
||||
/* default output file is stdout */
|
||||
output_file = write_stdout();
|
||||
}
|
||||
|
||||
#ifdef PROGRESS_REPORT
|
||||
start_progress_monitor((j_common_ptr) &cinfo, &progress);
|
||||
#endif
|
||||
|
||||
/* Figure out the input file format, and set up to read it. */
|
||||
src_mgr = select_file_type(&cinfo, input_file);
|
||||
src_mgr->input_file = input_file;
|
||||
|
||||
/* Read the input file header to obtain file size & colorspace. */
|
||||
(*src_mgr->start_input) (&cinfo, src_mgr);
|
||||
|
||||
/* Now that we know input colorspace, fix colorspace-dependent defaults */
|
||||
jpeg_default_colorspace(&cinfo);
|
||||
|
||||
/* Adjust default compression parameters by re-parsing the options */
|
||||
file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
|
||||
|
||||
/* Specify data destination for compression */
|
||||
jpeg_stdio_dest(&cinfo, output_file);
|
||||
|
||||
/* Start compressor */
|
||||
jpeg_start_compress(&cinfo, TRUE);
|
||||
|
||||
/* Process data */
|
||||
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);
|
||||
}
|
||||
|
||||
/* Finish compression and release memory */
|
||||
(*src_mgr->finish_input) (&cinfo, src_mgr);
|
||||
jpeg_finish_compress(&cinfo);
|
||||
jpeg_destroy_compress(&cinfo);
|
||||
|
||||
/* Close files, if we opened them */
|
||||
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
|
||||
|
||||
/* All done. */
|
||||
exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
|
||||
return 0; /* suppress no-return-value warnings */
|
||||
}
|
||||
|
|
@ -0,0 +1,616 @@
|
|||
/*
|
||||
* djpeg.c
|
||||
*
|
||||
* Copyright (C) 1991-1997, Thomas G. Lane.
|
||||
* This file is part of the Independent JPEG Group's software.
|
||||
* For conditions of distribution and use, see the accompanying README file.
|
||||
*
|
||||
* This file contains a command-line user interface for the JPEG decompressor.
|
||||
* It should work on any system with Unix- or MS-DOS-style command lines.
|
||||
*
|
||||
* Two different command line styles are permitted, depending on the
|
||||
* compile-time switch TWO_FILE_COMMANDLINE:
|
||||
* djpeg [options] inputfile outputfile
|
||||
* djpeg [options] [inputfile]
|
||||
* In the second style, output is always to standard output, which you'd
|
||||
* normally redirect to a file or pipe to some other program. Input is
|
||||
* either from a named file or from standard input (typically redirected).
|
||||
* The second style is convenient on Unix but is unhelpful on systems that
|
||||
* don't support pipes. Also, you MUST use the first style if your system
|
||||
* doesn't do binary I/O to stdin/stdout.
|
||||
* To simplify script writing, the "-outfile" switch is provided. The syntax
|
||||
* djpeg [options] -outfile outputfile inputfile
|
||||
* works regardless of which command line style is used.
|
||||
*/
|
||||
|
||||
#include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
|
||||
#include "jversion.h" /* for version message */
|
||||
|
||||
#include <ctype.h> /* to declare isprint() */
|
||||
|
||||
#ifdef USE_CCOMMAND /* command-line reader for Macintosh */
|
||||
#ifdef __MWERKS__
|
||||
#include <SIOUX.h> /* Metrowerks needs this */
|
||||
#include <console.h> /* ... and this */
|
||||
#endif
|
||||
#ifdef THINK_C
|
||||
#include <console.h> /* Think declares it here */
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
/* Create the add-on message string table. */
|
||||
|
||||
#define JMESSAGE(code,string) string ,
|
||||
|
||||
static const char * const cdjpeg_message_table[] = {
|
||||
#include "cderror.h"
|
||||
NULL
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* This list defines the known output image formats
|
||||
* (not all of which need be supported by a given version).
|
||||
* You can change the default output format by defining DEFAULT_FMT;
|
||||
* indeed, you had better do so if you undefine PPM_SUPPORTED.
|
||||
*/
|
||||
|
||||
typedef enum {
|
||||
FMT_BMP, /* BMP format (Windows flavor) */
|
||||
FMT_GIF, /* GIF format */
|
||||
FMT_OS2, /* BMP format (OS/2 flavor) */
|
||||
FMT_PPM, /* PPM/PGM (PBMPLUS formats) */
|
||||
FMT_RLE, /* RLE format */
|
||||
FMT_TARGA, /* Targa format */
|
||||
FMT_TIFF /* TIFF format */
|
||||
} IMAGE_FORMATS;
|
||||
|
||||
#ifndef DEFAULT_FMT /* so can override from CFLAGS in Makefile */
|
||||
#define DEFAULT_FMT FMT_PPM
|
||||
#endif
|
||||
|
||||
static IMAGE_FORMATS requested_fmt;
|
||||
|
||||
|
||||
/*
|
||||
* Argument-parsing code.
|
||||
* The switch parser is designed to be useful with DOS-style command line
|
||||
* syntax, ie, intermixed switches and file names, where only the switches
|
||||
* to the left of a given file name affect processing of that file.
|
||||
* The main program in this file doesn't actually use this capability...
|
||||
*/
|
||||
|
||||
|
||||
static const char * progname; /* program name for error messages */
|
||||
static char * outfilename; /* for -outfile switch */
|
||||
|
||||
|
||||
LOCAL(void)
|
||||
usage (void)
|
||||
/* complain about bad command line */
|
||||
{
|
||||
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, " -colors N Reduce image to no more than N colors\n");
|
||||
fprintf(stderr, " -fast Fast, low-quality processing\n");
|
||||
fprintf(stderr, " -grayscale Force grayscale output\n");
|
||||
#ifdef IDCT_SCALING_SUPPORTED
|
||||
fprintf(stderr, " -scale M/N Scale output image by fraction M/N, eg, 1/8\n");
|
||||
#endif
|
||||
#ifdef BMP_SUPPORTED
|
||||
fprintf(stderr, " -bmp Select BMP output format (Windows style)%s\n",
|
||||
(DEFAULT_FMT == FMT_BMP ? " (default)" : ""));
|
||||
#endif
|
||||
#ifdef GIF_SUPPORTED
|
||||
fprintf(stderr, " -gif Select GIF output format%s\n",
|
||||
(DEFAULT_FMT == FMT_GIF ? " (default)" : ""));
|
||||
#endif
|
||||
#ifdef BMP_SUPPORTED
|
||||
fprintf(stderr, " -os2 Select BMP output format (OS/2 style)%s\n",
|
||||
(DEFAULT_FMT == FMT_OS2 ? " (default)" : ""));
|
||||
#endif
|
||||
#ifdef PPM_SUPPORTED
|
||||
fprintf(stderr, " -pnm Select PBMPLUS (PPM/PGM) output format%s\n",
|
||||
(DEFAULT_FMT == FMT_PPM ? " (default)" : ""));
|
||||
#endif
|
||||
#ifdef RLE_SUPPORTED
|
||||
fprintf(stderr, " -rle Select Utah RLE output format%s\n",
|
||||
(DEFAULT_FMT == FMT_RLE ? " (default)" : ""));
|
||||
#endif
|
||||
#ifdef TARGA_SUPPORTED
|
||||
fprintf(stderr, " -targa Select Targa output format%s\n",
|
||||
(DEFAULT_FMT == FMT_TARGA ? " (default)" : ""));
|
||||
#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, " -dither fs Use F-S dithering (default)\n");
|
||||
fprintf(stderr, " -dither none Don't use dithering in quantization\n");
|
||||
fprintf(stderr, " -dither ordered Use ordered dither (medium speed, quality)\n");
|
||||
#ifdef QUANT_2PASS_SUPPORTED
|
||||
fprintf(stderr, " -map FILE Map to colors used in named image file\n");
|
||||
#endif
|
||||
fprintf(stderr, " -nosmooth Don't use high-quality upsampling\n");
|
||||
#ifdef QUANT_1PASS_SUPPORTED
|
||||
fprintf(stderr, " -onepass Use 1-pass quantization (fast, low quality)\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");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
|
||||
LOCAL(int)
|
||||
parse_switches (j_decompress_ptr cinfo, int argc, char **argv,
|
||||
int last_file_arg_seen, boolean for_real)
|
||||
/* Parse optional switches.
|
||||
* Returns argv[] index of first file-name argument (== argc if none).
|
||||
* Any file names with indexes <= last_file_arg_seen are ignored;
|
||||
* they have presumably been processed in a previous iteration.
|
||||
* (Pass 0 for last_file_arg_seen on the first or only iteration.)
|
||||
* for_real is FALSE on the first (dummy) pass; we may skip any expensive
|
||||
* processing.
|
||||
*/
|
||||
{
|
||||
int argn;
|
||||
char * arg;
|
||||
|
||||
/* Set up default JPEG parameters. */
|
||||
requested_fmt = DEFAULT_FMT; /* set default output file format */
|
||||
outfilename = NULL;
|
||||
cinfo->err->trace_level = 0;
|
||||
|
||||
/* Scan command line options, adjust parameters */
|
||||
|
||||
for (argn = 1; argn < argc; argn++) {
|
||||
arg = argv[argn];
|
||||
if (*arg != '-') {
|
||||
/* Not a switch, must be a file name argument */
|
||||
if (argn <= last_file_arg_seen) {
|
||||
outfilename = NULL; /* -outfile applies to just one input file */
|
||||
continue; /* ignore this name if previously processed */
|
||||
}
|
||||
break; /* else done parsing switches */
|
||||
}
|
||||
arg++; /* advance past switch marker character */
|
||||
|
||||
if (keymatch(arg, "bmp", 1)) {
|
||||
/* BMP output format. */
|
||||
requested_fmt = FMT_BMP;
|
||||
|
||||
} else if (keymatch(arg, "colors", 1) || keymatch(arg, "colours", 1) ||
|
||||
keymatch(arg, "quantize", 1) || keymatch(arg, "quantise", 1)) {
|
||||
/* Do color quantization. */
|
||||
int val;
|
||||
|
||||
if (++argn >= argc) /* advance to next argument */
|
||||
usage();
|
||||
if (sscanf(argv[argn], "%d", &val) != 1)
|
||||
usage();
|
||||
cinfo->desired_number_of_colors = val;
|
||||
cinfo->quantize_colors = TRUE;
|
||||
|
||||
} else if (keymatch(arg, "dct", 2)) {
|
||||
/* Select IDCT algorithm. */
|
||||
if (++argn >= argc) /* advance to next argument */
|
||||
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, "dither", 2)) {
|
||||
/* Select dithering algorithm. */
|
||||
if (++argn >= argc) /* advance to next argument */
|
||||
usage();
|
||||
if (keymatch(argv[argn], "fs", 2)) {
|
||||
cinfo->dither_mode = JDITHER_FS;
|
||||
} else if (keymatch(argv[argn], "none", 2)) {
|
||||
cinfo->dither_mode = JDITHER_NONE;
|
||||
} else if (keymatch(argv[argn], "ordered", 2)) {
|
||||
cinfo->dither_mode = JDITHER_ORDERED;
|
||||
} else
|
||||
usage();
|
||||
|
||||
} else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {
|
||||
/* Enable debug printouts. */
|
||||
/* On first -d, print version identification */
|
||||
static boolean printed_version = FALSE;
|
||||
|
||||
if (! printed_version) {
|
||||
fprintf(stderr, "Independent JPEG Group's DJPEG, version %s\n%s\n",
|
||||
JVERSION, JCOPYRIGHT);
|
||||
printed_version = TRUE;
|
||||
}
|
||||
cinfo->err->trace_level++;
|
||||
|
||||
} else if (keymatch(arg, "fast", 1)) {
|
||||
/* Select recommended processing options for quick-and-dirty output. */
|
||||
cinfo->two_pass_quantize = FALSE;
|
||||
cinfo->dither_mode = JDITHER_ORDERED;
|
||||
if (! cinfo->quantize_colors) /* don't override an earlier -colors */
|
||||
cinfo->desired_number_of_colors = 216;
|
||||
cinfo->dct_method = JDCT_FASTEST;
|
||||
cinfo->do_fancy_upsampling = FALSE;
|
||||
|
||||
} else if (keymatch(arg, "gif", 1)) {
|
||||
/* GIF output format. */
|
||||
requested_fmt = FMT_GIF;
|
||||
|
||||
} else if (keymatch(arg, "grayscale", 2) || keymatch(arg, "greyscale",2)) {
|
||||
/* Force monochrome output. */
|
||||
cinfo->out_color_space = JCS_GRAYSCALE;
|
||||
|
||||
} else if (keymatch(arg, "map", 3)) {
|
||||
/* Quantize to a color map taken from an input file. */
|
||||
if (++argn >= argc) /* advance to next argument */
|
||||
usage();
|
||||
if (for_real) { /* too expensive to do twice! */
|
||||
#ifdef QUANT_2PASS_SUPPORTED /* otherwise can't quantize to supplied map */
|
||||
FILE * mapfile;
|
||||
|
||||
if ((mapfile = fopen(argv[argn], READ_BINARY)) == NULL) {
|
||||
fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
read_color_map(cinfo, mapfile);
|
||||
fclose(mapfile);
|
||||
cinfo->quantize_colors = TRUE;
|
||||
#else
|
||||
ERREXIT(cinfo, JERR_NOT_COMPILED);
|
||||
#endif
|
||||
}
|
||||
|
||||
} else if (keymatch(arg, "maxmemory", 3)) {
|
||||
/* Maximum memory in Kb (or Mb with 'm'). */
|
||||
long lval;
|
||||
char ch = 'x';
|
||||
|
||||
if (++argn >= argc) /* advance to next argument */
|
||||
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, "nosmooth", 3)) {
|
||||
/* Suppress fancy upsampling */
|
||||
cinfo->do_fancy_upsampling = FALSE;
|
||||
|
||||
} else if (keymatch(arg, "onepass", 3)) {
|
||||
/* Use fast one-pass quantization. */
|
||||
cinfo->two_pass_quantize = FALSE;
|
||||
|
||||
} else if (keymatch(arg, "os2", 3)) {
|
||||
/* BMP output format (OS/2 flavor). */
|
||||
requested_fmt = FMT_OS2;
|
||||
|
||||
} else if (keymatch(arg, "outfile", 4)) {
|
||||
/* Set output file name. */
|
||||
if (++argn >= argc) /* advance to next argument */
|
||||
usage();
|
||||
outfilename = argv[argn]; /* save it away for later use */
|
||||
|
||||
} else if (keymatch(arg, "pnm", 1) || keymatch(arg, "ppm", 1)) {
|
||||
/* PPM/PGM output format. */
|
||||
requested_fmt = FMT_PPM;
|
||||
|
||||
} else if (keymatch(arg, "rle", 1)) {
|
||||
/* RLE output format. */
|
||||
requested_fmt = FMT_RLE;
|
||||
|
||||
} else if (keymatch(arg, "scale", 1)) {
|
||||
/* Scale the output image by a fraction M/N. */
|
||||
if (++argn >= argc) /* advance to next argument */
|
||||
usage();
|
||||
if (sscanf(argv[argn], "%d/%d",
|
||||
&cinfo->scale_num, &cinfo->scale_denom) != 2)
|
||||
usage();
|
||||
|
||||
} else if (keymatch(arg, "targa", 1)) {
|
||||
/* Targa output format. */
|
||||
requested_fmt = FMT_TARGA;
|
||||
|
||||
} else {
|
||||
usage(); /* bogus switch */
|
||||
}
|
||||
}
|
||||
|
||||
return argn; /* return index of next arg (file name) */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Marker processor for COM and interesting APPn markers.
|
||||
* This replaces the library's built-in processor, which just skips the marker.
|
||||
* We want to print out the marker as text, to the extent possible.
|
||||
* Note this code relies on a non-suspending data source.
|
||||
*/
|
||||
|
||||
LOCAL(unsigned int)
|
||||
jpeg_getc (j_decompress_ptr cinfo)
|
||||
/* Read next byte */
|
||||
{
|
||||
struct jpeg_source_mgr * datasrc = cinfo->src;
|
||||
|
||||
if (datasrc->bytes_in_buffer == 0) {
|
||||
if (! (*datasrc->fill_input_buffer) (cinfo))
|
||||
ERREXIT(cinfo, JERR_CANT_SUSPEND);
|
||||
}
|
||||
datasrc->bytes_in_buffer--;
|
||||
return GETJOCTET(*datasrc->next_input_byte++);
|
||||
}
|
||||
|
||||
|
||||
METHODDEF(boolean)
|
||||
print_text_marker (j_decompress_ptr cinfo)
|
||||
{
|
||||
boolean traceit = (cinfo->err->trace_level >= 1);
|
||||
INT32 length;
|
||||
unsigned int ch;
|
||||
unsigned int lastch = 0;
|
||||
|
||||
length = jpeg_getc(cinfo) << 8;
|
||||
length += jpeg_getc(cinfo);
|
||||
length -= 2; /* discount the length word itself */
|
||||
|
||||
if (traceit) {
|
||||
if (cinfo->unread_marker == JPEG_COM)
|
||||
fprintf(stderr, "Comment, length %ld:\n", (long) length);
|
||||
else /* assume it is an APPn otherwise */
|
||||
fprintf(stderr, "APP%d, length %ld:\n",
|
||||
cinfo->unread_marker - JPEG_APP0, (long) length);
|
||||
}
|
||||
|
||||
while (--length >= 0) {
|
||||
ch = jpeg_getc(cinfo);
|
||||
if (traceit) {
|
||||
/* Emit the character in a readable form.
|
||||
* Nonprintables are converted to \nnn form,
|
||||
* while \ is converted to \\.
|
||||
* Newlines in CR, CR/LF, or LF form will be printed as one newline.
|
||||
*/
|
||||
if (ch == '\r') {
|
||||
fprintf(stderr, "\n");
|
||||
} else if (ch == '\n') {
|
||||
if (lastch != '\r')
|
||||
fprintf(stderr, "\n");
|
||||
} else if (ch == '\\') {
|
||||
fprintf(stderr, "\\\\");
|
||||
} else if (isprint(ch)) {
|
||||
putc(ch, stderr);
|
||||
} else {
|
||||
fprintf(stderr, "\\%03o", ch);
|
||||
}
|
||||
lastch = ch;
|
||||
}
|
||||
}
|
||||
|
||||
if (traceit)
|
||||
fprintf(stderr, "\n");
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* The main program.
|
||||
*/
|
||||
|
||||
int
|
||||
main (int argc, char **argv)
|
||||
{
|
||||
struct jpeg_decompress_struct cinfo;
|
||||
struct jpeg_error_mgr jerr;
|
||||
#ifdef PROGRESS_REPORT
|
||||
struct cdjpeg_progress_mgr progress;
|
||||
#endif
|
||||
int file_index;
|
||||
djpeg_dest_ptr dest_mgr = NULL;
|
||||
FILE * input_file;
|
||||
FILE * output_file;
|
||||
JDIMENSION num_scanlines;
|
||||
|
||||
/* On Mac, fetch a command line. */
|
||||
#ifdef USE_CCOMMAND
|
||||
argc = ccommand(&argv);
|
||||
#endif
|
||||
|
||||
progname = argv[0];
|
||||
if (progname == NULL || progname[0] == 0)
|
||||
progname = "djpeg"; /* in case C library doesn't provide it */
|
||||
|
||||
/* Initialize the JPEG decompression object with default error handling. */
|
||||
cinfo.err = jpeg_std_error(&jerr);
|
||||
jpeg_create_decompress(&cinfo);
|
||||
/* Add some application-specific error messages (from cderror.h) */
|
||||
jerr.addon_message_table = cdjpeg_message_table;
|
||||
jerr.first_addon_message = JMSG_FIRSTADDONCODE;
|
||||
jerr.last_addon_message = JMSG_LASTADDONCODE;
|
||||
|
||||
/* Insert custom marker processor for COM and APP12.
|
||||
* APP12 is used by some digital camera makers for textual info,
|
||||
* so we provide the ability to display it as text.
|
||||
* If you like, additional APPn marker types can be selected for display,
|
||||
* but don't try to override APP0 or APP14 this way (see libjpeg.doc).
|
||||
*/
|
||||
jpeg_set_marker_processor(&cinfo, JPEG_COM, print_text_marker);
|
||||
jpeg_set_marker_processor(&cinfo, JPEG_APP0+12, print_text_marker);
|
||||
|
||||
/* Now safe to enable signal catcher. */
|
||||
#ifdef NEED_SIGNAL_CATCHER
|
||||
enable_signal_catcher((j_common_ptr) &cinfo);
|
||||
#endif
|
||||
|
||||
/* Scan command line to find file names. */
|
||||
/* It is convenient to use just one switch-parsing routine, but the switch
|
||||
* values read here are ignored; we will rescan the switches after opening
|
||||
* the input file.
|
||||
* (Exception: tracing level set here controls verbosity for COM markers
|
||||
* found during jpeg_read_header...)
|
||||
*/
|
||||
|
||||
file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
|
||||
|
||||
#ifdef TWO_FILE_COMMANDLINE
|
||||
/* Must have either -outfile switch or explicit output file name */
|
||||
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();
|
||||
}
|
||||
}
|
||||
#else
|
||||
/* Unix style: expect zero or one file name */
|
||||
if (file_index < argc-1) {
|
||||
fprintf(stderr, "%s: only one input file\n", progname);
|
||||
usage();
|
||||
}
|
||||
#endif /* TWO_FILE_COMMANDLINE */
|
||||
|
||||
/* Open the input file. */
|
||||
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);
|
||||
}
|
||||
} else {
|
||||
/* default input file is stdin */
|
||||
input_file = read_stdin();
|
||||
}
|
||||
|
||||
/* Open the output file. */
|
||||
if (outfilename != NULL) {
|
||||
if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
|
||||
fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
} else {
|
||||
/* default output file is stdout */
|
||||
output_file = write_stdout();
|
||||
}
|
||||
|
||||
#ifdef PROGRESS_REPORT
|
||||
start_progress_monitor((j_common_ptr) &cinfo, &progress);
|
||||
#endif
|
||||
|
||||
/* Specify data source for decompression */
|
||||
jpeg_stdio_src(&cinfo, input_file);
|
||||
|
||||
/* Read file header, set default decompression parameters */
|
||||
(void) jpeg_read_header(&cinfo, TRUE);
|
||||
|
||||
/* Adjust default decompression parameters by re-parsing the options */
|
||||
file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
|
||||
|
||||
/* Initialize the output module now to let it override any crucial
|
||||
* option settings (for instance, GIF wants to force color quantization).
|
||||
*/
|
||||
switch (requested_fmt) {
|
||||
#ifdef BMP_SUPPORTED
|
||||
case FMT_BMP:
|
||||
dest_mgr = jinit_write_bmp(&cinfo, FALSE);
|
||||
break;
|
||||
case FMT_OS2:
|
||||
dest_mgr = jinit_write_bmp(&cinfo, TRUE);
|
||||
break;
|
||||
#endif
|
||||
#ifdef GIF_SUPPORTED
|
||||
case FMT_GIF:
|
||||
dest_mgr = jinit_write_gif(&cinfo);
|
||||
break;
|
||||
#endif
|
||||
#ifdef PPM_SUPPORTED
|
||||
case FMT_PPM:
|
||||
dest_mgr = jinit_write_ppm(&cinfo);
|
||||
break;
|
||||
#endif
|
||||
#ifdef RLE_SUPPORTED
|
||||
case FMT_RLE:
|
||||
dest_mgr = jinit_write_rle(&cinfo);
|
||||
break;
|
||||
#endif
|
||||
#ifdef TARGA_SUPPORTED
|
||||
case FMT_TARGA:
|
||||
dest_mgr = jinit_write_targa(&cinfo);
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
ERREXIT(&cinfo, JERR_UNSUPPORTED_FORMAT);
|
||||
break;
|
||||
}
|
||||
dest_mgr->output_file = output_file;
|
||||
|
||||
/* Start decompressor */
|
||||
(void) jpeg_start_decompress(&cinfo);
|
||||
|
||||
/* Write output file header */
|
||||
(*dest_mgr->start_output) (&cinfo, dest_mgr);
|
||||
|
||||
/* Process data */
|
||||
while (cinfo.output_scanline < cinfo.output_height) {
|
||||
num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
|
||||
dest_mgr->buffer_height);
|
||||
(*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
|
||||
}
|
||||
|
||||
#ifdef PROGRESS_REPORT
|
||||
/* Hack: count final pass as done in case finish_output does an extra pass.
|
||||
* The library won't have updated completed_passes.
|
||||
*/
|
||||
progress.pub.completed_passes = progress.pub.total_passes;
|
||||
#endif
|
||||
|
||||
/* Finish decompression and release memory.
|
||||
* I must do it in this order because output module has allocated memory
|
||||
* of lifespan JPOOL_IMAGE; it needs to finish before releasing memory.
|
||||
*/
|
||||
(*dest_mgr->finish_output) (&cinfo, dest_mgr);
|
||||
(void) jpeg_finish_decompress(&cinfo);
|
||||
jpeg_destroy_decompress(&cinfo);
|
||||
|
||||
/* Close files, if we opened them */
|
||||
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
|
||||
|
||||
/* All done. */
|
||||
exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
|
||||
return 0; /* suppress no-return-value warnings */
|
||||
}
|
||||
|
|
@ -0,0 +1,439 @@
|
|||
/*
|
||||
* rdbmp.c
|
||||
*
|
||||
* Copyright (C) 1994-1996, Thomas G. Lane.
|
||||
* This file is part of the Independent JPEG Group's software.
|
||||
* For conditions of distribution and use, see the accompanying README file.
|
||||
*
|
||||
* This file contains routines to read input images in Microsoft "BMP"
|
||||
* format (MS Windows 3.x, OS/2 1.x, and OS/2 2.x flavors).
|
||||
* Currently, only 8-bit and 24-bit images are supported, not 1-bit or
|
||||
* 4-bit (feeding such low-depth images into JPEG would be silly anyway).
|
||||
* Also, we don't support RLE-compressed files.
|
||||
*
|
||||
* These routines may need modification for non-Unix environments or
|
||||
* specialized applications. As they stand, they assume input from
|
||||
* an ordinary stdio stream. They further assume that reading begins
|
||||
* at the start of the file; start_input may need work if the
|
||||
* user interface has already read some data (e.g., to determine that
|
||||
* the file is indeed BMP format).
|
||||
*
|
||||
* This code contributed by James Arthur Boucher.
|
||||
*/
|
||||
|
||||
#include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
|
||||
|
||||
#ifdef BMP_SUPPORTED
|
||||
|
||||
|
||||
/* Macros to deal with unsigned chars as efficiently as compiler allows */
|
||||
|
||||
#ifdef HAVE_UNSIGNED_CHAR
|
||||
typedef unsigned char U_CHAR;
|
||||
#define UCH(x) ((int) (x))
|
||||
#else /* !HAVE_UNSIGNED_CHAR */
|
||||
#ifdef CHAR_IS_UNSIGNED
|
||||
typedef char U_CHAR;
|
||||
#define UCH(x) ((int) (x))
|
||||
#else
|
||||
typedef char U_CHAR;
|
||||
#define UCH(x) ((int) (x) & 0xFF)
|
||||
#endif
|
||||
#endif /* HAVE_UNSIGNED_CHAR */
|
||||
|
||||
|
||||
#define ReadOK(file,buffer,len) (JFREAD(file,buffer,len) == ((size_t) (len)))
|
||||
|
||||
|
||||
/* Private version of data source object */
|
||||
|
||||
typedef struct _bmp_source_struct * bmp_source_ptr;
|
||||
|
||||
typedef struct _bmp_source_struct {
|
||||
struct cjpeg_source_struct pub; /* public fields */
|
||||
|
||||
j_compress_ptr cinfo; /* back link saves passing separate parm */
|
||||
|
||||
JSAMPARRAY colormap; /* BMP colormap (converted to my format) */
|
||||
|
||||
jvirt_sarray_ptr whole_image; /* Needed to reverse row order */
|
||||
JDIMENSION source_row; /* Current source row number */
|
||||
JDIMENSION row_width; /* Physical width of scanlines in file */
|
||||
|
||||
int bits_per_pixel; /* remembers 8- or 24-bit format */
|
||||
} bmp_source_struct;
|
||||
|
||||
|
||||
LOCAL(int)
|
||||
read_byte (bmp_source_ptr sinfo)
|
||||
/* Read next byte from BMP file */
|
||||
{
|
||||
register FILE *infile = sinfo->pub.input_file;
|
||||
register int c;
|
||||
|
||||
if ((c = getc(infile)) == EOF)
|
||||
ERREXIT(sinfo->cinfo, JERR_INPUT_EOF);
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
LOCAL(void)
|
||||
read_colormap (bmp_source_ptr sinfo, int cmaplen, int mapentrysize)
|
||||
/* Read the colormap from a BMP file */
|
||||
{
|
||||
int i;
|
||||
|
||||
switch (mapentrysize) {
|
||||
case 3:
|
||||
/* BGR format (occurs in OS/2 files) */
|
||||
for (i = 0; i < cmaplen; i++) {
|
||||
sinfo->colormap[2][i] = (JSAMPLE) read_byte(sinfo);
|
||||
sinfo->colormap[1][i] = (JSAMPLE) read_byte(sinfo);
|
||||
sinfo->colormap[0][i] = (JSAMPLE) read_byte(sinfo);
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
/* BGR0 format (occurs in MS Windows files) */
|
||||
for (i = 0; i < cmaplen; i++) {
|
||||
sinfo->colormap[2][i] = (JSAMPLE) read_byte(sinfo);
|
||||
sinfo->colormap[1][i] = (JSAMPLE) read_byte(sinfo);
|
||||
sinfo->colormap[0][i] = (JSAMPLE) read_byte(sinfo);
|
||||
(void) read_byte(sinfo);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
ERREXIT(sinfo->cinfo, JERR_BMP_BADCMAP);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Read one row of pixels.
|
||||
* The image has been read into the whole_image array, but is otherwise
|
||||
* unprocessed. We must read it out in top-to-bottom row order, and if
|
||||
* it is an 8-bit image, we must expand colormapped pixels to 24bit format.
|
||||
*/
|
||||
|
||||
METHODDEF(JDIMENSION)
|
||||
get_8bit_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
/* This version is for reading 8-bit colormap indexes */
|
||||
{
|
||||
bmp_source_ptr source = (bmp_source_ptr) sinfo;
|
||||
register JSAMPARRAY colormap = source->colormap;
|
||||
JSAMPARRAY image_ptr;
|
||||
register int t;
|
||||
register JSAMPROW inptr, outptr;
|
||||
register JDIMENSION col;
|
||||
|
||||
/* Fetch next row from virtual array */
|
||||
source->source_row--;
|
||||
image_ptr = (*cinfo->mem->access_virt_sarray)
|
||||
((j_common_ptr) cinfo, source->whole_image,
|
||||
source->source_row, (JDIMENSION) 1, FALSE);
|
||||
|
||||
/* Expand the colormap indexes to real data */
|
||||
inptr = image_ptr[0];
|
||||
outptr = source->pub.buffer[0];
|
||||
for (col = cinfo->image_width; col > 0; col--) {
|
||||
t = GETJSAMPLE(*inptr++);
|
||||
*outptr++ = colormap[0][t]; /* can omit GETJSAMPLE() safely */
|
||||
*outptr++ = colormap[1][t];
|
||||
*outptr++ = colormap[2][t];
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
METHODDEF(JDIMENSION)
|
||||
get_24bit_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
/* This version is for reading 24-bit pixels */
|
||||
{
|
||||
bmp_source_ptr source = (bmp_source_ptr) sinfo;
|
||||
JSAMPARRAY image_ptr;
|
||||
register JSAMPROW inptr, outptr;
|
||||
register JDIMENSION col;
|
||||
|
||||
/* Fetch next row from virtual array */
|
||||
source->source_row--;
|
||||
image_ptr = (*cinfo->mem->access_virt_sarray)
|
||||
((j_common_ptr) cinfo, source->whole_image,
|
||||
source->source_row, (JDIMENSION) 1, FALSE);
|
||||
|
||||
/* Transfer data. Note source values are in BGR order
|
||||
* (even though Microsoft's own documents say the opposite).
|
||||
*/
|
||||
inptr = image_ptr[0];
|
||||
outptr = source->pub.buffer[0];
|
||||
for (col = cinfo->image_width; col > 0; col--) {
|
||||
outptr[2] = *inptr++; /* can omit GETJSAMPLE() safely */
|
||||
outptr[1] = *inptr++;
|
||||
outptr[0] = *inptr++;
|
||||
outptr += 3;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* This method loads the image into whole_image during the first call on
|
||||
* get_pixel_rows. The get_pixel_rows pointer is then adjusted to call
|
||||
* get_8bit_row or get_24bit_row on subsequent calls.
|
||||
*/
|
||||
|
||||
METHODDEF(JDIMENSION)
|
||||
preload_image (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
{
|
||||
bmp_source_ptr source = (bmp_source_ptr) sinfo;
|
||||
register FILE *infile = source->pub.input_file;
|
||||
register int c;
|
||||
register JSAMPROW out_ptr;
|
||||
JSAMPARRAY image_ptr;
|
||||
JDIMENSION row, col;
|
||||
cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress;
|
||||
|
||||
/* Read the data into a virtual array in input-file row order. */
|
||||
for (row = 0; row < cinfo->image_height; row++) {
|
||||
if (progress != NULL) {
|
||||
progress->pub.pass_counter = (long) row;
|
||||
progress->pub.pass_limit = (long) cinfo->image_height;
|
||||
(*progress->pub.progress_monitor) ((j_common_ptr) cinfo);
|
||||
}
|
||||
image_ptr = (*cinfo->mem->access_virt_sarray)
|
||||
((j_common_ptr) cinfo, source->whole_image,
|
||||
row, (JDIMENSION) 1, TRUE);
|
||||
out_ptr = image_ptr[0];
|
||||
for (col = source->row_width; col > 0; col--) {
|
||||
/* inline copy of read_byte() for speed */
|
||||
if ((c = getc(infile)) == EOF)
|
||||
ERREXIT(cinfo, JERR_INPUT_EOF);
|
||||
*out_ptr++ = (JSAMPLE) c;
|
||||
}
|
||||
}
|
||||
if (progress != NULL)
|
||||
progress->completed_extra_passes++;
|
||||
|
||||
/* Set up to read from the virtual array in top-to-bottom order */
|
||||
switch (source->bits_per_pixel) {
|
||||
case 8:
|
||||
source->pub.get_pixel_rows = get_8bit_row;
|
||||
break;
|
||||
case 24:
|
||||
source->pub.get_pixel_rows = get_24bit_row;
|
||||
break;
|
||||
default:
|
||||
ERREXIT(cinfo, JERR_BMP_BADDEPTH);
|
||||
}
|
||||
source->source_row = cinfo->image_height;
|
||||
|
||||
/* And read the first row */
|
||||
return (*source->pub.get_pixel_rows) (cinfo, sinfo);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Read the file header; return image size and component count.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
start_input_bmp (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
{
|
||||
bmp_source_ptr source = (bmp_source_ptr) sinfo;
|
||||
U_CHAR bmpfileheader[14];
|
||||
U_CHAR bmpinfoheader[64];
|
||||
#define GET_2B(array,offset) ((unsigned int) UCH(array[offset]) + \
|
||||
(((unsigned int) UCH(array[offset+1])) << 8))
|
||||
#define GET_4B(array,offset) ((INT32) UCH(array[offset]) + \
|
||||
(((INT32) UCH(array[offset+1])) << 8) + \
|
||||
(((INT32) UCH(array[offset+2])) << 16) + \
|
||||
(((INT32) UCH(array[offset+3])) << 24))
|
||||
INT32 bfOffBits;
|
||||
INT32 headerSize;
|
||||
INT32 biWidth = 0; /* initialize to avoid compiler warning */
|
||||
INT32 biHeight = 0;
|
||||
unsigned int biPlanes;
|
||||
INT32 biCompression;
|
||||
INT32 biXPelsPerMeter,biYPelsPerMeter;
|
||||
INT32 biClrUsed = 0;
|
||||
int mapentrysize = 0; /* 0 indicates no colormap */
|
||||
INT32 bPad;
|
||||
JDIMENSION row_width;
|
||||
|
||||
/* Read and verify the bitmap file header */
|
||||
if (! ReadOK(source->pub.input_file, bmpfileheader, 14))
|
||||
ERREXIT(cinfo, JERR_INPUT_EOF);
|
||||
if (GET_2B(bmpfileheader,0) != 0x4D42) /* 'BM' */
|
||||
ERREXIT(cinfo, JERR_BMP_NOT);
|
||||
bfOffBits = (INT32) GET_4B(bmpfileheader,10);
|
||||
/* We ignore the remaining fileheader fields */
|
||||
|
||||
/* The infoheader might be 12 bytes (OS/2 1.x), 40 bytes (Windows),
|
||||
* or 64 bytes (OS/2 2.x). Check the first 4 bytes to find out which.
|
||||
*/
|
||||
if (! ReadOK(source->pub.input_file, bmpinfoheader, 4))
|
||||
ERREXIT(cinfo, JERR_INPUT_EOF);
|
||||
headerSize = (INT32) GET_4B(bmpinfoheader,0);
|
||||
if (headerSize < 12 || headerSize > 64)
|
||||
ERREXIT(cinfo, JERR_BMP_BADHEADER);
|
||||
if (! ReadOK(source->pub.input_file, bmpinfoheader+4, headerSize-4))
|
||||
ERREXIT(cinfo, JERR_INPUT_EOF);
|
||||
|
||||
switch ((int) headerSize) {
|
||||
case 12:
|
||||
/* Decode OS/2 1.x header (Microsoft calls this a BITMAPCOREHEADER) */
|
||||
biWidth = (INT32) GET_2B(bmpinfoheader,4);
|
||||
biHeight = (INT32) GET_2B(bmpinfoheader,6);
|
||||
biPlanes = GET_2B(bmpinfoheader,8);
|
||||
source->bits_per_pixel = (int) GET_2B(bmpinfoheader,10);
|
||||
|
||||
switch (source->bits_per_pixel) {
|
||||
case 8: /* colormapped image */
|
||||
mapentrysize = 3; /* OS/2 uses RGBTRIPLE colormap */
|
||||
TRACEMS2(cinfo, 1, JTRC_BMP_OS2_MAPPED, (int) biWidth, (int) biHeight);
|
||||
break;
|
||||
case 24: /* RGB image */
|
||||
TRACEMS2(cinfo, 1, JTRC_BMP_OS2, (int) biWidth, (int) biHeight);
|
||||
break;
|
||||
default:
|
||||
ERREXIT(cinfo, JERR_BMP_BADDEPTH);
|
||||
break;
|
||||
}
|
||||
if (biPlanes != 1)
|
||||
ERREXIT(cinfo, JERR_BMP_BADPLANES);
|
||||
break;
|
||||
case 40:
|
||||
case 64:
|
||||
/* Decode Windows 3.x header (Microsoft calls this a BITMAPINFOHEADER) */
|
||||
/* or OS/2 2.x header, which has additional fields that we ignore */
|
||||
biWidth = GET_4B(bmpinfoheader,4);
|
||||
biHeight = GET_4B(bmpinfoheader,8);
|
||||
biPlanes = GET_2B(bmpinfoheader,12);
|
||||
source->bits_per_pixel = (int) GET_2B(bmpinfoheader,14);
|
||||
biCompression = GET_4B(bmpinfoheader,16);
|
||||
biXPelsPerMeter = GET_4B(bmpinfoheader,24);
|
||||
biYPelsPerMeter = GET_4B(bmpinfoheader,28);
|
||||
biClrUsed = GET_4B(bmpinfoheader,32);
|
||||
/* biSizeImage, biClrImportant fields are ignored */
|
||||
|
||||
switch (source->bits_per_pixel) {
|
||||
case 8: /* colormapped image */
|
||||
mapentrysize = 4; /* Windows uses RGBQUAD colormap */
|
||||
TRACEMS2(cinfo, 1, JTRC_BMP_MAPPED, (int) biWidth, (int) biHeight);
|
||||
break;
|
||||
case 24: /* RGB image */
|
||||
TRACEMS2(cinfo, 1, JTRC_BMP, (int) biWidth, (int) biHeight);
|
||||
break;
|
||||
default:
|
||||
ERREXIT(cinfo, JERR_BMP_BADDEPTH);
|
||||
break;
|
||||
}
|
||||
if (biPlanes != 1)
|
||||
ERREXIT(cinfo, JERR_BMP_BADPLANES);
|
||||
if (biCompression != 0)
|
||||
ERREXIT(cinfo, JERR_BMP_COMPRESSED);
|
||||
|
||||
if (biXPelsPerMeter > 0 && biYPelsPerMeter > 0) {
|
||||
/* Set JFIF density parameters from the BMP data */
|
||||
cinfo->X_density = (UINT16) (biXPelsPerMeter/100); /* 100 cm per meter */
|
||||
cinfo->Y_density = (UINT16) (biYPelsPerMeter/100);
|
||||
cinfo->density_unit = 2; /* dots/cm */
|
||||
}
|
||||
break;
|
||||
default:
|
||||
ERREXIT(cinfo, JERR_BMP_BADHEADER);
|
||||
break;
|
||||
}
|
||||
|
||||
/* Compute distance to bitmap data --- will adjust for colormap below */
|
||||
bPad = bfOffBits - (headerSize + 14);
|
||||
|
||||
/* Read the colormap, if any */
|
||||
if (mapentrysize > 0) {
|
||||
if (biClrUsed <= 0)
|
||||
biClrUsed = 256; /* assume it's 256 */
|
||||
else if (biClrUsed > 256)
|
||||
ERREXIT(cinfo, JERR_BMP_BADCMAP);
|
||||
/* Allocate space to store the colormap */
|
||||
source->colormap = (*cinfo->mem->alloc_sarray)
|
||||
((j_common_ptr) cinfo, JPOOL_IMAGE,
|
||||
(JDIMENSION) biClrUsed, (JDIMENSION) 3);
|
||||
/* and read it from the file */
|
||||
read_colormap(source, (int) biClrUsed, mapentrysize);
|
||||
/* account for size of colormap */
|
||||
bPad -= biClrUsed * mapentrysize;
|
||||
}
|
||||
|
||||
/* Skip any remaining pad bytes */
|
||||
if (bPad < 0) /* incorrect bfOffBits value? */
|
||||
ERREXIT(cinfo, JERR_BMP_BADHEADER);
|
||||
while (--bPad >= 0) {
|
||||
(void) read_byte(source);
|
||||
}
|
||||
|
||||
/* Compute row width in file, including padding to 4-byte boundary */
|
||||
if (source->bits_per_pixel == 24)
|
||||
row_width = (JDIMENSION) (biWidth * 3);
|
||||
else
|
||||
row_width = (JDIMENSION) biWidth;
|
||||
while ((row_width & 3) != 0) row_width++;
|
||||
source->row_width = row_width;
|
||||
|
||||
/* Allocate space for inversion array, prepare for preload pass */
|
||||
source->whole_image = (*cinfo->mem->request_virt_sarray)
|
||||
((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
|
||||
row_width, (JDIMENSION) biHeight, (JDIMENSION) 1);
|
||||
source->pub.get_pixel_rows = preload_image;
|
||||
if (cinfo->progress != NULL) {
|
||||
cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress;
|
||||
progress->total_extra_passes++; /* count file input as separate pass */
|
||||
}
|
||||
|
||||
/* Allocate one-row buffer for returned data */
|
||||
source->pub.buffer = (*cinfo->mem->alloc_sarray)
|
||||
((j_common_ptr) cinfo, JPOOL_IMAGE,
|
||||
(JDIMENSION) (biWidth * 3), (JDIMENSION) 1);
|
||||
source->pub.buffer_height = 1;
|
||||
|
||||
cinfo->in_color_space = JCS_RGB;
|
||||
cinfo->input_components = 3;
|
||||
cinfo->data_precision = 8;
|
||||
cinfo->image_width = (JDIMENSION) biWidth;
|
||||
cinfo->image_height = (JDIMENSION) biHeight;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Finish up at the end of the file.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
finish_input_bmp (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
{
|
||||
/* no work */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* The module selection routine for BMP format input.
|
||||
*/
|
||||
|
||||
GLOBAL(cjpeg_source_ptr)
|
||||
jinit_read_bmp (j_compress_ptr cinfo)
|
||||
{
|
||||
bmp_source_ptr source;
|
||||
|
||||
/* Create module interface object */
|
||||
source = (bmp_source_ptr)
|
||||
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
|
||||
SIZEOF(bmp_source_struct));
|
||||
source->cinfo = cinfo; /* make back link for subroutines */
|
||||
/* Fill in method ptrs, except get_pixel_rows which start_input sets */
|
||||
source->pub.start_input = start_input_bmp;
|
||||
source->pub.finish_input = finish_input_bmp;
|
||||
|
||||
return (cjpeg_source_ptr) source;
|
||||
}
|
||||
|
||||
#endif /* BMP_SUPPORTED */
|
||||
|
|
@ -0,0 +1,253 @@
|
|||
/*
|
||||
* rdcolmap.c
|
||||
*
|
||||
* Copyright (C) 1994-1996, Thomas G. Lane.
|
||||
* This file is part of the Independent JPEG Group's software.
|
||||
* For conditions of distribution and use, see the accompanying README file.
|
||||
*
|
||||
* This file implements djpeg's "-map file" switch. It reads a source image
|
||||
* and constructs a colormap to be supplied to the JPEG decompressor.
|
||||
*
|
||||
* Currently, these file formats are supported for the map file:
|
||||
* GIF: the contents of the GIF's global colormap are used.
|
||||
* PPM (either text or raw flavor): the entire file is read and
|
||||
* each unique pixel value is entered in the map.
|
||||
* Note that reading a large PPM file will be horrendously slow.
|
||||
* Typically, a PPM-format map file should contain just one pixel
|
||||
* of each desired color. Such a file can be extracted from an
|
||||
* ordinary image PPM file with ppmtomap(1).
|
||||
*
|
||||
* Rescaling a PPM that has a maxval unequal to MAXJSAMPLE is not
|
||||
* currently implemented.
|
||||
*/
|
||||
|
||||
#include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
|
||||
|
||||
#ifdef QUANT_2PASS_SUPPORTED /* otherwise can't quantize to supplied map */
|
||||
|
||||
/* Portions of this code are based on the PBMPLUS library, which is:
|
||||
**
|
||||
** Copyright (C) 1988 by Jef Poskanzer.
|
||||
**
|
||||
** Permission to use, copy, modify, and distribute this software and its
|
||||
** documentation for any purpose and without fee is hereby granted, provided
|
||||
** that the above copyright notice appear in all copies and that both that
|
||||
** copyright notice and this permission notice appear in supporting
|
||||
** documentation. This software is provided "as is" without express or
|
||||
** implied warranty.
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* Add a (potentially) new color to the color map.
|
||||
*/
|
||||
|
||||
LOCAL(void)
|
||||
add_map_entry (j_decompress_ptr cinfo, int R, int G, int B)
|
||||
{
|
||||
JSAMPROW colormap0 = cinfo->colormap[0];
|
||||
JSAMPROW colormap1 = cinfo->colormap[1];
|
||||
JSAMPROW colormap2 = cinfo->colormap[2];
|
||||
int ncolors = cinfo->actual_number_of_colors;
|
||||
int index;
|
||||
|
||||
/* Check for duplicate color. */
|
||||
for (index = 0; index < ncolors; index++) {
|
||||
if (GETJSAMPLE(colormap0[index]) == R &&
|
||||
GETJSAMPLE(colormap1[index]) == G &&
|
||||
GETJSAMPLE(colormap2[index]) == B)
|
||||
return; /* color is already in map */
|
||||
}
|
||||
|
||||
/* Check for map overflow. */
|
||||
if (ncolors >= (MAXJSAMPLE+1))
|
||||
ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, (MAXJSAMPLE+1));
|
||||
|
||||
/* OK, add color to map. */
|
||||
colormap0[ncolors] = (JSAMPLE) R;
|
||||
colormap1[ncolors] = (JSAMPLE) G;
|
||||
colormap2[ncolors] = (JSAMPLE) B;
|
||||
cinfo->actual_number_of_colors++;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Extract color map from a GIF file.
|
||||
*/
|
||||
|
||||
LOCAL(void)
|
||||
read_gif_map (j_decompress_ptr cinfo, FILE * infile)
|
||||
{
|
||||
int header[13];
|
||||
int i, colormaplen;
|
||||
int R, G, B;
|
||||
|
||||
/* Initial 'G' has already been read by read_color_map */
|
||||
/* Read the rest of the GIF header and logical screen descriptor */
|
||||
for (i = 1; i < 13; i++) {
|
||||
if ((header[i] = getc(infile)) == EOF)
|
||||
ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
|
||||
}
|
||||
|
||||
/* Verify GIF Header */
|
||||
if (header[1] != 'I' || header[2] != 'F')
|
||||
ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
|
||||
|
||||
/* There must be a global color map. */
|
||||
if ((header[10] & 0x80) == 0)
|
||||
ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
|
||||
|
||||
/* OK, fetch it. */
|
||||
colormaplen = 2 << (header[10] & 0x07);
|
||||
|
||||
for (i = 0; i < colormaplen; i++) {
|
||||
R = getc(infile);
|
||||
G = getc(infile);
|
||||
B = getc(infile);
|
||||
if (R == EOF || G == EOF || B == EOF)
|
||||
ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
|
||||
add_map_entry(cinfo,
|
||||
R << (BITS_IN_JSAMPLE-8),
|
||||
G << (BITS_IN_JSAMPLE-8),
|
||||
B << (BITS_IN_JSAMPLE-8));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Support routines for reading PPM */
|
||||
|
||||
|
||||
LOCAL(int)
|
||||
pbm_getc (FILE * infile)
|
||||
/* Read next char, skipping over any comments */
|
||||
/* A comment/newline sequence is returned as a newline */
|
||||
{
|
||||
register int ch;
|
||||
|
||||
ch = getc(infile);
|
||||
if (ch == '#') {
|
||||
do {
|
||||
ch = getc(infile);
|
||||
} while (ch != '\n' && ch != EOF);
|
||||
}
|
||||
return ch;
|
||||
}
|
||||
|
||||
|
||||
LOCAL(unsigned int)
|
||||
read_pbm_integer (j_decompress_ptr cinfo, FILE * infile)
|
||||
/* Read an unsigned decimal integer from the PPM file */
|
||||
/* Swallows one trailing character after the integer */
|
||||
/* Note that on a 16-bit-int machine, only values up to 64k can be read. */
|
||||
/* This should not be a problem in practice. */
|
||||
{
|
||||
register int ch;
|
||||
register unsigned int val;
|
||||
|
||||
/* Skip any leading whitespace */
|
||||
do {
|
||||
ch = pbm_getc(infile);
|
||||
if (ch == EOF)
|
||||
ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
|
||||
} while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r');
|
||||
|
||||
if (ch < '0' || ch > '9')
|
||||
ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
|
||||
|
||||
val = ch - '0';
|
||||
while ((ch = pbm_getc(infile)) >= '0' && ch <= '9') {
|
||||
val *= 10;
|
||||
val += ch - '0';
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Extract color map from a PPM file.
|
||||
*/
|
||||
|
||||
LOCAL(void)
|
||||
read_ppm_map (j_decompress_ptr cinfo, FILE * infile)
|
||||
{
|
||||
int c;
|
||||
unsigned int w, h, maxval, row, col;
|
||||
int R, G, B;
|
||||
|
||||
/* Initial 'P' has already been read by read_color_map */
|
||||
c = getc(infile); /* save format discriminator for a sec */
|
||||
|
||||
/* while we fetch the remaining header info */
|
||||
w = read_pbm_integer(cinfo, infile);
|
||||
h = read_pbm_integer(cinfo, infile);
|
||||
maxval = read_pbm_integer(cinfo, infile);
|
||||
|
||||
if (w <= 0 || h <= 0 || maxval <= 0) /* error check */
|
||||
ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
|
||||
|
||||
/* For now, we don't support rescaling from an unusual maxval. */
|
||||
if (maxval != (unsigned int) MAXJSAMPLE)
|
||||
ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
|
||||
|
||||
switch (c) {
|
||||
case '3': /* it's a text-format PPM file */
|
||||
for (row = 0; row < h; row++) {
|
||||
for (col = 0; col < w; col++) {
|
||||
R = read_pbm_integer(cinfo, infile);
|
||||
G = read_pbm_integer(cinfo, infile);
|
||||
B = read_pbm_integer(cinfo, infile);
|
||||
add_map_entry(cinfo, R, G, B);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case '6': /* it's a raw-format PPM file */
|
||||
for (row = 0; row < h; row++) {
|
||||
for (col = 0; col < w; col++) {
|
||||
R = getc(infile);
|
||||
G = getc(infile);
|
||||
B = getc(infile);
|
||||
if (R == EOF || G == EOF || B == EOF)
|
||||
ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
|
||||
add_map_entry(cinfo, R, G, B);
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Main entry point from djpeg.c.
|
||||
* Input: opened input file (from file name argument on command line).
|
||||
* Output: colormap and actual_number_of_colors fields are set in cinfo.
|
||||
*/
|
||||
|
||||
GLOBAL(void)
|
||||
read_color_map (j_decompress_ptr cinfo, FILE * infile)
|
||||
{
|
||||
/* Allocate space for a color map of maximum supported size. */
|
||||
cinfo->colormap = (*cinfo->mem->alloc_sarray)
|
||||
((j_common_ptr) cinfo, JPOOL_IMAGE,
|
||||
(JDIMENSION) (MAXJSAMPLE+1), (JDIMENSION) 3);
|
||||
cinfo->actual_number_of_colors = 0; /* initialize map to empty */
|
||||
|
||||
/* Read first byte to determine file format */
|
||||
switch (getc(infile)) {
|
||||
case 'G':
|
||||
read_gif_map(cinfo, infile);
|
||||
break;
|
||||
case 'P':
|
||||
read_ppm_map(cinfo, infile);
|
||||
break;
|
||||
default:
|
||||
ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* QUANT_2PASS_SUPPORTED */
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
/*
|
||||
* rdgif.c
|
||||
*
|
||||
* Copyright (C) 1991-1997, Thomas G. Lane.
|
||||
* This file is part of the Independent JPEG Group's software.
|
||||
* For conditions of distribution and use, see the accompanying README file.
|
||||
*
|
||||
* This file contains routines to read input images in GIF format.
|
||||
*
|
||||
*****************************************************************************
|
||||
* NOTE: to avoid entanglements with Unisys' patent on LZW compression, *
|
||||
* the ability to read GIF files has been removed from the IJG distribution. *
|
||||
* Sorry about that. *
|
||||
*****************************************************************************
|
||||
*
|
||||
* We are required to state that
|
||||
* "The Graphics Interchange Format(c) is the Copyright property of
|
||||
* CompuServe Incorporated. GIF(sm) is a Service Mark property of
|
||||
* CompuServe Incorporated."
|
||||
*/
|
||||
|
||||
#include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
|
||||
|
||||
#ifdef GIF_SUPPORTED
|
||||
|
||||
/*
|
||||
* The module selection routine for GIF format input.
|
||||
*/
|
||||
|
||||
GLOBAL(cjpeg_source_ptr)
|
||||
jinit_read_gif (j_compress_ptr cinfo)
|
||||
{
|
||||
fprintf(stderr, "GIF input is unsupported for legal reasons. Sorry.\n");
|
||||
exit(EXIT_FAILURE);
|
||||
return NULL; /* keep compiler happy */
|
||||
}
|
||||
|
||||
#endif /* GIF_SUPPORTED */
|
||||
|
|
@ -0,0 +1,458 @@
|
|||
/*
|
||||
* rdppm.c
|
||||
*
|
||||
* Copyright (C) 1991-1997, Thomas G. Lane.
|
||||
* This file is part of the Independent JPEG Group's software.
|
||||
* For conditions of distribution and use, see the accompanying README file.
|
||||
*
|
||||
* This file contains routines to read input images in PPM/PGM format.
|
||||
* The extended 2-byte-per-sample raw PPM/PGM formats are supported.
|
||||
* The PBMPLUS library is NOT required to compile this software
|
||||
* (but it is highly useful as a set of PPM image manipulation programs).
|
||||
*
|
||||
* These routines may need modification for non-Unix environments or
|
||||
* specialized applications. As they stand, they assume input from
|
||||
* an ordinary stdio stream. They further assume that reading begins
|
||||
* at the start of the file; start_input may need work if the
|
||||
* user interface has already read some data (e.g., to determine that
|
||||
* the file is indeed PPM format).
|
||||
*/
|
||||
|
||||
#include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
|
||||
|
||||
#ifdef PPM_SUPPORTED
|
||||
|
||||
|
||||
/* Portions of this code are based on the PBMPLUS library, which is:
|
||||
**
|
||||
** Copyright (C) 1988 by Jef Poskanzer.
|
||||
**
|
||||
** Permission to use, copy, modify, and distribute this software and its
|
||||
** documentation for any purpose and without fee is hereby granted, provided
|
||||
** that the above copyright notice appear in all copies and that both that
|
||||
** copyright notice and this permission notice appear in supporting
|
||||
** documentation. This software is provided "as is" without express or
|
||||
** implied warranty.
|
||||
*/
|
||||
|
||||
|
||||
/* Macros to deal with unsigned chars as efficiently as compiler allows */
|
||||
|
||||
#ifdef HAVE_UNSIGNED_CHAR
|
||||
typedef unsigned char U_CHAR;
|
||||
#define UCH(x) ((int) (x))
|
||||
#else /* !HAVE_UNSIGNED_CHAR */
|
||||
#ifdef CHAR_IS_UNSIGNED
|
||||
typedef char U_CHAR;
|
||||
#define UCH(x) ((int) (x))
|
||||
#else
|
||||
typedef char U_CHAR;
|
||||
#define UCH(x) ((int) (x) & 0xFF)
|
||||
#endif
|
||||
#endif /* HAVE_UNSIGNED_CHAR */
|
||||
|
||||
|
||||
#define ReadOK(file,buffer,len) (JFREAD(file,buffer,len) == ((size_t) (len)))
|
||||
|
||||
|
||||
/*
|
||||
* On most systems, reading individual bytes with getc() is drastically less
|
||||
* efficient than buffering a row at a time with fread(). On PCs, we must
|
||||
* allocate the buffer in near data space, because we are assuming small-data
|
||||
* memory model, wherein fread() can't reach far memory. If you need to
|
||||
* process very wide images on a PC, you might have to compile in large-memory
|
||||
* model, or else replace fread() with a getc() loop --- which will be much
|
||||
* slower.
|
||||
*/
|
||||
|
||||
|
||||
/* Private version of data source object */
|
||||
|
||||
typedef struct {
|
||||
struct cjpeg_source_struct pub; /* public fields */
|
||||
|
||||
U_CHAR *iobuffer; /* non-FAR pointer to I/O buffer */
|
||||
JSAMPROW pixrow; /* FAR pointer to same */
|
||||
size_t buffer_width; /* width of I/O buffer */
|
||||
JSAMPLE *rescale; /* => maxval-remapping array, or NULL */
|
||||
} ppm_source_struct;
|
||||
|
||||
typedef ppm_source_struct * ppm_source_ptr;
|
||||
|
||||
|
||||
LOCAL(int)
|
||||
pbm_getc (FILE * infile)
|
||||
/* Read next char, skipping over any comments */
|
||||
/* A comment/newline sequence is returned as a newline */
|
||||
{
|
||||
register int ch;
|
||||
|
||||
ch = getc(infile);
|
||||
if (ch == '#') {
|
||||
do {
|
||||
ch = getc(infile);
|
||||
} while (ch != '\n' && ch != EOF);
|
||||
}
|
||||
return ch;
|
||||
}
|
||||
|
||||
|
||||
LOCAL(unsigned int)
|
||||
read_pbm_integer (j_compress_ptr cinfo, FILE * infile)
|
||||
/* Read an unsigned decimal integer from the PPM file */
|
||||
/* Swallows one trailing character after the integer */
|
||||
/* Note that on a 16-bit-int machine, only values up to 64k can be read. */
|
||||
/* This should not be a problem in practice. */
|
||||
{
|
||||
register int ch;
|
||||
register unsigned int val;
|
||||
|
||||
/* Skip any leading whitespace */
|
||||
do {
|
||||
ch = pbm_getc(infile);
|
||||
if (ch == EOF)
|
||||
ERREXIT(cinfo, JERR_INPUT_EOF);
|
||||
} while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r');
|
||||
|
||||
if (ch < '0' || ch > '9')
|
||||
ERREXIT(cinfo, JERR_PPM_NONNUMERIC);
|
||||
|
||||
val = ch - '0';
|
||||
while ((ch = pbm_getc(infile)) >= '0' && ch <= '9') {
|
||||
val *= 10;
|
||||
val += ch - '0';
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Read one row of pixels.
|
||||
*
|
||||
* We provide several different versions depending on input file format.
|
||||
* In all cases, input is scaled to the size of JSAMPLE.
|
||||
*
|
||||
* A really fast path is provided for reading byte/sample raw files with
|
||||
* maxval = MAXJSAMPLE, which is the normal case for 8-bit data.
|
||||
*/
|
||||
|
||||
|
||||
METHODDEF(JDIMENSION)
|
||||
get_text_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
/* This version is for reading text-format PGM files with any maxval */
|
||||
{
|
||||
ppm_source_ptr source = (ppm_source_ptr) sinfo;
|
||||
FILE * infile = source->pub.input_file;
|
||||
register JSAMPROW ptr;
|
||||
register JSAMPLE *rescale = source->rescale;
|
||||
JDIMENSION col;
|
||||
|
||||
ptr = source->pub.buffer[0];
|
||||
for (col = cinfo->image_width; col > 0; col--) {
|
||||
*ptr++ = rescale[read_pbm_integer(cinfo, infile)];
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
METHODDEF(JDIMENSION)
|
||||
get_text_rgb_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
/* This version is for reading text-format PPM files with any maxval */
|
||||
{
|
||||
ppm_source_ptr source = (ppm_source_ptr) sinfo;
|
||||
FILE * infile = source->pub.input_file;
|
||||
register JSAMPROW ptr;
|
||||
register JSAMPLE *rescale = source->rescale;
|
||||
JDIMENSION col;
|
||||
|
||||
ptr = source->pub.buffer[0];
|
||||
for (col = cinfo->image_width; col > 0; col--) {
|
||||
*ptr++ = rescale[read_pbm_integer(cinfo, infile)];
|
||||
*ptr++ = rescale[read_pbm_integer(cinfo, infile)];
|
||||
*ptr++ = rescale[read_pbm_integer(cinfo, infile)];
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
METHODDEF(JDIMENSION)
|
||||
get_scaled_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
/* This version is for reading raw-byte-format PGM files with any maxval */
|
||||
{
|
||||
ppm_source_ptr source = (ppm_source_ptr) sinfo;
|
||||
register JSAMPROW ptr;
|
||||
register U_CHAR * bufferptr;
|
||||
register JSAMPLE *rescale = source->rescale;
|
||||
JDIMENSION col;
|
||||
|
||||
if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
|
||||
ERREXIT(cinfo, JERR_INPUT_EOF);
|
||||
ptr = source->pub.buffer[0];
|
||||
bufferptr = source->iobuffer;
|
||||
for (col = cinfo->image_width; col > 0; col--) {
|
||||
*ptr++ = rescale[UCH(*bufferptr++)];
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
METHODDEF(JDIMENSION)
|
||||
get_scaled_rgb_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
/* This version is for reading raw-byte-format PPM files with any maxval */
|
||||
{
|
||||
ppm_source_ptr source = (ppm_source_ptr) sinfo;
|
||||
register JSAMPROW ptr;
|
||||
register U_CHAR * bufferptr;
|
||||
register JSAMPLE *rescale = source->rescale;
|
||||
JDIMENSION col;
|
||||
|
||||
if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
|
||||
ERREXIT(cinfo, JERR_INPUT_EOF);
|
||||
ptr = source->pub.buffer[0];
|
||||
bufferptr = source->iobuffer;
|
||||
for (col = cinfo->image_width; col > 0; col--) {
|
||||
*ptr++ = rescale[UCH(*bufferptr++)];
|
||||
*ptr++ = rescale[UCH(*bufferptr++)];
|
||||
*ptr++ = rescale[UCH(*bufferptr++)];
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
METHODDEF(JDIMENSION)
|
||||
get_raw_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
/* This version is for reading raw-byte-format files with maxval = MAXJSAMPLE.
|
||||
* In this case we just read right into the JSAMPLE buffer!
|
||||
* Note that same code works for PPM and PGM files.
|
||||
*/
|
||||
{
|
||||
ppm_source_ptr source = (ppm_source_ptr) sinfo;
|
||||
|
||||
if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
|
||||
ERREXIT(cinfo, JERR_INPUT_EOF);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
METHODDEF(JDIMENSION)
|
||||
get_word_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
/* This version is for reading raw-word-format PGM files with any maxval */
|
||||
{
|
||||
ppm_source_ptr source = (ppm_source_ptr) sinfo;
|
||||
register JSAMPROW ptr;
|
||||
register U_CHAR * bufferptr;
|
||||
register JSAMPLE *rescale = source->rescale;
|
||||
JDIMENSION col;
|
||||
|
||||
if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
|
||||
ERREXIT(cinfo, JERR_INPUT_EOF);
|
||||
ptr = source->pub.buffer[0];
|
||||
bufferptr = source->iobuffer;
|
||||
for (col = cinfo->image_width; col > 0; col--) {
|
||||
register int temp;
|
||||
temp = UCH(*bufferptr++);
|
||||
temp |= UCH(*bufferptr++) << 8;
|
||||
*ptr++ = rescale[temp];
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
METHODDEF(JDIMENSION)
|
||||
get_word_rgb_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
/* This version is for reading raw-word-format PPM files with any maxval */
|
||||
{
|
||||
ppm_source_ptr source = (ppm_source_ptr) sinfo;
|
||||
register JSAMPROW ptr;
|
||||
register U_CHAR * bufferptr;
|
||||
register JSAMPLE *rescale = source->rescale;
|
||||
JDIMENSION col;
|
||||
|
||||
if (! ReadOK(source->pub.input_file, source->iobuffer, source->buffer_width))
|
||||
ERREXIT(cinfo, JERR_INPUT_EOF);
|
||||
ptr = source->pub.buffer[0];
|
||||
bufferptr = source->iobuffer;
|
||||
for (col = cinfo->image_width; col > 0; col--) {
|
||||
register int temp;
|
||||
temp = UCH(*bufferptr++);
|
||||
temp |= UCH(*bufferptr++) << 8;
|
||||
*ptr++ = rescale[temp];
|
||||
temp = UCH(*bufferptr++);
|
||||
temp |= UCH(*bufferptr++) << 8;
|
||||
*ptr++ = rescale[temp];
|
||||
temp = UCH(*bufferptr++);
|
||||
temp |= UCH(*bufferptr++) << 8;
|
||||
*ptr++ = rescale[temp];
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Read the file header; return image size and component count.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
start_input_ppm (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
{
|
||||
ppm_source_ptr source = (ppm_source_ptr) sinfo;
|
||||
int c;
|
||||
unsigned int w, h, maxval;
|
||||
boolean need_iobuffer, use_raw_buffer, need_rescale;
|
||||
|
||||
if (getc(source->pub.input_file) != 'P')
|
||||
ERREXIT(cinfo, JERR_PPM_NOT);
|
||||
|
||||
c = getc(source->pub.input_file); /* subformat discriminator character */
|
||||
|
||||
/* detect unsupported variants (ie, PBM) before trying to read header */
|
||||
switch (c) {
|
||||
case '2': /* it's a text-format PGM file */
|
||||
case '3': /* it's a text-format PPM file */
|
||||
case '5': /* it's a raw-format PGM file */
|
||||
case '6': /* it's a raw-format PPM file */
|
||||
break;
|
||||
default:
|
||||
ERREXIT(cinfo, JERR_PPM_NOT);
|
||||
break;
|
||||
}
|
||||
|
||||
/* fetch the remaining header info */
|
||||
w = read_pbm_integer(cinfo, source->pub.input_file);
|
||||
h = read_pbm_integer(cinfo, source->pub.input_file);
|
||||
maxval = read_pbm_integer(cinfo, source->pub.input_file);
|
||||
|
||||
if (w <= 0 || h <= 0 || maxval <= 0) /* error check */
|
||||
ERREXIT(cinfo, JERR_PPM_NOT);
|
||||
|
||||
cinfo->data_precision = BITS_IN_JSAMPLE; /* we always rescale data to this */
|
||||
cinfo->image_width = (JDIMENSION) w;
|
||||
cinfo->image_height = (JDIMENSION) h;
|
||||
|
||||
/* initialize flags to most common settings */
|
||||
need_iobuffer = TRUE; /* do we need an I/O buffer? */
|
||||
use_raw_buffer = FALSE; /* do we map input buffer onto I/O buffer? */
|
||||
need_rescale = TRUE; /* do we need a rescale array? */
|
||||
|
||||
switch (c) {
|
||||
case '2': /* it's a text-format PGM file */
|
||||
cinfo->input_components = 1;
|
||||
cinfo->in_color_space = JCS_GRAYSCALE;
|
||||
TRACEMS2(cinfo, 1, JTRC_PGM_TEXT, w, h);
|
||||
source->pub.get_pixel_rows = get_text_gray_row;
|
||||
need_iobuffer = FALSE;
|
||||
break;
|
||||
|
||||
case '3': /* it's a text-format PPM file */
|
||||
cinfo->input_components = 3;
|
||||
cinfo->in_color_space = JCS_RGB;
|
||||
TRACEMS2(cinfo, 1, JTRC_PPM_TEXT, w, h);
|
||||
source->pub.get_pixel_rows = get_text_rgb_row;
|
||||
need_iobuffer = FALSE;
|
||||
break;
|
||||
|
||||
case '5': /* it's a raw-format PGM file */
|
||||
cinfo->input_components = 1;
|
||||
cinfo->in_color_space = JCS_GRAYSCALE;
|
||||
TRACEMS2(cinfo, 1, JTRC_PGM, w, h);
|
||||
if (maxval > 255) {
|
||||
source->pub.get_pixel_rows = get_word_gray_row;
|
||||
} else if (maxval == MAXJSAMPLE && SIZEOF(JSAMPLE) == SIZEOF(U_CHAR)) {
|
||||
source->pub.get_pixel_rows = get_raw_row;
|
||||
use_raw_buffer = TRUE;
|
||||
need_rescale = FALSE;
|
||||
} else {
|
||||
source->pub.get_pixel_rows = get_scaled_gray_row;
|
||||
}
|
||||
break;
|
||||
|
||||
case '6': /* it's a raw-format PPM file */
|
||||
cinfo->input_components = 3;
|
||||
cinfo->in_color_space = JCS_RGB;
|
||||
TRACEMS2(cinfo, 1, JTRC_PPM, w, h);
|
||||
if (maxval > 255) {
|
||||
source->pub.get_pixel_rows = get_word_rgb_row;
|
||||
} else if (maxval == MAXJSAMPLE && SIZEOF(JSAMPLE) == SIZEOF(U_CHAR)) {
|
||||
source->pub.get_pixel_rows = get_raw_row;
|
||||
use_raw_buffer = TRUE;
|
||||
need_rescale = FALSE;
|
||||
} else {
|
||||
source->pub.get_pixel_rows = get_scaled_rgb_row;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
/* Allocate space for I/O buffer: 1 or 3 bytes or words/pixel. */
|
||||
if (need_iobuffer) {
|
||||
source->buffer_width = (size_t) w * cinfo->input_components *
|
||||
((maxval<=255) ? SIZEOF(U_CHAR) : (2*SIZEOF(U_CHAR)));
|
||||
source->iobuffer = (U_CHAR *)
|
||||
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
|
||||
source->buffer_width);
|
||||
}
|
||||
|
||||
/* Create compressor input buffer. */
|
||||
if (use_raw_buffer) {
|
||||
/* For unscaled raw-input case, we can just map it onto the I/O buffer. */
|
||||
/* Synthesize a JSAMPARRAY pointer structure */
|
||||
/* Cast here implies near->far pointer conversion on PCs */
|
||||
source->pixrow = (JSAMPROW) source->iobuffer;
|
||||
source->pub.buffer = & source->pixrow;
|
||||
source->pub.buffer_height = 1;
|
||||
} else {
|
||||
/* Need to translate anyway, so make a separate sample buffer. */
|
||||
source->pub.buffer = (*cinfo->mem->alloc_sarray)
|
||||
((j_common_ptr) cinfo, JPOOL_IMAGE,
|
||||
(JDIMENSION) w * cinfo->input_components, (JDIMENSION) 1);
|
||||
source->pub.buffer_height = 1;
|
||||
}
|
||||
|
||||
/* Compute the rescaling array if required. */
|
||||
if (need_rescale) {
|
||||
INT32 val, half_maxval;
|
||||
|
||||
/* On 16-bit-int machines we have to be careful of maxval = 65535 */
|
||||
source->rescale = (JSAMPLE *)
|
||||
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
|
||||
(size_t) (((long) maxval + 1L) * SIZEOF(JSAMPLE)));
|
||||
half_maxval = maxval / 2;
|
||||
for (val = 0; val <= (INT32) maxval; val++) {
|
||||
/* The multiplication here must be done in 32 bits to avoid overflow */
|
||||
source->rescale[val] = (JSAMPLE) ((val*MAXJSAMPLE + half_maxval)/maxval);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Finish up at the end of the file.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
finish_input_ppm (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
{
|
||||
/* no work */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* The module selection routine for PPM format input.
|
||||
*/
|
||||
|
||||
GLOBAL(cjpeg_source_ptr)
|
||||
jinit_read_ppm (j_compress_ptr cinfo)
|
||||
{
|
||||
ppm_source_ptr source;
|
||||
|
||||
/* Create module interface object */
|
||||
source = (ppm_source_ptr)
|
||||
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
|
||||
SIZEOF(ppm_source_struct));
|
||||
/* Fill in method ptrs, except get_pixel_rows which start_input sets */
|
||||
source->pub.start_input = start_input_ppm;
|
||||
source->pub.finish_input = finish_input_ppm;
|
||||
|
||||
return (cjpeg_source_ptr) source;
|
||||
}
|
||||
|
||||
#endif /* PPM_SUPPORTED */
|
||||
|
|
@ -0,0 +1,332 @@
|
|||
/*
|
||||
* rdswitch.c
|
||||
*
|
||||
* Copyright (C) 1991-1996, Thomas G. Lane.
|
||||
* This file is part of the Independent JPEG Group's software.
|
||||
* For conditions of distribution and use, see the accompanying README file.
|
||||
*
|
||||
* This file contains routines to process some of cjpeg's more complicated
|
||||
* command-line switches. Switches processed here are:
|
||||
* -qtables file Read quantization tables from text file
|
||||
* -scans file Read scan script from text file
|
||||
* -qslots N[,N,...] Set component quantization table selectors
|
||||
* -sample HxV[,HxV,...] Set component sampling factors
|
||||
*/
|
||||
|
||||
#include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
|
||||
#include <ctype.h> /* to declare isdigit(), isspace() */
|
||||
|
||||
|
||||
LOCAL(int)
|
||||
text_getc (FILE * file)
|
||||
/* Read next char, skipping over any comments (# to end of line) */
|
||||
/* A comment/newline sequence is returned as a newline */
|
||||
{
|
||||
register int ch;
|
||||
|
||||
ch = getc(file);
|
||||
if (ch == '#') {
|
||||
do {
|
||||
ch = getc(file);
|
||||
} while (ch != '\n' && ch != EOF);
|
||||
}
|
||||
return ch;
|
||||
}
|
||||
|
||||
|
||||
LOCAL(boolean)
|
||||
read_text_integer (FILE * file, long * result, int * termchar)
|
||||
/* Read an unsigned decimal integer from a file, store it in result */
|
||||
/* Reads one trailing character after the integer; returns it in termchar */
|
||||
{
|
||||
register int ch;
|
||||
register long val;
|
||||
|
||||
/* Skip any leading whitespace, detect EOF */
|
||||
do {
|
||||
ch = text_getc(file);
|
||||
if (ch == EOF) {
|
||||
*termchar = ch;
|
||||
return FALSE;
|
||||
}
|
||||
} while (isspace(ch));
|
||||
|
||||
if (! isdigit(ch)) {
|
||||
*termchar = ch;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
val = ch - '0';
|
||||
while ((ch = text_getc(file)) != EOF) {
|
||||
if (! isdigit(ch))
|
||||
break;
|
||||
val *= 10;
|
||||
val += ch - '0';
|
||||
}
|
||||
*result = val;
|
||||
*termchar = ch;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
GLOBAL(boolean)
|
||||
read_quant_tables (j_compress_ptr cinfo, char * filename,
|
||||
int scale_factor, boolean force_baseline)
|
||||
/* Read a set of quantization tables from the specified file.
|
||||
* The file is plain ASCII text: decimal numbers with whitespace between.
|
||||
* Comments preceded by '#' may be included in the file.
|
||||
* There may be one to NUM_QUANT_TBLS tables in the file, each of 64 values.
|
||||
* The tables are implicitly numbered 0,1,etc.
|
||||
* NOTE: does not affect the qslots mapping, which will default to selecting
|
||||
* table 0 for luminance (or primary) components, 1 for chrominance components.
|
||||
* You must use -qslots if you want a different component->table mapping.
|
||||
*/
|
||||
{
|
||||
FILE * fp;
|
||||
int tblno, i, termchar;
|
||||
long val;
|
||||
unsigned int table[DCTSIZE2];
|
||||
|
||||
if ((fp = fopen(filename, "r")) == NULL) {
|
||||
fprintf(stderr, "Can't open table file %s\n", filename);
|
||||
return FALSE;
|
||||
}
|
||||
tblno = 0;
|
||||
|
||||
while (read_text_integer(fp, &val, &termchar)) { /* read 1st element of table */
|
||||
if (tblno >= NUM_QUANT_TBLS) {
|
||||
fprintf(stderr, "Too many tables in file %s\n", filename);
|
||||
fclose(fp);
|
||||
return FALSE;
|
||||
}
|
||||
table[0] = (unsigned int) val;
|
||||
for (i = 1; i < DCTSIZE2; i++) {
|
||||
if (! read_text_integer(fp, &val, &termchar)) {
|
||||
fprintf(stderr, "Invalid table data in file %s\n", filename);
|
||||
fclose(fp);
|
||||
return FALSE;
|
||||
}
|
||||
table[i] = (unsigned int) val;
|
||||
}
|
||||
jpeg_add_quant_table(cinfo, tblno, table, scale_factor, force_baseline);
|
||||
tblno++;
|
||||
}
|
||||
|
||||
if (termchar != EOF) {
|
||||
fprintf(stderr, "Non-numeric data in file %s\n", filename);
|
||||
fclose(fp);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
fclose(fp);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
#ifdef C_MULTISCAN_FILES_SUPPORTED
|
||||
|
||||
LOCAL(boolean)
|
||||
read_scan_integer (FILE * file, long * result, int * termchar)
|
||||
/* Variant of read_text_integer that always looks for a non-space termchar;
|
||||
* this simplifies parsing of punctuation in scan scripts.
|
||||
*/
|
||||
{
|
||||
register int ch;
|
||||
|
||||
if (! read_text_integer(file, result, termchar))
|
||||
return FALSE;
|
||||
ch = *termchar;
|
||||
while (ch != EOF && isspace(ch))
|
||||
ch = text_getc(file);
|
||||
if (isdigit(ch)) { /* oops, put it back */
|
||||
if (ungetc(ch, file) == EOF)
|
||||
return FALSE;
|
||||
ch = ' ';
|
||||
} else {
|
||||
/* Any separators other than ';' and ':' are ignored;
|
||||
* this allows user to insert commas, etc, if desired.
|
||||
*/
|
||||
if (ch != EOF && ch != ';' && ch != ':')
|
||||
ch = ' ';
|
||||
}
|
||||
*termchar = ch;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
GLOBAL(boolean)
|
||||
read_scan_script (j_compress_ptr cinfo, char * filename)
|
||||
/* Read a scan script from the specified text file.
|
||||
* Each entry in the file defines one scan to be emitted.
|
||||
* Entries are separated by semicolons ';'.
|
||||
* An entry contains one to four component indexes,
|
||||
* optionally followed by a colon ':' and four progressive-JPEG parameters.
|
||||
* The component indexes denote which component(s) are to be transmitted
|
||||
* in the current scan. The first component has index 0.
|
||||
* Sequential JPEG is used if the progressive-JPEG parameters are omitted.
|
||||
* The file is free format text: any whitespace may appear between numbers
|
||||
* and the ':' and ';' punctuation marks. Also, other punctuation (such
|
||||
* as commas or dashes) can be placed between numbers if desired.
|
||||
* Comments preceded by '#' may be included in the file.
|
||||
* Note: we do very little validity checking here;
|
||||
* jcmaster.c will validate the script parameters.
|
||||
*/
|
||||
{
|
||||
FILE * fp;
|
||||
int scanno, ncomps, termchar;
|
||||
long val;
|
||||
jpeg_scan_info * scanptr;
|
||||
#define MAX_SCANS 100 /* quite arbitrary limit */
|
||||
jpeg_scan_info scans[MAX_SCANS];
|
||||
|
||||
if ((fp = fopen(filename, "r")) == NULL) {
|
||||
fprintf(stderr, "Can't open scan definition file %s\n", filename);
|
||||
return FALSE;
|
||||
}
|
||||
scanptr = scans;
|
||||
scanno = 0;
|
||||
|
||||
while (read_scan_integer(fp, &val, &termchar)) {
|
||||
if (scanno >= MAX_SCANS) {
|
||||
fprintf(stderr, "Too many scans defined in file %s\n", filename);
|
||||
fclose(fp);
|
||||
return FALSE;
|
||||
}
|
||||
scanptr->component_index[0] = (int) val;
|
||||
ncomps = 1;
|
||||
while (termchar == ' ') {
|
||||
if (ncomps >= MAX_COMPS_IN_SCAN) {
|
||||
fprintf(stderr, "Too many components in one scan in file %s\n",
|
||||
filename);
|
||||
fclose(fp);
|
||||
return FALSE;
|
||||
}
|
||||
if (! read_scan_integer(fp, &val, &termchar))
|
||||
goto bogus;
|
||||
scanptr->component_index[ncomps] = (int) val;
|
||||
ncomps++;
|
||||
}
|
||||
scanptr->comps_in_scan = ncomps;
|
||||
if (termchar == ':') {
|
||||
if (! read_scan_integer(fp, &val, &termchar) || termchar != ' ')
|
||||
goto bogus;
|
||||
scanptr->Ss = (int) val;
|
||||
if (! read_scan_integer(fp, &val, &termchar) || termchar != ' ')
|
||||
goto bogus;
|
||||
scanptr->Se = (int) val;
|
||||
if (! read_scan_integer(fp, &val, &termchar) || termchar != ' ')
|
||||
goto bogus;
|
||||
scanptr->Ah = (int) val;
|
||||
if (! read_scan_integer(fp, &val, &termchar))
|
||||
goto bogus;
|
||||
scanptr->Al = (int) val;
|
||||
} else {
|
||||
/* set non-progressive parameters */
|
||||
scanptr->Ss = 0;
|
||||
scanptr->Se = DCTSIZE2-1;
|
||||
scanptr->Ah = 0;
|
||||
scanptr->Al = 0;
|
||||
}
|
||||
if (termchar != ';' && termchar != EOF) {
|
||||
bogus:
|
||||
fprintf(stderr, "Invalid scan entry format in file %s\n", filename);
|
||||
fclose(fp);
|
||||
return FALSE;
|
||||
}
|
||||
scanptr++, scanno++;
|
||||
}
|
||||
|
||||
if (termchar != EOF) {
|
||||
fprintf(stderr, "Non-numeric data in file %s\n", filename);
|
||||
fclose(fp);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (scanno > 0) {
|
||||
/* Stash completed scan list in cinfo structure.
|
||||
* NOTE: for cjpeg's use, JPOOL_IMAGE is the right lifetime for this data,
|
||||
* but if you want to compress multiple images you'd want JPOOL_PERMANENT.
|
||||
*/
|
||||
scanptr = (jpeg_scan_info *)
|
||||
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
|
||||
scanno * SIZEOF(jpeg_scan_info));
|
||||
MEMCOPY(scanptr, scans, scanno * SIZEOF(jpeg_scan_info));
|
||||
cinfo->scan_info = scanptr;
|
||||
cinfo->num_scans = scanno;
|
||||
}
|
||||
|
||||
fclose(fp);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
#endif /* C_MULTISCAN_FILES_SUPPORTED */
|
||||
|
||||
|
||||
GLOBAL(boolean)
|
||||
set_quant_slots (j_compress_ptr cinfo, char *arg)
|
||||
/* Process a quantization-table-selectors parameter string, of the form
|
||||
* N[,N,...]
|
||||
* If there are more components than parameters, the last value is replicated.
|
||||
*/
|
||||
{
|
||||
int val = 0; /* default table # */
|
||||
int ci;
|
||||
char ch;
|
||||
|
||||
for (ci = 0; ci < MAX_COMPONENTS; ci++) {
|
||||
if (*arg) {
|
||||
ch = ','; /* if not set by sscanf, will be ',' */
|
||||
if (sscanf(arg, "%d%c", &val, &ch) < 1)
|
||||
return FALSE;
|
||||
if (ch != ',') /* syntax check */
|
||||
return FALSE;
|
||||
if (val < 0 || val >= NUM_QUANT_TBLS) {
|
||||
fprintf(stderr, "JPEG quantization tables are numbered 0..%d\n",
|
||||
NUM_QUANT_TBLS-1);
|
||||
return FALSE;
|
||||
}
|
||||
cinfo->comp_info[ci].quant_tbl_no = val;
|
||||
while (*arg && *arg++ != ',') /* advance to next segment of arg string */
|
||||
;
|
||||
} else {
|
||||
/* reached end of parameter, set remaining components to last table */
|
||||
cinfo->comp_info[ci].quant_tbl_no = val;
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
GLOBAL(boolean)
|
||||
set_sample_factors (j_compress_ptr cinfo, char *arg)
|
||||
/* Process a sample-factors parameter string, of the form
|
||||
* HxV[,HxV,...]
|
||||
* If there are more components than parameters, "1x1" is assumed for the rest.
|
||||
*/
|
||||
{
|
||||
int ci, val1, val2;
|
||||
char ch1, ch2;
|
||||
|
||||
for (ci = 0; ci < MAX_COMPONENTS; ci++) {
|
||||
if (*arg) {
|
||||
ch2 = ','; /* if not set by sscanf, will be ',' */
|
||||
if (sscanf(arg, "%d%c%d%c", &val1, &ch1, &val2, &ch2) < 3)
|
||||
return FALSE;
|
||||
if ((ch1 != 'x' && ch1 != 'X') || ch2 != ',') /* syntax check */
|
||||
return FALSE;
|
||||
if (val1 <= 0 || val1 > 4 || val2 <= 0 || val2 > 4) {
|
||||
fprintf(stderr, "JPEG sampling factors must be 1..4\n");
|
||||
return FALSE;
|
||||
}
|
||||
cinfo->comp_info[ci].h_samp_factor = val1;
|
||||
cinfo->comp_info[ci].v_samp_factor = val2;
|
||||
while (*arg && *arg++ != ',') /* advance to next segment of arg string */
|
||||
;
|
||||
} else {
|
||||
/* reached end of parameter, set remaining components to 1x1 sampling */
|
||||
cinfo->comp_info[ci].h_samp_factor = 1;
|
||||
cinfo->comp_info[ci].v_samp_factor = 1;
|
||||
}
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
|
@ -0,0 +1,500 @@
|
|||
/*
|
||||
* rdtarga.c
|
||||
*
|
||||
* Copyright (C) 1991-1996, Thomas G. Lane.
|
||||
* This file is part of the Independent JPEG Group's software.
|
||||
* For conditions of distribution and use, see the accompanying README file.
|
||||
*
|
||||
* This file contains routines to read input images in Targa format.
|
||||
*
|
||||
* These routines may need modification for non-Unix environments or
|
||||
* specialized applications. As they stand, they assume input from
|
||||
* an ordinary stdio stream. They further assume that reading begins
|
||||
* at the start of the file; start_input may need work if the
|
||||
* user interface has already read some data (e.g., to determine that
|
||||
* the file is indeed Targa format).
|
||||
*
|
||||
* Based on code contributed by Lee Daniel Crocker.
|
||||
*/
|
||||
|
||||
#include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
|
||||
|
||||
#ifdef TARGA_SUPPORTED
|
||||
|
||||
|
||||
/* Macros to deal with unsigned chars as efficiently as compiler allows */
|
||||
|
||||
#ifdef HAVE_UNSIGNED_CHAR
|
||||
typedef unsigned char U_CHAR;
|
||||
#define UCH(x) ((int) (x))
|
||||
#else /* !HAVE_UNSIGNED_CHAR */
|
||||
#ifdef CHAR_IS_UNSIGNED
|
||||
typedef char U_CHAR;
|
||||
#define UCH(x) ((int) (x))
|
||||
#else
|
||||
typedef char U_CHAR;
|
||||
#define UCH(x) ((int) (x) & 0xFF)
|
||||
#endif
|
||||
#endif /* HAVE_UNSIGNED_CHAR */
|
||||
|
||||
|
||||
#define ReadOK(file,buffer,len) (JFREAD(file,buffer,len) == ((size_t) (len)))
|
||||
|
||||
|
||||
/* Private version of data source object */
|
||||
|
||||
typedef struct _tga_source_struct * tga_source_ptr;
|
||||
|
||||
typedef struct _tga_source_struct {
|
||||
struct cjpeg_source_struct pub; /* public fields */
|
||||
|
||||
j_compress_ptr cinfo; /* back link saves passing separate parm */
|
||||
|
||||
JSAMPARRAY colormap; /* Targa colormap (converted to my format) */
|
||||
|
||||
jvirt_sarray_ptr whole_image; /* Needed if funny input row order */
|
||||
JDIMENSION current_row; /* Current logical row number to read */
|
||||
|
||||
/* Pointer to routine to extract next Targa pixel from input file */
|
||||
JMETHOD(void, read_pixel, (tga_source_ptr sinfo));
|
||||
|
||||
/* Result of read_pixel is delivered here: */
|
||||
U_CHAR tga_pixel[4];
|
||||
|
||||
int pixel_size; /* Bytes per Targa pixel (1 to 4) */
|
||||
|
||||
/* State info for reading RLE-coded pixels; both counts must be init to 0 */
|
||||
int block_count; /* # of pixels remaining in RLE block */
|
||||
int dup_pixel_count; /* # of times to duplicate previous pixel */
|
||||
|
||||
/* This saves the correct pixel-row-expansion method for preload_image */
|
||||
JMETHOD(JDIMENSION, get_pixel_rows, (j_compress_ptr cinfo,
|
||||
cjpeg_source_ptr sinfo));
|
||||
} tga_source_struct;
|
||||
|
||||
|
||||
/* For expanding 5-bit pixel values to 8-bit with best rounding */
|
||||
|
||||
static const UINT8 c5to8bits[32] = {
|
||||
0, 8, 16, 25, 33, 41, 49, 58,
|
||||
66, 74, 82, 90, 99, 107, 115, 123,
|
||||
132, 140, 148, 156, 165, 173, 181, 189,
|
||||
197, 206, 214, 222, 230, 239, 247, 255
|
||||
};
|
||||
|
||||
|
||||
|
||||
LOCAL(int)
|
||||
read_byte (tga_source_ptr sinfo)
|
||||
/* Read next byte from Targa file */
|
||||
{
|
||||
register FILE *infile = sinfo->pub.input_file;
|
||||
register int c;
|
||||
|
||||
if ((c = getc(infile)) == EOF)
|
||||
ERREXIT(sinfo->cinfo, JERR_INPUT_EOF);
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
LOCAL(void)
|
||||
read_colormap (tga_source_ptr sinfo, int cmaplen, int mapentrysize)
|
||||
/* Read the colormap from a Targa file */
|
||||
{
|
||||
int i;
|
||||
|
||||
/* Presently only handles 24-bit BGR format */
|
||||
if (mapentrysize != 24)
|
||||
ERREXIT(sinfo->cinfo, JERR_TGA_BADCMAP);
|
||||
|
||||
for (i = 0; i < cmaplen; i++) {
|
||||
sinfo->colormap[2][i] = (JSAMPLE) read_byte(sinfo);
|
||||
sinfo->colormap[1][i] = (JSAMPLE) read_byte(sinfo);
|
||||
sinfo->colormap[0][i] = (JSAMPLE) read_byte(sinfo);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* read_pixel methods: get a single pixel from Targa file into tga_pixel[]
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
read_non_rle_pixel (tga_source_ptr sinfo)
|
||||
/* Read one Targa pixel from the input file; no RLE expansion */
|
||||
{
|
||||
register FILE *infile = sinfo->pub.input_file;
|
||||
register int i;
|
||||
|
||||
for (i = 0; i < sinfo->pixel_size; i++) {
|
||||
sinfo->tga_pixel[i] = (U_CHAR) getc(infile);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
METHODDEF(void)
|
||||
read_rle_pixel (tga_source_ptr sinfo)
|
||||
/* Read one Targa pixel from the input file, expanding RLE data as needed */
|
||||
{
|
||||
register FILE *infile = sinfo->pub.input_file;
|
||||
register int i;
|
||||
|
||||
/* Duplicate previously read pixel? */
|
||||
if (sinfo->dup_pixel_count > 0) {
|
||||
sinfo->dup_pixel_count--;
|
||||
return;
|
||||
}
|
||||
|
||||
/* Time to read RLE block header? */
|
||||
if (--sinfo->block_count < 0) { /* decrement pixels remaining in block */
|
||||
i = read_byte(sinfo);
|
||||
if (i & 0x80) { /* Start of duplicate-pixel block? */
|
||||
sinfo->dup_pixel_count = i & 0x7F; /* number of dups after this one */
|
||||
sinfo->block_count = 0; /* then read new block header */
|
||||
} else {
|
||||
sinfo->block_count = i & 0x7F; /* number of pixels after this one */
|
||||
}
|
||||
}
|
||||
|
||||
/* Read next pixel */
|
||||
for (i = 0; i < sinfo->pixel_size; i++) {
|
||||
sinfo->tga_pixel[i] = (U_CHAR) getc(infile);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Read one row of pixels.
|
||||
*
|
||||
* We provide several different versions depending on input file format.
|
||||
*/
|
||||
|
||||
|
||||
METHODDEF(JDIMENSION)
|
||||
get_8bit_gray_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
/* This version is for reading 8-bit grayscale pixels */
|
||||
{
|
||||
tga_source_ptr source = (tga_source_ptr) sinfo;
|
||||
register JSAMPROW ptr;
|
||||
register JDIMENSION col;
|
||||
|
||||
ptr = source->pub.buffer[0];
|
||||
for (col = cinfo->image_width; col > 0; col--) {
|
||||
(*source->read_pixel) (source); /* Load next pixel into tga_pixel */
|
||||
*ptr++ = (JSAMPLE) UCH(source->tga_pixel[0]);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
METHODDEF(JDIMENSION)
|
||||
get_8bit_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
/* This version is for reading 8-bit colormap indexes */
|
||||
{
|
||||
tga_source_ptr source = (tga_source_ptr) sinfo;
|
||||
register int t;
|
||||
register JSAMPROW ptr;
|
||||
register JDIMENSION col;
|
||||
register JSAMPARRAY colormap = source->colormap;
|
||||
|
||||
ptr = source->pub.buffer[0];
|
||||
for (col = cinfo->image_width; col > 0; col--) {
|
||||
(*source->read_pixel) (source); /* Load next pixel into tga_pixel */
|
||||
t = UCH(source->tga_pixel[0]);
|
||||
*ptr++ = colormap[0][t];
|
||||
*ptr++ = colormap[1][t];
|
||||
*ptr++ = colormap[2][t];
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
METHODDEF(JDIMENSION)
|
||||
get_16bit_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
/* This version is for reading 16-bit pixels */
|
||||
{
|
||||
tga_source_ptr source = (tga_source_ptr) sinfo;
|
||||
register int t;
|
||||
register JSAMPROW ptr;
|
||||
register JDIMENSION col;
|
||||
|
||||
ptr = source->pub.buffer[0];
|
||||
for (col = cinfo->image_width; col > 0; col--) {
|
||||
(*source->read_pixel) (source); /* Load next pixel into tga_pixel */
|
||||
t = UCH(source->tga_pixel[0]);
|
||||
t += UCH(source->tga_pixel[1]) << 8;
|
||||
/* We expand 5 bit data to 8 bit sample width.
|
||||
* The format of the 16-bit (LSB first) input word is
|
||||
* xRRRRRGGGGGBBBBB
|
||||
*/
|
||||
ptr[2] = (JSAMPLE) c5to8bits[t & 0x1F];
|
||||
t >>= 5;
|
||||
ptr[1] = (JSAMPLE) c5to8bits[t & 0x1F];
|
||||
t >>= 5;
|
||||
ptr[0] = (JSAMPLE) c5to8bits[t & 0x1F];
|
||||
ptr += 3;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
METHODDEF(JDIMENSION)
|
||||
get_24bit_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
/* This version is for reading 24-bit pixels */
|
||||
{
|
||||
tga_source_ptr source = (tga_source_ptr) sinfo;
|
||||
register JSAMPROW ptr;
|
||||
register JDIMENSION col;
|
||||
|
||||
ptr = source->pub.buffer[0];
|
||||
for (col = cinfo->image_width; col > 0; col--) {
|
||||
(*source->read_pixel) (source); /* Load next pixel into tga_pixel */
|
||||
*ptr++ = (JSAMPLE) UCH(source->tga_pixel[2]); /* change BGR to RGB order */
|
||||
*ptr++ = (JSAMPLE) UCH(source->tga_pixel[1]);
|
||||
*ptr++ = (JSAMPLE) UCH(source->tga_pixel[0]);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Targa also defines a 32-bit pixel format with order B,G,R,A.
|
||||
* We presently ignore the attribute byte, so the code for reading
|
||||
* these pixels is identical to the 24-bit routine above.
|
||||
* This works because the actual pixel length is only known to read_pixel.
|
||||
*/
|
||||
|
||||
#define get_32bit_row get_24bit_row
|
||||
|
||||
|
||||
/*
|
||||
* This method is for re-reading the input data in standard top-down
|
||||
* row order. The entire image has already been read into whole_image
|
||||
* with proper conversion of pixel format, but it's in a funny row order.
|
||||
*/
|
||||
|
||||
METHODDEF(JDIMENSION)
|
||||
get_memory_row (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
{
|
||||
tga_source_ptr source = (tga_source_ptr) sinfo;
|
||||
JDIMENSION source_row;
|
||||
|
||||
/* Compute row of source that maps to current_row of normal order */
|
||||
/* For now, assume image is bottom-up and not interlaced. */
|
||||
/* NEEDS WORK to support interlaced images! */
|
||||
source_row = cinfo->image_height - source->current_row - 1;
|
||||
|
||||
/* Fetch that row from virtual array */
|
||||
source->pub.buffer = (*cinfo->mem->access_virt_sarray)
|
||||
((j_common_ptr) cinfo, source->whole_image,
|
||||
source_row, (JDIMENSION) 1, FALSE);
|
||||
|
||||
source->current_row++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* This method loads the image into whole_image during the first call on
|
||||
* get_pixel_rows. The get_pixel_rows pointer is then adjusted to call
|
||||
* get_memory_row on subsequent calls.
|
||||
*/
|
||||
|
||||
METHODDEF(JDIMENSION)
|
||||
preload_image (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
{
|
||||
tga_source_ptr source = (tga_source_ptr) sinfo;
|
||||
JDIMENSION row;
|
||||
cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress;
|
||||
|
||||
/* Read the data into a virtual array in input-file row order. */
|
||||
for (row = 0; row < cinfo->image_height; row++) {
|
||||
if (progress != NULL) {
|
||||
progress->pub.pass_counter = (long) row;
|
||||
progress->pub.pass_limit = (long) cinfo->image_height;
|
||||
(*progress->pub.progress_monitor) ((j_common_ptr) cinfo);
|
||||
}
|
||||
source->pub.buffer = (*cinfo->mem->access_virt_sarray)
|
||||
((j_common_ptr) cinfo, source->whole_image, row, (JDIMENSION) 1, TRUE);
|
||||
(*source->get_pixel_rows) (cinfo, sinfo);
|
||||
}
|
||||
if (progress != NULL)
|
||||
progress->completed_extra_passes++;
|
||||
|
||||
/* Set up to read from the virtual array in unscrambled order */
|
||||
source->pub.get_pixel_rows = get_memory_row;
|
||||
source->current_row = 0;
|
||||
/* And read the first row */
|
||||
return get_memory_row(cinfo, sinfo);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Read the file header; return image size and component count.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
start_input_tga (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
{
|
||||
tga_source_ptr source = (tga_source_ptr) sinfo;
|
||||
U_CHAR targaheader[18];
|
||||
int idlen, cmaptype, subtype, flags, interlace_type, components;
|
||||
unsigned int width, height, maplen;
|
||||
boolean is_bottom_up;
|
||||
|
||||
#define GET_2B(offset) ((unsigned int) UCH(targaheader[offset]) + \
|
||||
(((unsigned int) UCH(targaheader[offset+1])) << 8))
|
||||
|
||||
if (! ReadOK(source->pub.input_file, targaheader, 18))
|
||||
ERREXIT(cinfo, JERR_INPUT_EOF);
|
||||
|
||||
/* Pretend "15-bit" pixels are 16-bit --- we ignore attribute bit anyway */
|
||||
if (targaheader[16] == 15)
|
||||
targaheader[16] = 16;
|
||||
|
||||
idlen = UCH(targaheader[0]);
|
||||
cmaptype = UCH(targaheader[1]);
|
||||
subtype = UCH(targaheader[2]);
|
||||
maplen = GET_2B(5);
|
||||
width = GET_2B(12);
|
||||
height = GET_2B(14);
|
||||
source->pixel_size = UCH(targaheader[16]) >> 3;
|
||||
flags = UCH(targaheader[17]); /* Image Descriptor byte */
|
||||
|
||||
is_bottom_up = ((flags & 0x20) == 0); /* bit 5 set => top-down */
|
||||
interlace_type = flags >> 6; /* bits 6/7 are interlace code */
|
||||
|
||||
if (cmaptype > 1 || /* cmaptype must be 0 or 1 */
|
||||
source->pixel_size < 1 || source->pixel_size > 4 ||
|
||||
(UCH(targaheader[16]) & 7) != 0 || /* bits/pixel must be multiple of 8 */
|
||||
interlace_type != 0) /* currently don't allow interlaced image */
|
||||
ERREXIT(cinfo, JERR_TGA_BADPARMS);
|
||||
|
||||
if (subtype > 8) {
|
||||
/* It's an RLE-coded file */
|
||||
source->read_pixel = read_rle_pixel;
|
||||
source->block_count = source->dup_pixel_count = 0;
|
||||
subtype -= 8;
|
||||
} else {
|
||||
/* Non-RLE file */
|
||||
source->read_pixel = read_non_rle_pixel;
|
||||
}
|
||||
|
||||
/* Now should have subtype 1, 2, or 3 */
|
||||
components = 3; /* until proven different */
|
||||
cinfo->in_color_space = JCS_RGB;
|
||||
|
||||
switch (subtype) {
|
||||
case 1: /* Colormapped image */
|
||||
if (source->pixel_size == 1 && cmaptype == 1)
|
||||
source->get_pixel_rows = get_8bit_row;
|
||||
else
|
||||
ERREXIT(cinfo, JERR_TGA_BADPARMS);
|
||||
TRACEMS2(cinfo, 1, JTRC_TGA_MAPPED, width, height);
|
||||
break;
|
||||
case 2: /* RGB image */
|
||||
switch (source->pixel_size) {
|
||||
case 2:
|
||||
source->get_pixel_rows = get_16bit_row;
|
||||
break;
|
||||
case 3:
|
||||
source->get_pixel_rows = get_24bit_row;
|
||||
break;
|
||||
case 4:
|
||||
source->get_pixel_rows = get_32bit_row;
|
||||
break;
|
||||
default:
|
||||
ERREXIT(cinfo, JERR_TGA_BADPARMS);
|
||||
break;
|
||||
}
|
||||
TRACEMS2(cinfo, 1, JTRC_TGA, width, height);
|
||||
break;
|
||||
case 3: /* Grayscale image */
|
||||
components = 1;
|
||||
cinfo->in_color_space = JCS_GRAYSCALE;
|
||||
if (source->pixel_size == 1)
|
||||
source->get_pixel_rows = get_8bit_gray_row;
|
||||
else
|
||||
ERREXIT(cinfo, JERR_TGA_BADPARMS);
|
||||
TRACEMS2(cinfo, 1, JTRC_TGA_GRAY, width, height);
|
||||
break;
|
||||
default:
|
||||
ERREXIT(cinfo, JERR_TGA_BADPARMS);
|
||||
break;
|
||||
}
|
||||
|
||||
if (is_bottom_up) {
|
||||
/* Create a virtual array to buffer the upside-down image. */
|
||||
source->whole_image = (*cinfo->mem->request_virt_sarray)
|
||||
((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
|
||||
(JDIMENSION) width * components, (JDIMENSION) height, (JDIMENSION) 1);
|
||||
if (cinfo->progress != NULL) {
|
||||
cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress;
|
||||
progress->total_extra_passes++; /* count file input as separate pass */
|
||||
}
|
||||
/* source->pub.buffer will point to the virtual array. */
|
||||
source->pub.buffer_height = 1; /* in case anyone looks at it */
|
||||
source->pub.get_pixel_rows = preload_image;
|
||||
} else {
|
||||
/* Don't need a virtual array, but do need a one-row input buffer. */
|
||||
source->whole_image = NULL;
|
||||
source->pub.buffer = (*cinfo->mem->alloc_sarray)
|
||||
((j_common_ptr) cinfo, JPOOL_IMAGE,
|
||||
(JDIMENSION) width * components, (JDIMENSION) 1);
|
||||
source->pub.buffer_height = 1;
|
||||
source->pub.get_pixel_rows = source->get_pixel_rows;
|
||||
}
|
||||
|
||||
while (idlen--) /* Throw away ID field */
|
||||
(void) read_byte(source);
|
||||
|
||||
if (maplen > 0) {
|
||||
if (maplen > 256 || GET_2B(3) != 0)
|
||||
ERREXIT(cinfo, JERR_TGA_BADCMAP);
|
||||
/* Allocate space to store the colormap */
|
||||
source->colormap = (*cinfo->mem->alloc_sarray)
|
||||
((j_common_ptr) cinfo, JPOOL_IMAGE, (JDIMENSION) maplen, (JDIMENSION) 3);
|
||||
/* and read it from the file */
|
||||
read_colormap(source, (int) maplen, UCH(targaheader[7]));
|
||||
} else {
|
||||
if (cmaptype) /* but you promised a cmap! */
|
||||
ERREXIT(cinfo, JERR_TGA_BADPARMS);
|
||||
source->colormap = NULL;
|
||||
}
|
||||
|
||||
cinfo->input_components = components;
|
||||
cinfo->data_precision = 8;
|
||||
cinfo->image_width = width;
|
||||
cinfo->image_height = height;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Finish up at the end of the file.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
finish_input_tga (j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
|
||||
{
|
||||
/* no work */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* The module selection routine for Targa format input.
|
||||
*/
|
||||
|
||||
GLOBAL(cjpeg_source_ptr)
|
||||
jinit_read_targa (j_compress_ptr cinfo)
|
||||
{
|
||||
tga_source_ptr source;
|
||||
|
||||
/* Create module interface object */
|
||||
source = (tga_source_ptr)
|
||||
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
|
||||
SIZEOF(tga_source_struct));
|
||||
source->cinfo = cinfo; /* make back link for subroutines */
|
||||
/* Fill in method ptrs, except get_pixel_rows which start_input sets */
|
||||
source->pub.start_input = start_input_tga;
|
||||
source->pub.finish_input = finish_input_tga;
|
||||
|
||||
return (cjpeg_source_ptr) source;
|
||||
}
|
||||
|
||||
#endif /* TARGA_SUPPORTED */
|
||||
|
|
@ -0,0 +1,442 @@
|
|||
/*
|
||||
* wrbmp.c
|
||||
*
|
||||
* Copyright (C) 1994-1996, Thomas G. Lane.
|
||||
* This file is part of the Independent JPEG Group's software.
|
||||
* For conditions of distribution and use, see the accompanying README file.
|
||||
*
|
||||
* This file contains routines to write output images in Microsoft "BMP"
|
||||
* format (MS Windows 3.x and OS/2 1.x flavors).
|
||||
* Either 8-bit colormapped or 24-bit full-color format can be written.
|
||||
* No compression is supported.
|
||||
*
|
||||
* These routines may need modification for non-Unix environments or
|
||||
* specialized applications. As they stand, they assume output to
|
||||
* an ordinary stdio stream.
|
||||
*
|
||||
* This code contributed by James Arthur Boucher.
|
||||
*/
|
||||
|
||||
#include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
|
||||
|
||||
#ifdef BMP_SUPPORTED
|
||||
|
||||
|
||||
/*
|
||||
* To support 12-bit JPEG data, we'd have to scale output down to 8 bits.
|
||||
* This is not yet implemented.
|
||||
*/
|
||||
|
||||
#if BITS_IN_JSAMPLE != 8
|
||||
Sorry, this code only copes with 8-bit JSAMPLEs. /* deliberate syntax err */
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Since BMP stores scanlines bottom-to-top, we have to invert the image
|
||||
* from JPEG's top-to-bottom order. To do this, we save the outgoing data
|
||||
* in a virtual array during put_pixel_row calls, then actually emit the
|
||||
* BMP file during finish_output. The virtual array contains one JSAMPLE per
|
||||
* pixel if the output is grayscale or colormapped, three if it is full color.
|
||||
*/
|
||||
|
||||
/* Private version of data destination object */
|
||||
|
||||
typedef struct {
|
||||
struct djpeg_dest_struct pub; /* public fields */
|
||||
|
||||
boolean is_os2; /* saves the OS2 format request flag */
|
||||
|
||||
jvirt_sarray_ptr whole_image; /* needed to reverse row order */
|
||||
JDIMENSION data_width; /* JSAMPLEs per row */
|
||||
JDIMENSION row_width; /* physical width of one row in the BMP file */
|
||||
int pad_bytes; /* number of padding bytes needed per row */
|
||||
JDIMENSION cur_output_row; /* next row# to write to virtual array */
|
||||
} bmp_dest_struct;
|
||||
|
||||
typedef bmp_dest_struct * bmp_dest_ptr;
|
||||
|
||||
|
||||
/* Forward declarations */
|
||||
LOCAL(void) write_colormap
|
||||
JPP((j_decompress_ptr cinfo, bmp_dest_ptr dest,
|
||||
int map_colors, int map_entry_size));
|
||||
|
||||
|
||||
/*
|
||||
* Write some pixel data.
|
||||
* In this module rows_supplied will always be 1.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
put_pixel_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
|
||||
JDIMENSION rows_supplied)
|
||||
/* This version is for writing 24-bit pixels */
|
||||
{
|
||||
bmp_dest_ptr dest = (bmp_dest_ptr) dinfo;
|
||||
JSAMPARRAY image_ptr;
|
||||
register JSAMPROW inptr, outptr;
|
||||
register JDIMENSION col;
|
||||
int pad;
|
||||
|
||||
/* Access next row in virtual array */
|
||||
image_ptr = (*cinfo->mem->access_virt_sarray)
|
||||
((j_common_ptr) cinfo, dest->whole_image,
|
||||
dest->cur_output_row, (JDIMENSION) 1, TRUE);
|
||||
dest->cur_output_row++;
|
||||
|
||||
/* Transfer data. Note destination values must be in BGR order
|
||||
* (even though Microsoft's own documents say the opposite).
|
||||
*/
|
||||
inptr = dest->pub.buffer[0];
|
||||
outptr = image_ptr[0];
|
||||
for (col = cinfo->output_width; col > 0; col--) {
|
||||
outptr[2] = *inptr++; /* can omit GETJSAMPLE() safely */
|
||||
outptr[1] = *inptr++;
|
||||
outptr[0] = *inptr++;
|
||||
outptr += 3;
|
||||
}
|
||||
|
||||
/* Zero out the pad bytes. */
|
||||
pad = dest->pad_bytes;
|
||||
while (--pad >= 0)
|
||||
*outptr++ = 0;
|
||||
}
|
||||
|
||||
METHODDEF(void)
|
||||
put_gray_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
|
||||
JDIMENSION rows_supplied)
|
||||
/* This version is for grayscale OR quantized color output */
|
||||
{
|
||||
bmp_dest_ptr dest = (bmp_dest_ptr) dinfo;
|
||||
JSAMPARRAY image_ptr;
|
||||
register JSAMPROW inptr, outptr;
|
||||
register JDIMENSION col;
|
||||
int pad;
|
||||
|
||||
/* Access next row in virtual array */
|
||||
image_ptr = (*cinfo->mem->access_virt_sarray)
|
||||
((j_common_ptr) cinfo, dest->whole_image,
|
||||
dest->cur_output_row, (JDIMENSION) 1, TRUE);
|
||||
dest->cur_output_row++;
|
||||
|
||||
/* Transfer data. */
|
||||
inptr = dest->pub.buffer[0];
|
||||
outptr = image_ptr[0];
|
||||
for (col = cinfo->output_width; col > 0; col--) {
|
||||
*outptr++ = *inptr++; /* can omit GETJSAMPLE() safely */
|
||||
}
|
||||
|
||||
/* Zero out the pad bytes. */
|
||||
pad = dest->pad_bytes;
|
||||
while (--pad >= 0)
|
||||
*outptr++ = 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Startup: normally writes the file header.
|
||||
* In this module we may as well postpone everything until finish_output.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
start_output_bmp (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
|
||||
{
|
||||
/* no work here */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Finish up at the end of the file.
|
||||
*
|
||||
* Here is where we really output the BMP file.
|
||||
*
|
||||
* First, routines to write the Windows and OS/2 variants of the file header.
|
||||
*/
|
||||
|
||||
LOCAL(void)
|
||||
write_bmp_header (j_decompress_ptr cinfo, bmp_dest_ptr dest)
|
||||
/* Write a Windows-style BMP file header, including colormap if needed */
|
||||
{
|
||||
char bmpfileheader[14];
|
||||
char bmpinfoheader[40];
|
||||
#define PUT_2B(array,offset,value) \
|
||||
(array[offset] = (char) ((value) & 0xFF), \
|
||||
array[offset+1] = (char) (((value) >> 8) & 0xFF))
|
||||
#define PUT_4B(array,offset,value) \
|
||||
(array[offset] = (char) ((value) & 0xFF), \
|
||||
array[offset+1] = (char) (((value) >> 8) & 0xFF), \
|
||||
array[offset+2] = (char) (((value) >> 16) & 0xFF), \
|
||||
array[offset+3] = (char) (((value) >> 24) & 0xFF))
|
||||
INT32 headersize, bfSize;
|
||||
int bits_per_pixel, cmap_entries;
|
||||
|
||||
/* Compute colormap size and total file size */
|
||||
if (cinfo->out_color_space == JCS_RGB) {
|
||||
if (cinfo->quantize_colors) {
|
||||
/* Colormapped RGB */
|
||||
bits_per_pixel = 8;
|
||||
cmap_entries = 256;
|
||||
} else {
|
||||
/* Unquantized, full color RGB */
|
||||
bits_per_pixel = 24;
|
||||
cmap_entries = 0;
|
||||
}
|
||||
} else {
|
||||
/* Grayscale output. We need to fake a 256-entry colormap. */
|
||||
bits_per_pixel = 8;
|
||||
cmap_entries = 256;
|
||||
}
|
||||
/* File size */
|
||||
headersize = 14 + 40 + cmap_entries * 4; /* Header and colormap */
|
||||
bfSize = headersize + (INT32) dest->row_width * (INT32) cinfo->output_height;
|
||||
|
||||
/* Set unused fields of header to 0 */
|
||||
MEMZERO(bmpfileheader, SIZEOF(bmpfileheader));
|
||||
MEMZERO(bmpinfoheader, SIZEOF(bmpinfoheader));
|
||||
|
||||
/* Fill the file header */
|
||||
bmpfileheader[0] = 0x42; /* first 2 bytes are ASCII 'B', 'M' */
|
||||
bmpfileheader[1] = 0x4D;
|
||||
PUT_4B(bmpfileheader, 2, bfSize); /* bfSize */
|
||||
/* we leave bfReserved1 & bfReserved2 = 0 */
|
||||
PUT_4B(bmpfileheader, 10, headersize); /* bfOffBits */
|
||||
|
||||
/* Fill the info header (Microsoft calls this a BITMAPINFOHEADER) */
|
||||
PUT_2B(bmpinfoheader, 0, 40); /* biSize */
|
||||
PUT_4B(bmpinfoheader, 4, cinfo->output_width); /* biWidth */
|
||||
PUT_4B(bmpinfoheader, 8, cinfo->output_height); /* biHeight */
|
||||
PUT_2B(bmpinfoheader, 12, 1); /* biPlanes - must be 1 */
|
||||
PUT_2B(bmpinfoheader, 14, bits_per_pixel); /* biBitCount */
|
||||
/* we leave biCompression = 0, for none */
|
||||
/* we leave biSizeImage = 0; this is correct for uncompressed data */
|
||||
if (cinfo->density_unit == 2) { /* if have density in dots/cm, then */
|
||||
PUT_4B(bmpinfoheader, 24, (INT32) (cinfo->X_density*100)); /* XPels/M */
|
||||
PUT_4B(bmpinfoheader, 28, (INT32) (cinfo->Y_density*100)); /* XPels/M */
|
||||
}
|
||||
PUT_2B(bmpinfoheader, 32, cmap_entries); /* biClrUsed */
|
||||
/* we leave biClrImportant = 0 */
|
||||
|
||||
if (JFWRITE(dest->pub.output_file, bmpfileheader, 14) != (size_t) 14)
|
||||
ERREXIT(cinfo, JERR_FILE_WRITE);
|
||||
if (JFWRITE(dest->pub.output_file, bmpinfoheader, 40) != (size_t) 40)
|
||||
ERREXIT(cinfo, JERR_FILE_WRITE);
|
||||
|
||||
if (cmap_entries > 0)
|
||||
write_colormap(cinfo, dest, cmap_entries, 4);
|
||||
}
|
||||
|
||||
|
||||
LOCAL(void)
|
||||
write_os2_header (j_decompress_ptr cinfo, bmp_dest_ptr dest)
|
||||
/* Write an OS2-style BMP file header, including colormap if needed */
|
||||
{
|
||||
char bmpfileheader[14];
|
||||
char bmpcoreheader[12];
|
||||
INT32 headersize, bfSize;
|
||||
int bits_per_pixel, cmap_entries;
|
||||
|
||||
/* Compute colormap size and total file size */
|
||||
if (cinfo->out_color_space == JCS_RGB) {
|
||||
if (cinfo->quantize_colors) {
|
||||
/* Colormapped RGB */
|
||||
bits_per_pixel = 8;
|
||||
cmap_entries = 256;
|
||||
} else {
|
||||
/* Unquantized, full color RGB */
|
||||
bits_per_pixel = 24;
|
||||
cmap_entries = 0;
|
||||
}
|
||||
} else {
|
||||
/* Grayscale output. We need to fake a 256-entry colormap. */
|
||||
bits_per_pixel = 8;
|
||||
cmap_entries = 256;
|
||||
}
|
||||
/* File size */
|
||||
headersize = 14 + 12 + cmap_entries * 3; /* Header and colormap */
|
||||
bfSize = headersize + (INT32) dest->row_width * (INT32) cinfo->output_height;
|
||||
|
||||
/* Set unused fields of header to 0 */
|
||||
MEMZERO(bmpfileheader, SIZEOF(bmpfileheader));
|
||||
MEMZERO(bmpcoreheader, SIZEOF(bmpcoreheader));
|
||||
|
||||
/* Fill the file header */
|
||||
bmpfileheader[0] = 0x42; /* first 2 bytes are ASCII 'B', 'M' */
|
||||
bmpfileheader[1] = 0x4D;
|
||||
PUT_4B(bmpfileheader, 2, bfSize); /* bfSize */
|
||||
/* we leave bfReserved1 & bfReserved2 = 0 */
|
||||
PUT_4B(bmpfileheader, 10, headersize); /* bfOffBits */
|
||||
|
||||
/* Fill the info header (Microsoft calls this a BITMAPCOREHEADER) */
|
||||
PUT_2B(bmpcoreheader, 0, 12); /* bcSize */
|
||||
PUT_2B(bmpcoreheader, 4, cinfo->output_width); /* bcWidth */
|
||||
PUT_2B(bmpcoreheader, 6, cinfo->output_height); /* bcHeight */
|
||||
PUT_2B(bmpcoreheader, 8, 1); /* bcPlanes - must be 1 */
|
||||
PUT_2B(bmpcoreheader, 10, bits_per_pixel); /* bcBitCount */
|
||||
|
||||
if (JFWRITE(dest->pub.output_file, bmpfileheader, 14) != (size_t) 14)
|
||||
ERREXIT(cinfo, JERR_FILE_WRITE);
|
||||
if (JFWRITE(dest->pub.output_file, bmpcoreheader, 12) != (size_t) 12)
|
||||
ERREXIT(cinfo, JERR_FILE_WRITE);
|
||||
|
||||
if (cmap_entries > 0)
|
||||
write_colormap(cinfo, dest, cmap_entries, 3);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Write the colormap.
|
||||
* Windows uses BGR0 map entries; OS/2 uses BGR entries.
|
||||
*/
|
||||
|
||||
LOCAL(void)
|
||||
write_colormap (j_decompress_ptr cinfo, bmp_dest_ptr dest,
|
||||
int map_colors, int map_entry_size)
|
||||
{
|
||||
JSAMPARRAY colormap = cinfo->colormap;
|
||||
int num_colors = cinfo->actual_number_of_colors;
|
||||
FILE * outfile = dest->pub.output_file;
|
||||
int i;
|
||||
|
||||
if (colormap != NULL) {
|
||||
if (cinfo->out_color_components == 3) {
|
||||
/* Normal case with RGB colormap */
|
||||
for (i = 0; i < num_colors; i++) {
|
||||
putc(GETJSAMPLE(colormap[2][i]), outfile);
|
||||
putc(GETJSAMPLE(colormap[1][i]), outfile);
|
||||
putc(GETJSAMPLE(colormap[0][i]), outfile);
|
||||
if (map_entry_size == 4)
|
||||
putc(0, outfile);
|
||||
}
|
||||
} else {
|
||||
/* Grayscale colormap (only happens with grayscale quantization) */
|
||||
for (i = 0; i < num_colors; i++) {
|
||||
putc(GETJSAMPLE(colormap[0][i]), outfile);
|
||||
putc(GETJSAMPLE(colormap[0][i]), outfile);
|
||||
putc(GETJSAMPLE(colormap[0][i]), outfile);
|
||||
if (map_entry_size == 4)
|
||||
putc(0, outfile);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
/* If no colormap, must be grayscale data. Generate a linear "map". */
|
||||
for (i = 0; i < 256; i++) {
|
||||
putc(i, outfile);
|
||||
putc(i, outfile);
|
||||
putc(i, outfile);
|
||||
if (map_entry_size == 4)
|
||||
putc(0, outfile);
|
||||
}
|
||||
}
|
||||
/* Pad colormap with zeros to ensure specified number of colormap entries */
|
||||
if (i > map_colors)
|
||||
ERREXIT1(cinfo, JERR_TOO_MANY_COLORS, i);
|
||||
for (; i < map_colors; i++) {
|
||||
putc(0, outfile);
|
||||
putc(0, outfile);
|
||||
putc(0, outfile);
|
||||
if (map_entry_size == 4)
|
||||
putc(0, outfile);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
METHODDEF(void)
|
||||
finish_output_bmp (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
|
||||
{
|
||||
bmp_dest_ptr dest = (bmp_dest_ptr) dinfo;
|
||||
register FILE * outfile = dest->pub.output_file;
|
||||
JSAMPARRAY image_ptr;
|
||||
register JSAMPROW data_ptr;
|
||||
JDIMENSION row;
|
||||
register JDIMENSION col;
|
||||
cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress;
|
||||
|
||||
/* Write the header and colormap */
|
||||
if (dest->is_os2)
|
||||
write_os2_header(cinfo, dest);
|
||||
else
|
||||
write_bmp_header(cinfo, dest);
|
||||
|
||||
/* Write the file body from our virtual array */
|
||||
for (row = cinfo->output_height; row > 0; row--) {
|
||||
if (progress != NULL) {
|
||||
progress->pub.pass_counter = (long) (cinfo->output_height - row);
|
||||
progress->pub.pass_limit = (long) cinfo->output_height;
|
||||
(*progress->pub.progress_monitor) ((j_common_ptr) cinfo);
|
||||
}
|
||||
image_ptr = (*cinfo->mem->access_virt_sarray)
|
||||
((j_common_ptr) cinfo, dest->whole_image, row-1, (JDIMENSION) 1, FALSE);
|
||||
data_ptr = image_ptr[0];
|
||||
for (col = dest->row_width; col > 0; col--) {
|
||||
putc(GETJSAMPLE(*data_ptr), outfile);
|
||||
data_ptr++;
|
||||
}
|
||||
}
|
||||
if (progress != NULL)
|
||||
progress->completed_extra_passes++;
|
||||
|
||||
/* Make sure we wrote the output file OK */
|
||||
fflush(outfile);
|
||||
if (ferror(outfile))
|
||||
ERREXIT(cinfo, JERR_FILE_WRITE);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* The module selection routine for BMP format output.
|
||||
*/
|
||||
|
||||
GLOBAL(djpeg_dest_ptr)
|
||||
jinit_write_bmp (j_decompress_ptr cinfo, boolean is_os2)
|
||||
{
|
||||
bmp_dest_ptr dest;
|
||||
JDIMENSION row_width;
|
||||
|
||||
/* Create module interface object, fill in method pointers */
|
||||
dest = (bmp_dest_ptr)
|
||||
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
|
||||
SIZEOF(bmp_dest_struct));
|
||||
dest->pub.start_output = start_output_bmp;
|
||||
dest->pub.finish_output = finish_output_bmp;
|
||||
dest->is_os2 = is_os2;
|
||||
|
||||
if (cinfo->out_color_space == JCS_GRAYSCALE) {
|
||||
dest->pub.put_pixel_rows = put_gray_rows;
|
||||
} else if (cinfo->out_color_space == JCS_RGB) {
|
||||
if (cinfo->quantize_colors)
|
||||
dest->pub.put_pixel_rows = put_gray_rows;
|
||||
else
|
||||
dest->pub.put_pixel_rows = put_pixel_rows;
|
||||
} else {
|
||||
ERREXIT(cinfo, JERR_BMP_COLORSPACE);
|
||||
}
|
||||
|
||||
/* Calculate output image dimensions so we can allocate space */
|
||||
jpeg_calc_output_dimensions(cinfo);
|
||||
|
||||
/* Determine width of rows in the BMP file (padded to 4-byte boundary). */
|
||||
row_width = cinfo->output_width * cinfo->output_components;
|
||||
dest->data_width = row_width;
|
||||
while ((row_width & 3) != 0) row_width++;
|
||||
dest->row_width = row_width;
|
||||
dest->pad_bytes = (int) (row_width - dest->data_width);
|
||||
|
||||
/* Allocate space for inversion array, prepare for write pass */
|
||||
dest->whole_image = (*cinfo->mem->request_virt_sarray)
|
||||
((j_common_ptr) cinfo, JPOOL_IMAGE, FALSE,
|
||||
row_width, cinfo->output_height, (JDIMENSION) 1);
|
||||
dest->cur_output_row = 0;
|
||||
if (cinfo->progress != NULL) {
|
||||
cd_progress_ptr progress = (cd_progress_ptr) cinfo->progress;
|
||||
progress->total_extra_passes++; /* count file input as separate pass */
|
||||
}
|
||||
|
||||
/* Create decompressor output buffer. */
|
||||
dest->pub.buffer = (*cinfo->mem->alloc_sarray)
|
||||
((j_common_ptr) cinfo, JPOOL_IMAGE, row_width, (JDIMENSION) 1);
|
||||
dest->pub.buffer_height = 1;
|
||||
|
||||
return (djpeg_dest_ptr) dest;
|
||||
}
|
||||
|
||||
#endif /* BMP_SUPPORTED */
|
||||
|
|
@ -0,0 +1,399 @@
|
|||
/*
|
||||
* wrgif.c
|
||||
*
|
||||
* Copyright (C) 1991-1997, Thomas G. Lane.
|
||||
* This file is part of the Independent JPEG Group's software.
|
||||
* For conditions of distribution and use, see the accompanying README file.
|
||||
*
|
||||
* This file contains routines to write output images in GIF format.
|
||||
*
|
||||
**************************************************************************
|
||||
* NOTE: to avoid entanglements with Unisys' patent on LZW compression, *
|
||||
* this code has been modified to output "uncompressed GIF" files. *
|
||||
* There is no trace of the LZW algorithm in this file. *
|
||||
**************************************************************************
|
||||
*
|
||||
* These routines may need modification for non-Unix environments or
|
||||
* specialized applications. As they stand, they assume output to
|
||||
* an ordinary stdio stream.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This code is loosely based on ppmtogif from the PBMPLUS distribution
|
||||
* of Feb. 1991. That file contains the following copyright notice:
|
||||
* Based on GIFENCODE by David Rowley <mgardi@watdscu.waterloo.edu>.
|
||||
* Lempel-Ziv compression based on "compress" by Spencer W. Thomas et al.
|
||||
* Copyright (C) 1989 by Jef Poskanzer.
|
||||
* Permission to use, copy, modify, and distribute this software and its
|
||||
* documentation for any purpose and without fee is hereby granted, provided
|
||||
* that the above copyright notice appear in all copies and that both that
|
||||
* copyright notice and this permission notice appear in supporting
|
||||
* documentation. This software is provided "as is" without express or
|
||||
* implied warranty.
|
||||
*
|
||||
* We are also required to state that
|
||||
* "The Graphics Interchange Format(c) is the Copyright property of
|
||||
* CompuServe Incorporated. GIF(sm) is a Service Mark property of
|
||||
* CompuServe Incorporated."
|
||||
*/
|
||||
|
||||
#include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
|
||||
|
||||
#ifdef GIF_SUPPORTED
|
||||
|
||||
|
||||
/* Private version of data destination object */
|
||||
|
||||
typedef struct {
|
||||
struct djpeg_dest_struct pub; /* public fields */
|
||||
|
||||
j_decompress_ptr cinfo; /* back link saves passing separate parm */
|
||||
|
||||
/* State for packing variable-width codes into a bitstream */
|
||||
int n_bits; /* current number of bits/code */
|
||||
int maxcode; /* maximum code, given n_bits */
|
||||
INT32 cur_accum; /* holds bits not yet output */
|
||||
int cur_bits; /* # of bits in cur_accum */
|
||||
|
||||
/* State for GIF code assignment */
|
||||
int ClearCode; /* clear code (doesn't change) */
|
||||
int EOFCode; /* EOF code (ditto) */
|
||||
int code_counter; /* counts output symbols */
|
||||
|
||||
/* GIF data packet construction buffer */
|
||||
int bytesinpkt; /* # of bytes in current packet */
|
||||
char packetbuf[256]; /* workspace for accumulating packet */
|
||||
|
||||
} gif_dest_struct;
|
||||
|
||||
typedef gif_dest_struct * gif_dest_ptr;
|
||||
|
||||
/* Largest value that will fit in N bits */
|
||||
#define MAXCODE(n_bits) ((1 << (n_bits)) - 1)
|
||||
|
||||
|
||||
/*
|
||||
* Routines to package finished data bytes into GIF data blocks.
|
||||
* A data block consists of a count byte (1..255) and that many data bytes.
|
||||
*/
|
||||
|
||||
LOCAL(void)
|
||||
flush_packet (gif_dest_ptr dinfo)
|
||||
/* flush any accumulated data */
|
||||
{
|
||||
if (dinfo->bytesinpkt > 0) { /* never write zero-length packet */
|
||||
dinfo->packetbuf[0] = (char) dinfo->bytesinpkt++;
|
||||
if (JFWRITE(dinfo->pub.output_file, dinfo->packetbuf, dinfo->bytesinpkt)
|
||||
!= (size_t) dinfo->bytesinpkt)
|
||||
ERREXIT(dinfo->cinfo, JERR_FILE_WRITE);
|
||||
dinfo->bytesinpkt = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Add a character to current packet; flush to disk if necessary */
|
||||
#define CHAR_OUT(dinfo,c) \
|
||||
{ (dinfo)->packetbuf[++(dinfo)->bytesinpkt] = (char) (c); \
|
||||
if ((dinfo)->bytesinpkt >= 255) \
|
||||
flush_packet(dinfo); \
|
||||
}
|
||||
|
||||
|
||||
/* Routine to convert variable-width codes into a byte stream */
|
||||
|
||||
LOCAL(void)
|
||||
output (gif_dest_ptr dinfo, int code)
|
||||
/* Emit a code of n_bits bits */
|
||||
/* Uses cur_accum and cur_bits to reblock into 8-bit bytes */
|
||||
{
|
||||
dinfo->cur_accum |= ((INT32) code) << dinfo->cur_bits;
|
||||
dinfo->cur_bits += dinfo->n_bits;
|
||||
|
||||
while (dinfo->cur_bits >= 8) {
|
||||
CHAR_OUT(dinfo, dinfo->cur_accum & 0xFF);
|
||||
dinfo->cur_accum >>= 8;
|
||||
dinfo->cur_bits -= 8;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* The pseudo-compression algorithm.
|
||||
*
|
||||
* In this module we simply output each pixel value as a separate symbol;
|
||||
* thus, no compression occurs. In fact, there is expansion of one bit per
|
||||
* pixel, because we use a symbol width one bit wider than the pixel width.
|
||||
*
|
||||
* GIF ordinarily uses variable-width symbols, and the decoder will expect
|
||||
* to ratchet up the symbol width after a fixed number of symbols.
|
||||
* To simplify the logic and keep the expansion penalty down, we emit a
|
||||
* GIF Clear code to reset the decoder just before the width would ratchet up.
|
||||
* Thus, all the symbols in the output file will have the same bit width.
|
||||
* Note that emitting the Clear codes at the right times is a mere matter of
|
||||
* counting output symbols and is in no way dependent on the LZW patent.
|
||||
*
|
||||
* With a small basic pixel width (low color count), Clear codes will be
|
||||
* needed very frequently, causing the file to expand even more. So this
|
||||
* simplistic approach wouldn't work too well on bilevel images, for example.
|
||||
* But for output of JPEG conversions the pixel width will usually be 8 bits
|
||||
* (129 to 256 colors), so the overhead added by Clear symbols is only about
|
||||
* one symbol in every 256.
|
||||
*/
|
||||
|
||||
LOCAL(void)
|
||||
compress_init (gif_dest_ptr dinfo, int i_bits)
|
||||
/* Initialize pseudo-compressor */
|
||||
{
|
||||
/* init all the state variables */
|
||||
dinfo->n_bits = i_bits;
|
||||
dinfo->maxcode = MAXCODE(dinfo->n_bits);
|
||||
dinfo->ClearCode = (1 << (i_bits - 1));
|
||||
dinfo->EOFCode = dinfo->ClearCode + 1;
|
||||
dinfo->code_counter = dinfo->ClearCode + 2;
|
||||
/* init output buffering vars */
|
||||
dinfo->bytesinpkt = 0;
|
||||
dinfo->cur_accum = 0;
|
||||
dinfo->cur_bits = 0;
|
||||
/* GIF specifies an initial Clear code */
|
||||
output(dinfo, dinfo->ClearCode);
|
||||
}
|
||||
|
||||
|
||||
LOCAL(void)
|
||||
compress_pixel (gif_dest_ptr dinfo, int c)
|
||||
/* Accept and "compress" one pixel value.
|
||||
* The given value must be less than n_bits wide.
|
||||
*/
|
||||
{
|
||||
/* Output the given pixel value as a symbol. */
|
||||
output(dinfo, c);
|
||||
/* Issue Clear codes often enough to keep the reader from ratcheting up
|
||||
* its symbol size.
|
||||
*/
|
||||
if (dinfo->code_counter < dinfo->maxcode) {
|
||||
dinfo->code_counter++;
|
||||
} else {
|
||||
output(dinfo, dinfo->ClearCode);
|
||||
dinfo->code_counter = dinfo->ClearCode + 2; /* reset the counter */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
LOCAL(void)
|
||||
compress_term (gif_dest_ptr dinfo)
|
||||
/* Clean up at end */
|
||||
{
|
||||
/* Send an EOF code */
|
||||
output(dinfo, dinfo->EOFCode);
|
||||
/* Flush the bit-packing buffer */
|
||||
if (dinfo->cur_bits > 0) {
|
||||
CHAR_OUT(dinfo, dinfo->cur_accum & 0xFF);
|
||||
}
|
||||
/* Flush the packet buffer */
|
||||
flush_packet(dinfo);
|
||||
}
|
||||
|
||||
|
||||
/* GIF header construction */
|
||||
|
||||
|
||||
LOCAL(void)
|
||||
put_word (gif_dest_ptr dinfo, unsigned int w)
|
||||
/* Emit a 16-bit word, LSB first */
|
||||
{
|
||||
putc(w & 0xFF, dinfo->pub.output_file);
|
||||
putc((w >> 8) & 0xFF, dinfo->pub.output_file);
|
||||
}
|
||||
|
||||
|
||||
LOCAL(void)
|
||||
put_3bytes (gif_dest_ptr dinfo, int val)
|
||||
/* Emit 3 copies of same byte value --- handy subr for colormap construction */
|
||||
{
|
||||
putc(val, dinfo->pub.output_file);
|
||||
putc(val, dinfo->pub.output_file);
|
||||
putc(val, dinfo->pub.output_file);
|
||||
}
|
||||
|
||||
|
||||
LOCAL(void)
|
||||
emit_header (gif_dest_ptr dinfo, int num_colors, JSAMPARRAY colormap)
|
||||
/* Output the GIF file header, including color map */
|
||||
/* If colormap==NULL, synthesize a gray-scale colormap */
|
||||
{
|
||||
int BitsPerPixel, ColorMapSize, InitCodeSize, FlagByte;
|
||||
int cshift = dinfo->cinfo->data_precision - 8;
|
||||
int i;
|
||||
|
||||
if (num_colors > 256)
|
||||
ERREXIT1(dinfo->cinfo, JERR_TOO_MANY_COLORS, num_colors);
|
||||
/* Compute bits/pixel and related values */
|
||||
BitsPerPixel = 1;
|
||||
while (num_colors > (1 << BitsPerPixel))
|
||||
BitsPerPixel++;
|
||||
ColorMapSize = 1 << BitsPerPixel;
|
||||
if (BitsPerPixel <= 1)
|
||||
InitCodeSize = 2;
|
||||
else
|
||||
InitCodeSize = BitsPerPixel;
|
||||
/*
|
||||
* Write the GIF header.
|
||||
* Note that we generate a plain GIF87 header for maximum compatibility.
|
||||
*/
|
||||
putc('G', dinfo->pub.output_file);
|
||||
putc('I', dinfo->pub.output_file);
|
||||
putc('F', dinfo->pub.output_file);
|
||||
putc('8', dinfo->pub.output_file);
|
||||
putc('7', dinfo->pub.output_file);
|
||||
putc('a', dinfo->pub.output_file);
|
||||
/* Write the Logical Screen Descriptor */
|
||||
put_word(dinfo, (unsigned int) dinfo->cinfo->output_width);
|
||||
put_word(dinfo, (unsigned int) dinfo->cinfo->output_height);
|
||||
FlagByte = 0x80; /* Yes, there is a global color table */
|
||||
FlagByte |= (BitsPerPixel-1) << 4; /* color resolution */
|
||||
FlagByte |= (BitsPerPixel-1); /* size of global color table */
|
||||
putc(FlagByte, dinfo->pub.output_file);
|
||||
putc(0, dinfo->pub.output_file); /* Background color index */
|
||||
putc(0, dinfo->pub.output_file); /* Reserved (aspect ratio in GIF89) */
|
||||
/* Write the Global Color Map */
|
||||
/* If the color map is more than 8 bits precision, */
|
||||
/* we reduce it to 8 bits by shifting */
|
||||
for (i=0; i < ColorMapSize; i++) {
|
||||
if (i < num_colors) {
|
||||
if (colormap != NULL) {
|
||||
if (dinfo->cinfo->out_color_space == JCS_RGB) {
|
||||
/* Normal case: RGB color map */
|
||||
putc(GETJSAMPLE(colormap[0][i]) >> cshift, dinfo->pub.output_file);
|
||||
putc(GETJSAMPLE(colormap[1][i]) >> cshift, dinfo->pub.output_file);
|
||||
putc(GETJSAMPLE(colormap[2][i]) >> cshift, dinfo->pub.output_file);
|
||||
} else {
|
||||
/* Grayscale "color map": possible if quantizing grayscale image */
|
||||
put_3bytes(dinfo, GETJSAMPLE(colormap[0][i]) >> cshift);
|
||||
}
|
||||
} else {
|
||||
/* Create a gray-scale map of num_colors values, range 0..255 */
|
||||
put_3bytes(dinfo, (i * 255 + (num_colors-1)/2) / (num_colors-1));
|
||||
}
|
||||
} else {
|
||||
/* fill out the map to a power of 2 */
|
||||
put_3bytes(dinfo, 0);
|
||||
}
|
||||
}
|
||||
/* Write image separator and Image Descriptor */
|
||||
putc(',', dinfo->pub.output_file); /* separator */
|
||||
put_word(dinfo, 0); /* left/top offset */
|
||||
put_word(dinfo, 0);
|
||||
put_word(dinfo, (unsigned int) dinfo->cinfo->output_width); /* image size */
|
||||
put_word(dinfo, (unsigned int) dinfo->cinfo->output_height);
|
||||
/* flag byte: not interlaced, no local color map */
|
||||
putc(0x00, dinfo->pub.output_file);
|
||||
/* Write Initial Code Size byte */
|
||||
putc(InitCodeSize, dinfo->pub.output_file);
|
||||
|
||||
/* Initialize for "compression" of image data */
|
||||
compress_init(dinfo, InitCodeSize+1);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Startup: write the file header.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
start_output_gif (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
|
||||
{
|
||||
gif_dest_ptr dest = (gif_dest_ptr) dinfo;
|
||||
|
||||
if (cinfo->quantize_colors)
|
||||
emit_header(dest, cinfo->actual_number_of_colors, cinfo->colormap);
|
||||
else
|
||||
emit_header(dest, 256, (JSAMPARRAY) NULL);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Write some pixel data.
|
||||
* In this module rows_supplied will always be 1.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
put_pixel_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
|
||||
JDIMENSION rows_supplied)
|
||||
{
|
||||
gif_dest_ptr dest = (gif_dest_ptr) dinfo;
|
||||
register JSAMPROW ptr;
|
||||
register JDIMENSION col;
|
||||
|
||||
ptr = dest->pub.buffer[0];
|
||||
for (col = cinfo->output_width; col > 0; col--) {
|
||||
compress_pixel(dest, GETJSAMPLE(*ptr++));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Finish up at the end of the file.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
finish_output_gif (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
|
||||
{
|
||||
gif_dest_ptr dest = (gif_dest_ptr) dinfo;
|
||||
|
||||
/* Flush "compression" mechanism */
|
||||
compress_term(dest);
|
||||
/* Write a zero-length data block to end the series */
|
||||
putc(0, dest->pub.output_file);
|
||||
/* Write the GIF terminator mark */
|
||||
putc(';', dest->pub.output_file);
|
||||
/* Make sure we wrote the output file OK */
|
||||
fflush(dest->pub.output_file);
|
||||
if (ferror(dest->pub.output_file))
|
||||
ERREXIT(cinfo, JERR_FILE_WRITE);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* The module selection routine for GIF format output.
|
||||
*/
|
||||
|
||||
GLOBAL(djpeg_dest_ptr)
|
||||
jinit_write_gif (j_decompress_ptr cinfo)
|
||||
{
|
||||
gif_dest_ptr dest;
|
||||
|
||||
/* Create module interface object, fill in method pointers */
|
||||
dest = (gif_dest_ptr)
|
||||
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
|
||||
SIZEOF(gif_dest_struct));
|
||||
dest->cinfo = cinfo; /* make back link for subroutines */
|
||||
dest->pub.start_output = start_output_gif;
|
||||
dest->pub.put_pixel_rows = put_pixel_rows;
|
||||
dest->pub.finish_output = finish_output_gif;
|
||||
|
||||
if (cinfo->out_color_space != JCS_GRAYSCALE &&
|
||||
cinfo->out_color_space != JCS_RGB)
|
||||
ERREXIT(cinfo, JERR_GIF_COLORSPACE);
|
||||
|
||||
/* Force quantization if color or if > 8 bits input */
|
||||
if (cinfo->out_color_space != JCS_GRAYSCALE || cinfo->data_precision > 8) {
|
||||
/* Force quantization to at most 256 colors */
|
||||
cinfo->quantize_colors = TRUE;
|
||||
if (cinfo->desired_number_of_colors > 256)
|
||||
cinfo->desired_number_of_colors = 256;
|
||||
}
|
||||
|
||||
/* Calculate output image dimensions so we can allocate space */
|
||||
jpeg_calc_output_dimensions(cinfo);
|
||||
|
||||
if (cinfo->output_components != 1) /* safety check: just one component? */
|
||||
ERREXIT(cinfo, JERR_GIF_BUG);
|
||||
|
||||
/* Create decompressor output buffer. */
|
||||
dest->pub.buffer = (*cinfo->mem->alloc_sarray)
|
||||
((j_common_ptr) cinfo, JPOOL_IMAGE, cinfo->output_width, (JDIMENSION) 1);
|
||||
dest->pub.buffer_height = 1;
|
||||
|
||||
return (djpeg_dest_ptr) dest;
|
||||
}
|
||||
|
||||
#endif /* GIF_SUPPORTED */
|
||||
|
|
@ -0,0 +1,268 @@
|
|||
/*
|
||||
* wrppm.c
|
||||
*
|
||||
* Copyright (C) 1991-1996, Thomas G. Lane.
|
||||
* This file is part of the Independent JPEG Group's software.
|
||||
* For conditions of distribution and use, see the accompanying README file.
|
||||
*
|
||||
* This file contains routines to write output images in PPM/PGM format.
|
||||
* The extended 2-byte-per-sample raw PPM/PGM formats are supported.
|
||||
* The PBMPLUS library is NOT required to compile this software
|
||||
* (but it is highly useful as a set of PPM image manipulation programs).
|
||||
*
|
||||
* These routines may need modification for non-Unix environments or
|
||||
* specialized applications. As they stand, they assume output to
|
||||
* an ordinary stdio stream.
|
||||
*/
|
||||
|
||||
#include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
|
||||
|
||||
#ifdef PPM_SUPPORTED
|
||||
|
||||
|
||||
/*
|
||||
* For 12-bit JPEG data, we either downscale the values to 8 bits
|
||||
* (to write standard byte-per-sample PPM/PGM files), or output
|
||||
* nonstandard word-per-sample PPM/PGM files. Downscaling is done
|
||||
* if PPM_NORAWWORD is defined (this can be done in the Makefile
|
||||
* or in jconfig.h).
|
||||
* (When the core library supports data precision reduction, a cleaner
|
||||
* implementation will be to ask for that instead.)
|
||||
*/
|
||||
|
||||
#if BITS_IN_JSAMPLE == 8
|
||||
#define PUTPPMSAMPLE(ptr,v) *ptr++ = (char) (v)
|
||||
#define BYTESPERSAMPLE 1
|
||||
#define PPM_MAXVAL 255
|
||||
#else
|
||||
#ifdef PPM_NORAWWORD
|
||||
#define PUTPPMSAMPLE(ptr,v) *ptr++ = (char) ((v) >> (BITS_IN_JSAMPLE-8))
|
||||
#define BYTESPERSAMPLE 1
|
||||
#define PPM_MAXVAL 255
|
||||
#else
|
||||
/* The word-per-sample format always puts the LSB first. */
|
||||
#define PUTPPMSAMPLE(ptr,v) \
|
||||
{ register int val_ = v; \
|
||||
*ptr++ = (char) (val_ & 0xFF); \
|
||||
*ptr++ = (char) ((val_ >> 8) & 0xFF); \
|
||||
}
|
||||
#define BYTESPERSAMPLE 2
|
||||
#define PPM_MAXVAL ((1<<BITS_IN_JSAMPLE)-1)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* When JSAMPLE is the same size as char, we can just fwrite() the
|
||||
* decompressed data to the PPM or PGM file. On PCs, in order to make this
|
||||
* work the output buffer must be allocated in near data space, because we are
|
||||
* assuming small-data memory model wherein fwrite() can't reach far memory.
|
||||
* If you need to process very wide images on a PC, you might have to compile
|
||||
* in large-memory model, or else replace fwrite() with a putc() loop ---
|
||||
* which will be much slower.
|
||||
*/
|
||||
|
||||
|
||||
/* Private version of data destination object */
|
||||
|
||||
typedef struct {
|
||||
struct djpeg_dest_struct pub; /* public fields */
|
||||
|
||||
/* Usually these two pointers point to the same place: */
|
||||
char *iobuffer; /* fwrite's I/O buffer */
|
||||
JSAMPROW pixrow; /* decompressor output buffer */
|
||||
size_t buffer_width; /* width of I/O buffer */
|
||||
JDIMENSION samples_per_row; /* JSAMPLEs per output row */
|
||||
} ppm_dest_struct;
|
||||
|
||||
typedef ppm_dest_struct * ppm_dest_ptr;
|
||||
|
||||
|
||||
/*
|
||||
* Write some pixel data.
|
||||
* In this module rows_supplied will always be 1.
|
||||
*
|
||||
* put_pixel_rows handles the "normal" 8-bit case where the decompressor
|
||||
* output buffer is physically the same as the fwrite buffer.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
put_pixel_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
|
||||
JDIMENSION rows_supplied)
|
||||
{
|
||||
ppm_dest_ptr dest = (ppm_dest_ptr) dinfo;
|
||||
|
||||
(void) JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* This code is used when we have to copy the data and apply a pixel
|
||||
* format translation. Typically this only happens in 12-bit mode.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
copy_pixel_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
|
||||
JDIMENSION rows_supplied)
|
||||
{
|
||||
ppm_dest_ptr dest = (ppm_dest_ptr) dinfo;
|
||||
register char * bufferptr;
|
||||
register JSAMPROW ptr;
|
||||
register JDIMENSION col;
|
||||
|
||||
ptr = dest->pub.buffer[0];
|
||||
bufferptr = dest->iobuffer;
|
||||
for (col = dest->samples_per_row; col > 0; col--) {
|
||||
PUTPPMSAMPLE(bufferptr, GETJSAMPLE(*ptr++));
|
||||
}
|
||||
(void) JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Write some pixel data when color quantization is in effect.
|
||||
* We have to demap the color index values to straight data.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
put_demapped_rgb (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
|
||||
JDIMENSION rows_supplied)
|
||||
{
|
||||
ppm_dest_ptr dest = (ppm_dest_ptr) dinfo;
|
||||
register char * bufferptr;
|
||||
register int pixval;
|
||||
register JSAMPROW ptr;
|
||||
register JSAMPROW color_map0 = cinfo->colormap[0];
|
||||
register JSAMPROW color_map1 = cinfo->colormap[1];
|
||||
register JSAMPROW color_map2 = cinfo->colormap[2];
|
||||
register JDIMENSION col;
|
||||
|
||||
ptr = dest->pub.buffer[0];
|
||||
bufferptr = dest->iobuffer;
|
||||
for (col = cinfo->output_width; col > 0; col--) {
|
||||
pixval = GETJSAMPLE(*ptr++);
|
||||
PUTPPMSAMPLE(bufferptr, GETJSAMPLE(color_map0[pixval]));
|
||||
PUTPPMSAMPLE(bufferptr, GETJSAMPLE(color_map1[pixval]));
|
||||
PUTPPMSAMPLE(bufferptr, GETJSAMPLE(color_map2[pixval]));
|
||||
}
|
||||
(void) JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
|
||||
}
|
||||
|
||||
|
||||
METHODDEF(void)
|
||||
put_demapped_gray (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
|
||||
JDIMENSION rows_supplied)
|
||||
{
|
||||
ppm_dest_ptr dest = (ppm_dest_ptr) dinfo;
|
||||
register char * bufferptr;
|
||||
register JSAMPROW ptr;
|
||||
register JSAMPROW color_map = cinfo->colormap[0];
|
||||
register JDIMENSION col;
|
||||
|
||||
ptr = dest->pub.buffer[0];
|
||||
bufferptr = dest->iobuffer;
|
||||
for (col = cinfo->output_width; col > 0; col--) {
|
||||
PUTPPMSAMPLE(bufferptr, GETJSAMPLE(color_map[GETJSAMPLE(*ptr++)]));
|
||||
}
|
||||
(void) JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Startup: write the file header.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
start_output_ppm (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
|
||||
{
|
||||
ppm_dest_ptr dest = (ppm_dest_ptr) dinfo;
|
||||
|
||||
/* Emit file header */
|
||||
switch (cinfo->out_color_space) {
|
||||
case JCS_GRAYSCALE:
|
||||
/* emit header for raw PGM format */
|
||||
fprintf(dest->pub.output_file, "P5\n%ld %ld\n%d\n",
|
||||
(long) cinfo->output_width, (long) cinfo->output_height,
|
||||
PPM_MAXVAL);
|
||||
break;
|
||||
case JCS_RGB:
|
||||
/* emit header for raw PPM format */
|
||||
fprintf(dest->pub.output_file, "P6\n%ld %ld\n%d\n",
|
||||
(long) cinfo->output_width, (long) cinfo->output_height,
|
||||
PPM_MAXVAL);
|
||||
break;
|
||||
default:
|
||||
ERREXIT(cinfo, JERR_PPM_COLORSPACE);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Finish up at the end of the file.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
finish_output_ppm (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
|
||||
{
|
||||
/* Make sure we wrote the output file OK */
|
||||
fflush(dinfo->output_file);
|
||||
if (ferror(dinfo->output_file))
|
||||
ERREXIT(cinfo, JERR_FILE_WRITE);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* The module selection routine for PPM format output.
|
||||
*/
|
||||
|
||||
GLOBAL(djpeg_dest_ptr)
|
||||
jinit_write_ppm (j_decompress_ptr cinfo)
|
||||
{
|
||||
ppm_dest_ptr dest;
|
||||
|
||||
/* Create module interface object, fill in method pointers */
|
||||
dest = (ppm_dest_ptr)
|
||||
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
|
||||
SIZEOF(ppm_dest_struct));
|
||||
dest->pub.start_output = start_output_ppm;
|
||||
dest->pub.finish_output = finish_output_ppm;
|
||||
|
||||
/* Calculate output image dimensions so we can allocate space */
|
||||
jpeg_calc_output_dimensions(cinfo);
|
||||
|
||||
/* Create physical I/O buffer. Note we make this near on a PC. */
|
||||
dest->samples_per_row = cinfo->output_width * cinfo->out_color_components;
|
||||
dest->buffer_width = dest->samples_per_row * (BYTESPERSAMPLE * SIZEOF(char));
|
||||
dest->iobuffer = (char *) (*cinfo->mem->alloc_small)
|
||||
((j_common_ptr) cinfo, JPOOL_IMAGE, dest->buffer_width);
|
||||
|
||||
if (cinfo->quantize_colors || BITS_IN_JSAMPLE != 8 ||
|
||||
SIZEOF(JSAMPLE) != SIZEOF(char)) {
|
||||
/* When quantizing, we need an output buffer for colormap indexes
|
||||
* that's separate from the physical I/O buffer. We also need a
|
||||
* separate buffer if pixel format translation must take place.
|
||||
*/
|
||||
dest->pub.buffer = (*cinfo->mem->alloc_sarray)
|
||||
((j_common_ptr) cinfo, JPOOL_IMAGE,
|
||||
cinfo->output_width * cinfo->output_components, (JDIMENSION) 1);
|
||||
dest->pub.buffer_height = 1;
|
||||
if (! cinfo->quantize_colors)
|
||||
dest->pub.put_pixel_rows = copy_pixel_rows;
|
||||
else if (cinfo->out_color_space == JCS_GRAYSCALE)
|
||||
dest->pub.put_pixel_rows = put_demapped_gray;
|
||||
else
|
||||
dest->pub.put_pixel_rows = put_demapped_rgb;
|
||||
} else {
|
||||
/* We will fwrite() directly from decompressor output buffer. */
|
||||
/* Synthesize a JSAMPARRAY pointer structure */
|
||||
/* Cast here implies near->far pointer conversion on PCs */
|
||||
dest->pixrow = (JSAMPROW) dest->iobuffer;
|
||||
dest->pub.buffer = & dest->pixrow;
|
||||
dest->pub.buffer_height = 1;
|
||||
dest->pub.put_pixel_rows = put_pixel_rows;
|
||||
}
|
||||
|
||||
return (djpeg_dest_ptr) dest;
|
||||
}
|
||||
|
||||
#endif /* PPM_SUPPORTED */
|
||||
|
|
@ -0,0 +1,253 @@
|
|||
/*
|
||||
* wrtarga.c
|
||||
*
|
||||
* Copyright (C) 1991-1996, Thomas G. Lane.
|
||||
* This file is part of the Independent JPEG Group's software.
|
||||
* For conditions of distribution and use, see the accompanying README file.
|
||||
*
|
||||
* This file contains routines to write output images in Targa format.
|
||||
*
|
||||
* These routines may need modification for non-Unix environments or
|
||||
* specialized applications. As they stand, they assume output to
|
||||
* an ordinary stdio stream.
|
||||
*
|
||||
* Based on code contributed by Lee Daniel Crocker.
|
||||
*/
|
||||
|
||||
#include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
|
||||
|
||||
#ifdef TARGA_SUPPORTED
|
||||
|
||||
|
||||
/*
|
||||
* To support 12-bit JPEG data, we'd have to scale output down to 8 bits.
|
||||
* This is not yet implemented.
|
||||
*/
|
||||
|
||||
#if BITS_IN_JSAMPLE != 8
|
||||
Sorry, this code only copes with 8-bit JSAMPLEs. /* deliberate syntax err */
|
||||
#endif
|
||||
|
||||
/*
|
||||
* The output buffer needs to be writable by fwrite(). On PCs, we must
|
||||
* allocate the buffer in near data space, because we are assuming small-data
|
||||
* memory model, wherein fwrite() can't reach far memory. If you need to
|
||||
* process very wide images on a PC, you might have to compile in large-memory
|
||||
* model, or else replace fwrite() with a putc() loop --- which will be much
|
||||
* slower.
|
||||
*/
|
||||
|
||||
|
||||
/* Private version of data destination object */
|
||||
|
||||
typedef struct {
|
||||
struct djpeg_dest_struct pub; /* public fields */
|
||||
|
||||
char *iobuffer; /* physical I/O buffer */
|
||||
JDIMENSION buffer_width; /* width of one row */
|
||||
} tga_dest_struct;
|
||||
|
||||
typedef tga_dest_struct * tga_dest_ptr;
|
||||
|
||||
|
||||
LOCAL(void)
|
||||
write_header (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo, int num_colors)
|
||||
/* Create and write a Targa header */
|
||||
{
|
||||
char targaheader[18];
|
||||
|
||||
/* Set unused fields of header to 0 */
|
||||
MEMZERO(targaheader, SIZEOF(targaheader));
|
||||
|
||||
if (num_colors > 0) {
|
||||
targaheader[1] = 1; /* color map type 1 */
|
||||
targaheader[5] = (char) (num_colors & 0xFF);
|
||||
targaheader[6] = (char) (num_colors >> 8);
|
||||
targaheader[7] = 24; /* 24 bits per cmap entry */
|
||||
}
|
||||
|
||||
targaheader[12] = (char) (cinfo->output_width & 0xFF);
|
||||
targaheader[13] = (char) (cinfo->output_width >> 8);
|
||||
targaheader[14] = (char) (cinfo->output_height & 0xFF);
|
||||
targaheader[15] = (char) (cinfo->output_height >> 8);
|
||||
targaheader[17] = 0x20; /* Top-down, non-interlaced */
|
||||
|
||||
if (cinfo->out_color_space == JCS_GRAYSCALE) {
|
||||
targaheader[2] = 3; /* image type = uncompressed gray-scale */
|
||||
targaheader[16] = 8; /* bits per pixel */
|
||||
} else { /* must be RGB */
|
||||
if (num_colors > 0) {
|
||||
targaheader[2] = 1; /* image type = colormapped RGB */
|
||||
targaheader[16] = 8;
|
||||
} else {
|
||||
targaheader[2] = 2; /* image type = uncompressed RGB */
|
||||
targaheader[16] = 24;
|
||||
}
|
||||
}
|
||||
|
||||
if (JFWRITE(dinfo->output_file, targaheader, 18) != (size_t) 18)
|
||||
ERREXIT(cinfo, JERR_FILE_WRITE);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Write some pixel data.
|
||||
* In this module rows_supplied will always be 1.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
put_pixel_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
|
||||
JDIMENSION rows_supplied)
|
||||
/* used for unquantized full-color output */
|
||||
{
|
||||
tga_dest_ptr dest = (tga_dest_ptr) dinfo;
|
||||
register JSAMPROW inptr;
|
||||
register char * outptr;
|
||||
register JDIMENSION col;
|
||||
|
||||
inptr = dest->pub.buffer[0];
|
||||
outptr = dest->iobuffer;
|
||||
for (col = cinfo->output_width; col > 0; col--) {
|
||||
outptr[0] = (char) GETJSAMPLE(inptr[2]); /* RGB to BGR order */
|
||||
outptr[1] = (char) GETJSAMPLE(inptr[1]);
|
||||
outptr[2] = (char) GETJSAMPLE(inptr[0]);
|
||||
inptr += 3, outptr += 3;
|
||||
}
|
||||
(void) JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
|
||||
}
|
||||
|
||||
METHODDEF(void)
|
||||
put_gray_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
|
||||
JDIMENSION rows_supplied)
|
||||
/* used for grayscale OR quantized color output */
|
||||
{
|
||||
tga_dest_ptr dest = (tga_dest_ptr) dinfo;
|
||||
register JSAMPROW inptr;
|
||||
register char * outptr;
|
||||
register JDIMENSION col;
|
||||
|
||||
inptr = dest->pub.buffer[0];
|
||||
outptr = dest->iobuffer;
|
||||
for (col = cinfo->output_width; col > 0; col--) {
|
||||
*outptr++ = (char) GETJSAMPLE(*inptr++);
|
||||
}
|
||||
(void) JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Write some demapped pixel data when color quantization is in effect.
|
||||
* For Targa, this is only applied to grayscale data.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
put_demapped_gray (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
|
||||
JDIMENSION rows_supplied)
|
||||
{
|
||||
tga_dest_ptr dest = (tga_dest_ptr) dinfo;
|
||||
register JSAMPROW inptr;
|
||||
register char * outptr;
|
||||
register JSAMPROW color_map0 = cinfo->colormap[0];
|
||||
register JDIMENSION col;
|
||||
|
||||
inptr = dest->pub.buffer[0];
|
||||
outptr = dest->iobuffer;
|
||||
for (col = cinfo->output_width; col > 0; col--) {
|
||||
*outptr++ = (char) GETJSAMPLE(color_map0[GETJSAMPLE(*inptr++)]);
|
||||
}
|
||||
(void) JFWRITE(dest->pub.output_file, dest->iobuffer, dest->buffer_width);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Startup: write the file header.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
start_output_tga (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
|
||||
{
|
||||
tga_dest_ptr dest = (tga_dest_ptr) dinfo;
|
||||
int num_colors, i;
|
||||
FILE *outfile;
|
||||
|
||||
if (cinfo->out_color_space == JCS_GRAYSCALE) {
|
||||
/* Targa doesn't have a mapped grayscale format, so we will */
|
||||
/* demap quantized gray output. Never emit a colormap. */
|
||||
write_header(cinfo, dinfo, 0);
|
||||
if (cinfo->quantize_colors)
|
||||
dest->pub.put_pixel_rows = put_demapped_gray;
|
||||
else
|
||||
dest->pub.put_pixel_rows = put_gray_rows;
|
||||
} else if (cinfo->out_color_space == JCS_RGB) {
|
||||
if (cinfo->quantize_colors) {
|
||||
/* We only support 8-bit colormap indexes, so only 256 colors */
|
||||
num_colors = cinfo->actual_number_of_colors;
|
||||
if (num_colors > 256)
|
||||
ERREXIT1(cinfo, JERR_TOO_MANY_COLORS, num_colors);
|
||||
write_header(cinfo, dinfo, num_colors);
|
||||
/* Write the colormap. Note Targa uses BGR byte order */
|
||||
outfile = dest->pub.output_file;
|
||||
for (i = 0; i < num_colors; i++) {
|
||||
putc(GETJSAMPLE(cinfo->colormap[2][i]), outfile);
|
||||
putc(GETJSAMPLE(cinfo->colormap[1][i]), outfile);
|
||||
putc(GETJSAMPLE(cinfo->colormap[0][i]), outfile);
|
||||
}
|
||||
dest->pub.put_pixel_rows = put_gray_rows;
|
||||
} else {
|
||||
write_header(cinfo, dinfo, 0);
|
||||
dest->pub.put_pixel_rows = put_pixel_rows;
|
||||
}
|
||||
} else {
|
||||
ERREXIT(cinfo, JERR_TGA_COLORSPACE);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Finish up at the end of the file.
|
||||
*/
|
||||
|
||||
METHODDEF(void)
|
||||
finish_output_tga (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo)
|
||||
{
|
||||
/* Make sure we wrote the output file OK */
|
||||
fflush(dinfo->output_file);
|
||||
if (ferror(dinfo->output_file))
|
||||
ERREXIT(cinfo, JERR_FILE_WRITE);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* The module selection routine for Targa format output.
|
||||
*/
|
||||
|
||||
GLOBAL(djpeg_dest_ptr)
|
||||
jinit_write_targa (j_decompress_ptr cinfo)
|
||||
{
|
||||
tga_dest_ptr dest;
|
||||
|
||||
/* Create module interface object, fill in method pointers */
|
||||
dest = (tga_dest_ptr)
|
||||
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
|
||||
SIZEOF(tga_dest_struct));
|
||||
dest->pub.start_output = start_output_tga;
|
||||
dest->pub.finish_output = finish_output_tga;
|
||||
|
||||
/* Calculate output image dimensions so we can allocate space */
|
||||
jpeg_calc_output_dimensions(cinfo);
|
||||
|
||||
/* Create I/O buffer. Note we make this near on a PC. */
|
||||
dest->buffer_width = cinfo->output_width * cinfo->output_components;
|
||||
dest->iobuffer = (char *)
|
||||
(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
|
||||
(size_t) (dest->buffer_width * SIZEOF(char)));
|
||||
|
||||
/* Create decompressor output buffer. */
|
||||
dest->pub.buffer = (*cinfo->mem->alloc_sarray)
|
||||
((j_common_ptr) cinfo, JPOOL_IMAGE, dest->buffer_width, (JDIMENSION) 1);
|
||||
dest->pub.buffer_height = 1;
|
||||
|
||||
return (djpeg_dest_ptr) dest;
|
||||
}
|
||||
|
||||
#endif /* TARGA_SUPPORTED */
|
||||
Загрузка…
Ссылка в новой задаче