From 13309ca36f9238e3209a1bf8fbe696d6c3a74373 Mon Sep 17 00:00:00 2001 From: Lock l00p Date: Fri, 29 Sep 2023 18:10:15 +0000 Subject: [PATCH] Add libjpeg v6b and define LINK_TO_LIBJPEG macro --- .../emscripten/jpeg/include/jconfig.h | 45 + .../emscripten/jpeg/include/jerror.h | 291 +++++ .../emscripten/jpeg/include/jmorecfg.h | 363 ++++++ .../emscripten/jpeg/include/jpeglib.h | 1096 +++++++++++++++++ misc/builddeps/emscripten/jpeg/libjpeg.a | Bin 0 -> 177686 bytes misc/tools/all/xonotic.subr | 2 +- 6 files changed, 1796 insertions(+), 1 deletion(-) create mode 100644 misc/builddeps/emscripten/jpeg/include/jconfig.h create mode 100644 misc/builddeps/emscripten/jpeg/include/jerror.h create mode 100644 misc/builddeps/emscripten/jpeg/include/jmorecfg.h create mode 100644 misc/builddeps/emscripten/jpeg/include/jpeglib.h create mode 100644 misc/builddeps/emscripten/jpeg/libjpeg.a diff --git a/misc/builddeps/emscripten/jpeg/include/jconfig.h b/misc/builddeps/emscripten/jpeg/include/jconfig.h new file mode 100644 index 00000000..ea89be4b --- /dev/null +++ b/misc/builddeps/emscripten/jpeg/include/jconfig.h @@ -0,0 +1,45 @@ +/* jconfig.h. Generated automatically by configure. */ +/* jconfig.cfg --- source file edited by configure script */ +/* see jconfig.doc for explanations */ + +#define HAVE_PROTOTYPES +#define HAVE_UNSIGNED_CHAR +#define HAVE_UNSIGNED_SHORT +#undef void +#undef const +#undef CHAR_IS_UNSIGNED +#define HAVE_STDDEF_H +#define HAVE_STDLIB_H +#undef NEED_BSD_STRINGS +#undef NEED_SYS_TYPES_H +#undef NEED_FAR_POINTERS +#undef NEED_SHORT_EXTERNAL_NAMES +/* Define this if you get warnings about undefined structures. */ +#undef INCOMPLETE_TYPES_BROKEN + +#ifdef JPEG_INTERNALS + +#undef RIGHT_SHIFT_IS_UNSIGNED +#define INLINE __inline__ +/* These are for configuring the JPEG memory manager. */ +#undef DEFAULT_MAX_MEM +#undef NO_MKTEMP + +#endif /* JPEG_INTERNALS */ + +#ifdef JPEG_CJPEG_DJPEG + +#define BMP_SUPPORTED /* BMP image file format */ +#define GIF_SUPPORTED /* GIF image file format */ +#define PPM_SUPPORTED /* PBMPLUS PPM/PGM image file format */ +#undef RLE_SUPPORTED /* Utah RLE image file format */ +#define TARGA_SUPPORTED /* Targa image file format */ + +#undef TWO_FILE_COMMANDLINE +#undef NEED_SIGNAL_CATCHER +#define DONT_USE_B_MODE + +/* Define this if you want percent-done progress reports from cjpeg/djpeg. */ +#undef PROGRESS_REPORT + +#endif /* JPEG_CJPEG_DJPEG */ diff --git a/misc/builddeps/emscripten/jpeg/include/jerror.h b/misc/builddeps/emscripten/jpeg/include/jerror.h new file mode 100644 index 00000000..fc2fffea --- /dev/null +++ b/misc/builddeps/emscripten/jpeg/include/jerror.h @@ -0,0 +1,291 @@ +/* + * jerror.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 JPEG library. + * Edit this file to add new codes, or to translate the message strings to + * some other language. + * A set of error-reporting macros are defined too. Some applications using + * the JPEG library may wish to include this file to get the error codes + * and/or the macros. + */ + +/* + * 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 JERROR_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 /* JERROR_H */ +#endif /* JMESSAGE */ + +#ifdef JMAKE_ENUM_LIST + +typedef enum { + +#define JMESSAGE(code,string) code , + +#endif /* JMAKE_ENUM_LIST */ + +JMESSAGE(JMSG_NOMESSAGE, "Bogus message code %d") /* Must be first entry! */ + +/* For maintenance convenience, list is alphabetical by message code name */ +JMESSAGE(JERR_ARITH_NOTIMPL, + "Sorry, there are legal restrictions on arithmetic coding") +JMESSAGE(JERR_BAD_ALIGN_TYPE, "ALIGN_TYPE is wrong, please fix") +JMESSAGE(JERR_BAD_ALLOC_CHUNK, "MAX_ALLOC_CHUNK is wrong, please fix") +JMESSAGE(JERR_BAD_BUFFER_MODE, "Bogus buffer control mode") +JMESSAGE(JERR_BAD_COMPONENT_ID, "Invalid component ID %d in SOS") +JMESSAGE(JERR_BAD_DCT_COEF, "DCT coefficient out of range") +JMESSAGE(JERR_BAD_DCTSIZE, "IDCT output block size %d not supported") +JMESSAGE(JERR_BAD_HUFF_TABLE, "Bogus Huffman table definition") +JMESSAGE(JERR_BAD_IN_COLORSPACE, "Bogus input colorspace") +JMESSAGE(JERR_BAD_J_COLORSPACE, "Bogus JPEG colorspace") +JMESSAGE(JERR_BAD_LENGTH, "Bogus marker length") +JMESSAGE(JERR_BAD_LIB_VERSION, + "Wrong JPEG library version: library is %d, caller expects %d") +JMESSAGE(JERR_BAD_MCU_SIZE, "Sampling factors too large for interleaved scan") +JMESSAGE(JERR_BAD_POOL_ID, "Invalid memory pool code %d") +JMESSAGE(JERR_BAD_PRECISION, "Unsupported JPEG data precision %d") +JMESSAGE(JERR_BAD_PROGRESSION, + "Invalid progressive parameters Ss=%d Se=%d Ah=%d Al=%d") +JMESSAGE(JERR_BAD_PROG_SCRIPT, + "Invalid progressive parameters at scan script entry %d") +JMESSAGE(JERR_BAD_SAMPLING, "Bogus sampling factors") +JMESSAGE(JERR_BAD_SCAN_SCRIPT, "Invalid scan script at entry %d") +JMESSAGE(JERR_BAD_STATE, "Improper call to JPEG library in state %d") +JMESSAGE(JERR_BAD_STRUCT_SIZE, + "JPEG parameter struct mismatch: library thinks size is %u, caller expects %u") +JMESSAGE(JERR_BAD_VIRTUAL_ACCESS, "Bogus virtual array access") +JMESSAGE(JERR_BUFFER_SIZE, "Buffer passed to JPEG library is too small") +JMESSAGE(JERR_CANT_SUSPEND, "Suspension not allowed here") +JMESSAGE(JERR_CCIR601_NOTIMPL, "CCIR601 sampling not implemented yet") +JMESSAGE(JERR_COMPONENT_COUNT, "Too many color components: %d, max %d") +JMESSAGE(JERR_CONVERSION_NOTIMPL, "Unsupported color conversion request") +JMESSAGE(JERR_DAC_INDEX, "Bogus DAC index %d") +JMESSAGE(JERR_DAC_VALUE, "Bogus DAC value 0x%x") +JMESSAGE(JERR_DHT_INDEX, "Bogus DHT index %d") +JMESSAGE(JERR_DQT_INDEX, "Bogus DQT index %d") +JMESSAGE(JERR_EMPTY_IMAGE, "Empty JPEG image (DNL not supported)") +JMESSAGE(JERR_EMS_READ, "Read from EMS failed") +JMESSAGE(JERR_EMS_WRITE, "Write to EMS failed") +JMESSAGE(JERR_EOI_EXPECTED, "Didn't expect more than one scan") +JMESSAGE(JERR_FILE_READ, "Input file read error") +JMESSAGE(JERR_FILE_WRITE, "Output file write error --- out of disk space?") +JMESSAGE(JERR_FRACT_SAMPLE_NOTIMPL, "Fractional sampling not implemented yet") +JMESSAGE(JERR_HUFF_CLEN_OVERFLOW, "Huffman code size table overflow") +JMESSAGE(JERR_HUFF_MISSING_CODE, "Missing Huffman code table entry") +JMESSAGE(JERR_IMAGE_TOO_BIG, "Maximum supported image dimension is %u pixels") +JMESSAGE(JERR_INPUT_EMPTY, "Empty input file") +JMESSAGE(JERR_INPUT_EOF, "Premature end of input file") +JMESSAGE(JERR_MISMATCHED_QUANT_TABLE, + "Cannot transcode due to multiple use of quantization table %d") +JMESSAGE(JERR_MISSING_DATA, "Scan script does not transmit all data") +JMESSAGE(JERR_MODE_CHANGE, "Invalid color quantization mode change") +JMESSAGE(JERR_NOTIMPL, "Not implemented yet") +JMESSAGE(JERR_NOT_COMPILED, "Requested feature was omitted at compile time") +JMESSAGE(JERR_NO_BACKING_STORE, "Backing store not supported") +JMESSAGE(JERR_NO_HUFF_TABLE, "Huffman table 0x%02x was not defined") +JMESSAGE(JERR_NO_IMAGE, "JPEG datastream contains no image") +JMESSAGE(JERR_NO_QUANT_TABLE, "Quantization table 0x%02x was not defined") +JMESSAGE(JERR_NO_SOI, "Not a JPEG file: starts with 0x%02x 0x%02x") +JMESSAGE(JERR_OUT_OF_MEMORY, "Insufficient memory (case %d)") +JMESSAGE(JERR_QUANT_COMPONENTS, + "Cannot quantize more than %d color components") +JMESSAGE(JERR_QUANT_FEW_COLORS, "Cannot quantize to fewer than %d colors") +JMESSAGE(JERR_QUANT_MANY_COLORS, "Cannot quantize to more than %d colors") +JMESSAGE(JERR_SOF_DUPLICATE, "Invalid JPEG file structure: two SOF markers") +JMESSAGE(JERR_SOF_NO_SOS, "Invalid JPEG file structure: missing SOS marker") +JMESSAGE(JERR_SOF_UNSUPPORTED, "Unsupported JPEG process: SOF type 0x%02x") +JMESSAGE(JERR_SOI_DUPLICATE, "Invalid JPEG file structure: two SOI markers") +JMESSAGE(JERR_SOS_NO_SOF, "Invalid JPEG file structure: SOS before SOF") +JMESSAGE(JERR_TFILE_CREATE, "Failed to create temporary file %s") +JMESSAGE(JERR_TFILE_READ, "Read failed on temporary file") +JMESSAGE(JERR_TFILE_SEEK, "Seek failed on temporary file") +JMESSAGE(JERR_TFILE_WRITE, + "Write failed on temporary file --- out of disk space?") +JMESSAGE(JERR_TOO_LITTLE_DATA, "Application transferred too few scanlines") +JMESSAGE(JERR_UNKNOWN_MARKER, "Unsupported marker type 0x%02x") +JMESSAGE(JERR_VIRTUAL_BUG, "Virtual array controller messed up") +JMESSAGE(JERR_WIDTH_OVERFLOW, "Image too wide for this implementation") +JMESSAGE(JERR_XMS_READ, "Read from XMS failed") +JMESSAGE(JERR_XMS_WRITE, "Write to XMS failed") +JMESSAGE(JMSG_COPYRIGHT, JCOPYRIGHT) +JMESSAGE(JMSG_VERSION, JVERSION) +JMESSAGE(JTRC_16BIT_TABLES, + "Caution: quantization tables are too coarse for baseline JPEG") +JMESSAGE(JTRC_ADOBE, + "Adobe APP14 marker: version %d, flags 0x%04x 0x%04x, transform %d") +JMESSAGE(JTRC_APP0, "Unknown APP0 marker (not JFIF), length %u") +JMESSAGE(JTRC_APP14, "Unknown APP14 marker (not Adobe), length %u") +JMESSAGE(JTRC_DAC, "Define Arithmetic Table 0x%02x: 0x%02x") +JMESSAGE(JTRC_DHT, "Define Huffman Table 0x%02x") +JMESSAGE(JTRC_DQT, "Define Quantization Table %d precision %d") +JMESSAGE(JTRC_DRI, "Define Restart Interval %u") +JMESSAGE(JTRC_EMS_CLOSE, "Freed EMS handle %u") +JMESSAGE(JTRC_EMS_OPEN, "Obtained EMS handle %u") +JMESSAGE(JTRC_EOI, "End Of Image") +JMESSAGE(JTRC_HUFFBITS, " %3d %3d %3d %3d %3d %3d %3d %3d") +JMESSAGE(JTRC_JFIF, "JFIF APP0 marker: version %d.%02d, density %dx%d %d") +JMESSAGE(JTRC_JFIF_BADTHUMBNAILSIZE, + "Warning: thumbnail image size does not match data length %u") +JMESSAGE(JTRC_JFIF_EXTENSION, + "JFIF extension marker: type 0x%02x, length %u") +JMESSAGE(JTRC_JFIF_THUMBNAIL, " with %d x %d thumbnail image") +JMESSAGE(JTRC_MISC_MARKER, "Miscellaneous marker 0x%02x, length %u") +JMESSAGE(JTRC_PARMLESS_MARKER, "Unexpected marker 0x%02x") +JMESSAGE(JTRC_QUANTVALS, " %4u %4u %4u %4u %4u %4u %4u %4u") +JMESSAGE(JTRC_QUANT_3_NCOLORS, "Quantizing to %d = %d*%d*%d colors") +JMESSAGE(JTRC_QUANT_NCOLORS, "Quantizing to %d colors") +JMESSAGE(JTRC_QUANT_SELECTED, "Selected %d colors for quantization") +JMESSAGE(JTRC_RECOVERY_ACTION, "At marker 0x%02x, recovery action %d") +JMESSAGE(JTRC_RST, "RST%d") +JMESSAGE(JTRC_SMOOTH_NOTIMPL, + "Smoothing not supported with nonstandard sampling ratios") +JMESSAGE(JTRC_SOF, "Start Of Frame 0x%02x: width=%u, height=%u, components=%d") +JMESSAGE(JTRC_SOF_COMPONENT, " Component %d: %dhx%dv q=%d") +JMESSAGE(JTRC_SOI, "Start of Image") +JMESSAGE(JTRC_SOS, "Start Of Scan: %d components") +JMESSAGE(JTRC_SOS_COMPONENT, " Component %d: dc=%d ac=%d") +JMESSAGE(JTRC_SOS_PARAMS, " Ss=%d, Se=%d, Ah=%d, Al=%d") +JMESSAGE(JTRC_TFILE_CLOSE, "Closed temporary file %s") +JMESSAGE(JTRC_TFILE_OPEN, "Opened temporary file %s") +JMESSAGE(JTRC_THUMB_JPEG, + "JFIF extension marker: JPEG-compressed thumbnail image, length %u") +JMESSAGE(JTRC_THUMB_PALETTE, + "JFIF extension marker: palette thumbnail image, length %u") +JMESSAGE(JTRC_THUMB_RGB, + "JFIF extension marker: RGB thumbnail image, length %u") +JMESSAGE(JTRC_UNKNOWN_IDS, + "Unrecognized component IDs %d %d %d, assuming YCbCr") +JMESSAGE(JTRC_XMS_CLOSE, "Freed XMS handle %u") +JMESSAGE(JTRC_XMS_OPEN, "Obtained XMS handle %u") +JMESSAGE(JWRN_ADOBE_XFORM, "Unknown Adobe color transform code %d") +JMESSAGE(JWRN_BOGUS_PROGRESSION, + "Inconsistent progression sequence for component %d coefficient %d") +JMESSAGE(JWRN_EXTRANEOUS_DATA, + "Corrupt JPEG data: %u extraneous bytes before marker 0x%02x") +JMESSAGE(JWRN_HIT_MARKER, "Corrupt JPEG data: premature end of data segment") +JMESSAGE(JWRN_HUFF_BAD_CODE, "Corrupt JPEG data: bad Huffman code") +JMESSAGE(JWRN_JFIF_MAJOR, "Warning: unknown JFIF revision number %d.%02d") +JMESSAGE(JWRN_JPEG_EOF, "Premature end of JPEG file") +JMESSAGE(JWRN_MUST_RESYNC, + "Corrupt JPEG data: found marker 0x%02x instead of RST%d") +JMESSAGE(JWRN_NOT_SEQUENTIAL, "Invalid SOS parameters for sequential JPEG") +JMESSAGE(JWRN_TOO_MUCH_DATA, "Application transferred too many scanlines") + +#ifdef JMAKE_ENUM_LIST + + JMSG_LASTMSGCODE +} J_MESSAGE_CODE; + +#undef JMAKE_ENUM_LIST +#endif /* JMAKE_ENUM_LIST */ + +/* Zap JMESSAGE macro so that future re-inclusions do nothing by default */ +#undef JMESSAGE + + +#ifndef JERROR_H +#define JERROR_H + +/* Macros to simplify using the error and trace message stuff */ +/* The first parameter is either type of cinfo pointer */ + +/* Fatal errors (print message and exit) */ +#define ERREXIT(cinfo,code) \ + ((cinfo)->err->msg_code = (code), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXIT1(cinfo,code,p1) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXIT2(cinfo,code,p1,p2) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXIT3(cinfo,code,p1,p2,p3) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (cinfo)->err->msg_parm.i[2] = (p3), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXIT4(cinfo,code,p1,p2,p3,p4) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (cinfo)->err->msg_parm.i[2] = (p3), \ + (cinfo)->err->msg_parm.i[3] = (p4), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) +#define ERREXITS(cinfo,code,str) \ + ((cinfo)->err->msg_code = (code), \ + strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \ + (*(cinfo)->err->error_exit) ((j_common_ptr) (cinfo))) + +#define MAKESTMT(stuff) do { stuff } while (0) + +/* Nonfatal errors (we can keep going, but the data is probably corrupt) */ +#define WARNMS(cinfo,code) \ + ((cinfo)->err->msg_code = (code), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1)) +#define WARNMS1(cinfo,code,p1) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1)) +#define WARNMS2(cinfo,code,p1,p2) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), -1)) + +/* Informational/debugging messages */ +#define TRACEMS(cinfo,lvl,code) \ + ((cinfo)->err->msg_code = (code), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) +#define TRACEMS1(cinfo,lvl,code,p1) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) +#define TRACEMS2(cinfo,lvl,code,p1,p2) \ + ((cinfo)->err->msg_code = (code), \ + (cinfo)->err->msg_parm.i[0] = (p1), \ + (cinfo)->err->msg_parm.i[1] = (p2), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) +#define TRACEMS3(cinfo,lvl,code,p1,p2,p3) \ + MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ + _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); \ + (cinfo)->err->msg_code = (code); \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) +#define TRACEMS4(cinfo,lvl,code,p1,p2,p3,p4) \ + MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ + _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \ + (cinfo)->err->msg_code = (code); \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) +#define TRACEMS5(cinfo,lvl,code,p1,p2,p3,p4,p5) \ + MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ + _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \ + _mp[4] = (p5); \ + (cinfo)->err->msg_code = (code); \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) +#define TRACEMS8(cinfo,lvl,code,p1,p2,p3,p4,p5,p6,p7,p8) \ + MAKESTMT(int * _mp = (cinfo)->err->msg_parm.i; \ + _mp[0] = (p1); _mp[1] = (p2); _mp[2] = (p3); _mp[3] = (p4); \ + _mp[4] = (p5); _mp[5] = (p6); _mp[6] = (p7); _mp[7] = (p8); \ + (cinfo)->err->msg_code = (code); \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl)); ) +#define TRACEMSS(cinfo,lvl,code,str) \ + ((cinfo)->err->msg_code = (code), \ + strncpy((cinfo)->err->msg_parm.s, (str), JMSG_STR_PARM_MAX), \ + (*(cinfo)->err->emit_message) ((j_common_ptr) (cinfo), (lvl))) + +#endif /* JERROR_H */ diff --git a/misc/builddeps/emscripten/jpeg/include/jmorecfg.h b/misc/builddeps/emscripten/jpeg/include/jmorecfg.h new file mode 100644 index 00000000..54a7d1c4 --- /dev/null +++ b/misc/builddeps/emscripten/jpeg/include/jmorecfg.h @@ -0,0 +1,363 @@ +/* + * jmorecfg.h + * + * 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 additional configuration options that customize the + * JPEG software for special applications or support machine-dependent + * optimizations. Most users will not need to touch this file. + */ + + +/* + * Define BITS_IN_JSAMPLE as either + * 8 for 8-bit sample values (the usual setting) + * 12 for 12-bit sample values + * Only 8 and 12 are legal data precisions for lossy JPEG according to the + * JPEG standard, and the IJG code does not support anything else! + * We do not support run-time selection of data precision, sorry. + */ + +#define BITS_IN_JSAMPLE 8 /* use 8 or 12 */ + + +/* + * Maximum number of components (color channels) allowed in JPEG image. + * To meet the letter of the JPEG spec, set this to 255. However, darn + * few applications need more than 4 channels (maybe 5 for CMYK + alpha + * mask). We recommend 10 as a reasonable compromise; use 4 if you are + * really short on memory. (Each allowed component costs a hundred or so + * bytes of storage, whether actually used in an image or not.) + */ + +#define MAX_COMPONENTS 10 /* maximum number of image components */ + + +/* + * Basic data types. + * You may need to change these if you have a machine with unusual data + * type sizes; for example, "char" not 8 bits, "short" not 16 bits, + * or "long" not 32 bits. We don't care whether "int" is 16 or 32 bits, + * but it had better be at least 16. + */ + +/* Representation of a single sample (pixel element value). + * We frequently allocate large arrays of these, so it's important to keep + * them small. But if you have memory to burn and access to char or short + * arrays is very slow on your hardware, you might want to change these. + */ + +#if BITS_IN_JSAMPLE == 8 +/* JSAMPLE should be the smallest type that will hold the values 0..255. + * You can use a signed char by having GETJSAMPLE mask it with 0xFF. + */ + +#ifdef HAVE_UNSIGNED_CHAR + +typedef unsigned char JSAMPLE; +#define GETJSAMPLE(value) ((int) (value)) + +#else /* not HAVE_UNSIGNED_CHAR */ + +typedef char JSAMPLE; +#ifdef CHAR_IS_UNSIGNED +#define GETJSAMPLE(value) ((int) (value)) +#else +#define GETJSAMPLE(value) ((int) (value) & 0xFF) +#endif /* CHAR_IS_UNSIGNED */ + +#endif /* HAVE_UNSIGNED_CHAR */ + +#define MAXJSAMPLE 255 +#define CENTERJSAMPLE 128 + +#endif /* BITS_IN_JSAMPLE == 8 */ + + +#if BITS_IN_JSAMPLE == 12 +/* JSAMPLE should be the smallest type that will hold the values 0..4095. + * On nearly all machines "short" will do nicely. + */ + +typedef short JSAMPLE; +#define GETJSAMPLE(value) ((int) (value)) + +#define MAXJSAMPLE 4095 +#define CENTERJSAMPLE 2048 + +#endif /* BITS_IN_JSAMPLE == 12 */ + + +/* Representation of a DCT frequency coefficient. + * This should be a signed value of at least 16 bits; "short" is usually OK. + * Again, we allocate large arrays of these, but you can change to int + * if you have memory to burn and "short" is really slow. + */ + +typedef short JCOEF; + + +/* Compressed datastreams are represented as arrays of JOCTET. + * These must be EXACTLY 8 bits wide, at least once they are written to + * external storage. Note that when using the stdio data source/destination + * managers, this is also the data type passed to fread/fwrite. + */ + +#ifdef HAVE_UNSIGNED_CHAR + +typedef unsigned char JOCTET; +#define GETJOCTET(value) (value) + +#else /* not HAVE_UNSIGNED_CHAR */ + +typedef char JOCTET; +#ifdef CHAR_IS_UNSIGNED +#define GETJOCTET(value) (value) +#else +#define GETJOCTET(value) ((value) & 0xFF) +#endif /* CHAR_IS_UNSIGNED */ + +#endif /* HAVE_UNSIGNED_CHAR */ + + +/* These typedefs are used for various table entries and so forth. + * They must be at least as wide as specified; but making them too big + * won't cost a huge amount of memory, so we don't provide special + * extraction code like we did for JSAMPLE. (In other words, these + * typedefs live at a different point on the speed/space tradeoff curve.) + */ + +/* UINT8 must hold at least the values 0..255. */ + +#ifdef HAVE_UNSIGNED_CHAR +typedef unsigned char UINT8; +#else /* not HAVE_UNSIGNED_CHAR */ +#ifdef CHAR_IS_UNSIGNED +typedef char UINT8; +#else /* not CHAR_IS_UNSIGNED */ +typedef short UINT8; +#endif /* CHAR_IS_UNSIGNED */ +#endif /* HAVE_UNSIGNED_CHAR */ + +/* UINT16 must hold at least the values 0..65535. */ + +#ifdef HAVE_UNSIGNED_SHORT +typedef unsigned short UINT16; +#else /* not HAVE_UNSIGNED_SHORT */ +typedef unsigned int UINT16; +#endif /* HAVE_UNSIGNED_SHORT */ + +/* INT16 must hold at least the values -32768..32767. */ + +#ifndef XMD_H /* X11/xmd.h correctly defines INT16 */ +typedef short INT16; +#endif + +/* INT32 must hold at least signed 32-bit values. */ + +#ifndef XMD_H /* X11/xmd.h correctly defines INT32 */ +typedef long INT32; +#endif + +/* Datatype used for image dimensions. The JPEG standard only supports + * images up to 64K*64K due to 16-bit fields in SOF markers. Therefore + * "unsigned int" is sufficient on all machines. However, if you need to + * handle larger images and you don't mind deviating from the spec, you + * can change this datatype. + */ + +typedef unsigned int JDIMENSION; + +#define JPEG_MAX_DIMENSION 65500L /* a tad under 64K to prevent overflows */ + + +/* These macros are used in all function definitions and extern declarations. + * You could modify them if you need to change function linkage conventions; + * in particular, you'll need to do that to make the library a Windows DLL. + * Another application is to make all functions global for use with debuggers + * or code profilers that require it. + */ + +/* a function called through method pointers: */ +#define METHODDEF(type) static type +/* a function used only in its module: */ +#define LOCAL(type) static type +/* a function referenced thru EXTERNs: */ +#define GLOBAL(type) type +/* a reference to a GLOBAL function: */ +#define EXTERN(type) extern type + + +/* This macro is used to declare a "method", that is, a function pointer. + * We want to supply prototype parameters if the compiler can cope. + * Note that the arglist parameter must be parenthesized! + * Again, you can customize this if you need special linkage keywords. + */ + +#ifdef HAVE_PROTOTYPES +#define JMETHOD(type,methodname,arglist) type (*methodname) arglist +#else +#define JMETHOD(type,methodname,arglist) type (*methodname) () +#endif + + +/* Here is the pseudo-keyword for declaring pointers that must be "far" + * on 80x86 machines. Most of the specialized coding for 80x86 is handled + * by just saying "FAR *" where such a pointer is needed. In a few places + * explicit coding is needed; see uses of the NEED_FAR_POINTERS symbol. + */ + +#ifdef NEED_FAR_POINTERS +#define FAR far +#else +#define FAR +#endif + + +/* + * On a few systems, type boolean and/or its values FALSE, TRUE may appear + * in standard header files. Or you may have conflicts with application- + * specific header files that you want to include together with these files. + * Defining HAVE_BOOLEAN before including jpeglib.h should make it work. + */ + +#ifndef HAVE_BOOLEAN +typedef int boolean; +#endif +#ifndef FALSE /* in case these macros already exist */ +#define FALSE 0 /* values of boolean */ +#endif +#ifndef TRUE +#define TRUE 1 +#endif + + +/* + * The remaining options affect code selection within the JPEG library, + * but they don't need to be visible to most applications using the library. + * To minimize application namespace pollution, the symbols won't be + * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined. + */ + +#ifdef JPEG_INTERNALS +#define JPEG_INTERNAL_OPTIONS +#endif + +#ifdef JPEG_INTERNAL_OPTIONS + + +/* + * These defines indicate whether to include various optional functions. + * Undefining some of these symbols will produce a smaller but less capable + * library. Note that you can leave certain source files out of the + * compilation/linking process if you've #undef'd the corresponding symbols. + * (You may HAVE to do that if your compiler doesn't like null source files.) + */ + +/* Arithmetic coding is unsupported for legal reasons. Complaints to IBM. */ + +/* Capability options common to encoder and decoder: */ + +#define DCT_ISLOW_SUPPORTED /* slow but accurate integer algorithm */ +#define DCT_IFAST_SUPPORTED /* faster, less accurate integer method */ +#define DCT_FLOAT_SUPPORTED /* floating-point: accurate, fast on fast HW */ + +/* Encoder capability options: */ + +#undef C_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */ +#define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */ +#define C_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/ +#define ENTROPY_OPT_SUPPORTED /* Optimization of entropy coding parms? */ +/* Note: if you selected 12-bit data precision, it is dangerous to turn off + * ENTROPY_OPT_SUPPORTED. The standard Huffman tables are only good for 8-bit + * precision, so jchuff.c normally uses entropy optimization to compute + * usable tables for higher precision. If you don't want to do optimization, + * you'll have to supply different default Huffman tables. + * The exact same statements apply for progressive JPEG: the default tables + * don't work for progressive mode. (This may get fixed, however.) + */ +#define INPUT_SMOOTHING_SUPPORTED /* Input image smoothing option? */ + +/* Decoder capability options: */ + +#undef D_ARITH_CODING_SUPPORTED /* Arithmetic coding back end? */ +#define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */ +#define D_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/ +#define SAVE_MARKERS_SUPPORTED /* jpeg_save_markers() needed? */ +#define BLOCK_SMOOTHING_SUPPORTED /* Block smoothing? (Progressive only) */ +#define IDCT_SCALING_SUPPORTED /* Output rescaling via IDCT? */ +#undef UPSAMPLE_SCALING_SUPPORTED /* Output rescaling at upsample stage? */ +#define UPSAMPLE_MERGING_SUPPORTED /* Fast path for sloppy upsampling? */ +#define QUANT_1PASS_SUPPORTED /* 1-pass color quantization? */ +#define QUANT_2PASS_SUPPORTED /* 2-pass color quantization? */ + +/* more capability options later, no doubt */ + + +/* + * Ordering of RGB data in scanlines passed to or from the application. + * If your application wants to deal with data in the order B,G,R, just + * change these macros. You can also deal with formats such as R,G,B,X + * (one extra byte per pixel) by changing RGB_PIXELSIZE. Note that changing + * the offsets will also change the order in which colormap data is organized. + * RESTRICTIONS: + * 1. The sample applications cjpeg,djpeg do NOT support modified RGB formats. + * 2. These macros only affect RGB<=>YCbCr color conversion, so they are not + * useful if you are using JPEG color spaces other than YCbCr or grayscale. + * 3. The color quantizer modules will not behave desirably if RGB_PIXELSIZE + * is not 3 (they don't understand about dummy color components!). So you + * can't use color quantization if you change that value. + */ + +#define RGB_RED 0 /* Offset of Red in an RGB scanline element */ +#define RGB_GREEN 1 /* Offset of Green */ +#define RGB_BLUE 2 /* Offset of Blue */ +#define RGB_PIXELSIZE 3 /* JSAMPLEs per RGB scanline element */ + + +/* Definitions for speed-related optimizations. */ + + +/* If your compiler supports inline functions, define INLINE + * as the inline keyword; otherwise define it as empty. + */ + +#ifndef INLINE +#ifdef __GNUC__ /* for instance, GNU C knows about inline */ +#define INLINE __inline__ +#endif +#ifndef INLINE +#define INLINE /* default is to define it as empty */ +#endif +#endif + + +/* On some machines (notably 68000 series) "int" is 32 bits, but multiplying + * two 16-bit shorts is faster than multiplying two ints. Define MULTIPLIER + * as short on such a machine. MULTIPLIER must be at least 16 bits wide. + */ + +#ifndef MULTIPLIER +#define MULTIPLIER int /* type for fastest integer multiply */ +#endif + + +/* FAST_FLOAT should be either float or double, whichever is done faster + * by your compiler. (Note that this type is only used in the floating point + * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.) + * Typically, float is faster in ANSI C compilers, while double is faster in + * pre-ANSI compilers (because they insist on converting to double anyway). + * The code below therefore chooses float if we have ANSI-style prototypes. + */ + +#ifndef FAST_FLOAT +#ifdef HAVE_PROTOTYPES +#define FAST_FLOAT float +#else +#define FAST_FLOAT double +#endif +#endif + +#endif /* JPEG_INTERNAL_OPTIONS */ diff --git a/misc/builddeps/emscripten/jpeg/include/jpeglib.h b/misc/builddeps/emscripten/jpeg/include/jpeglib.h new file mode 100644 index 00000000..d1be8dde --- /dev/null +++ b/misc/builddeps/emscripten/jpeg/include/jpeglib.h @@ -0,0 +1,1096 @@ +/* + * jpeglib.h + * + * 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 defines the application interface for the JPEG library. + * Most applications using the library need only include this file, + * and perhaps jerror.h if they want to know the exact error codes. + */ + +#ifndef JPEGLIB_H +#define JPEGLIB_H + +/* + * First we include the configuration files that record how this + * installation of the JPEG library is set up. jconfig.h can be + * generated automatically for many systems. jmorecfg.h contains + * manual configuration options that most people need not worry about. + */ + +#ifndef JCONFIG_INCLUDED /* in case jinclude.h already did */ +#include "jconfig.h" /* widely used configuration options */ +#endif +#include "jmorecfg.h" /* seldom changed options */ + + +/* Version ID for the JPEG library. + * Might be useful for tests like "#if JPEG_LIB_VERSION >= 60". + */ + +#define JPEG_LIB_VERSION 62 /* Version 6b */ + + +/* Various constants determining the sizes of things. + * All of these are specified by the JPEG standard, so don't change them + * if you want to be compatible. + */ + +#define DCTSIZE 8 /* The basic DCT block is 8x8 samples */ +#define DCTSIZE2 64 /* DCTSIZE squared; # of elements in a block */ +#define NUM_QUANT_TBLS 4 /* Quantization tables are numbered 0..3 */ +#define NUM_HUFF_TBLS 4 /* Huffman tables are numbered 0..3 */ +#define NUM_ARITH_TBLS 16 /* Arith-coding tables are numbered 0..15 */ +#define MAX_COMPS_IN_SCAN 4 /* JPEG limit on # of components in one scan */ +#define MAX_SAMP_FACTOR 4 /* JPEG limit on sampling factors */ +/* Unfortunately, some bozo at Adobe saw no reason to be bound by the standard; + * the PostScript DCT filter can emit files with many more than 10 blocks/MCU. + * If you happen to run across such a file, you can up D_MAX_BLOCKS_IN_MCU + * to handle it. We even let you do this from the jconfig.h file. However, + * we strongly discourage changing C_MAX_BLOCKS_IN_MCU; just because Adobe + * sometimes emits noncompliant files doesn't mean you should too. + */ +#define C_MAX_BLOCKS_IN_MCU 10 /* compressor's limit on blocks per MCU */ +#ifndef D_MAX_BLOCKS_IN_MCU +#define D_MAX_BLOCKS_IN_MCU 10 /* decompressor's limit on blocks per MCU */ +#endif + + +/* Data structures for images (arrays of samples and of DCT coefficients). + * On 80x86 machines, the image arrays are too big for near pointers, + * but the pointer arrays can fit in near memory. + */ + +typedef JSAMPLE FAR *JSAMPROW; /* ptr to one image row of pixel samples. */ +typedef JSAMPROW *JSAMPARRAY; /* ptr to some rows (a 2-D sample array) */ +typedef JSAMPARRAY *JSAMPIMAGE; /* a 3-D sample array: top index is color */ + +typedef JCOEF JBLOCK[DCTSIZE2]; /* one block of coefficients */ +typedef JBLOCK FAR *JBLOCKROW; /* pointer to one row of coefficient blocks */ +typedef JBLOCKROW *JBLOCKARRAY; /* a 2-D array of coefficient blocks */ +typedef JBLOCKARRAY *JBLOCKIMAGE; /* a 3-D array of coefficient blocks */ + +typedef JCOEF FAR *JCOEFPTR; /* useful in a couple of places */ + + +/* Types for JPEG compression parameters and working tables. */ + + +/* DCT coefficient quantization tables. */ + +typedef struct { + /* This array gives the coefficient quantizers in natural array order + * (not the zigzag order in which they are stored in a JPEG DQT marker). + * CAUTION: IJG versions prior to v6a kept this array in zigzag order. + */ + UINT16 quantval[DCTSIZE2]; /* quantization step for each coefficient */ + /* This field is used only during compression. It's initialized FALSE when + * the table is created, and set TRUE when it's been output to the file. + * You could suppress output of a table by setting this to TRUE. + * (See jpeg_suppress_tables for an example.) + */ + boolean sent_table; /* TRUE when table has been output */ +} JQUANT_TBL; + + +/* Huffman coding tables. */ + +typedef struct { + /* These two fields directly represent the contents of a JPEG DHT marker */ + UINT8 bits[17]; /* bits[k] = # of symbols with codes of */ + /* length k bits; bits[0] is unused */ + UINT8 huffval[256]; /* The symbols, in order of incr code length */ + /* This field is used only during compression. It's initialized FALSE when + * the table is created, and set TRUE when it's been output to the file. + * You could suppress output of a table by setting this to TRUE. + * (See jpeg_suppress_tables for an example.) + */ + boolean sent_table; /* TRUE when table has been output */ +} JHUFF_TBL; + + +/* Basic info about one component (color channel). */ + +typedef struct { + /* These values are fixed over the whole image. */ + /* For compression, they must be supplied by parameter setup; */ + /* for decompression, they are read from the SOF marker. */ + int component_id; /* identifier for this component (0..255) */ + int component_index; /* its index in SOF or cinfo->comp_info[] */ + int h_samp_factor; /* horizontal sampling factor (1..4) */ + int v_samp_factor; /* vertical sampling factor (1..4) */ + int quant_tbl_no; /* quantization table selector (0..3) */ + /* These values may vary between scans. */ + /* For compression, they must be supplied by parameter setup; */ + /* for decompression, they are read from the SOS marker. */ + /* The decompressor output side may not use these variables. */ + int dc_tbl_no; /* DC entropy table selector (0..3) */ + int ac_tbl_no; /* AC entropy table selector (0..3) */ + + /* Remaining fields should be treated as private by applications. */ + + /* These values are computed during compression or decompression startup: */ + /* Component's size in DCT blocks. + * Any dummy blocks added to complete an MCU are not counted; therefore + * these values do not depend on whether a scan is interleaved or not. + */ + JDIMENSION width_in_blocks; + JDIMENSION height_in_blocks; + /* Size of a DCT block in samples. Always DCTSIZE for compression. + * For decompression this is the size of the output from one DCT block, + * reflecting any scaling we choose to apply during the IDCT step. + * Values of 1,2,4,8 are likely to be supported. Note that different + * components may receive different IDCT scalings. + */ + int DCT_scaled_size; + /* The downsampled dimensions are the component's actual, unpadded number + * of samples at the main buffer (preprocessing/compression interface), thus + * downsampled_width = ceil(image_width * Hi/Hmax) + * and similarly for height. For decompression, IDCT scaling is included, so + * downsampled_width = ceil(image_width * Hi/Hmax * DCT_scaled_size/DCTSIZE) + */ + JDIMENSION downsampled_width; /* actual width in samples */ + JDIMENSION downsampled_height; /* actual height in samples */ + /* This flag is used only for decompression. In cases where some of the + * components will be ignored (eg grayscale output from YCbCr image), + * we can skip most computations for the unused components. + */ + boolean component_needed; /* do we need the value of this component? */ + + /* These values are computed before starting a scan of the component. */ + /* The decompressor output side may not use these variables. */ + int MCU_width; /* number of blocks per MCU, horizontally */ + int MCU_height; /* number of blocks per MCU, vertically */ + int MCU_blocks; /* MCU_width * MCU_height */ + int MCU_sample_width; /* MCU width in samples, MCU_width*DCT_scaled_size */ + int last_col_width; /* # of non-dummy blocks across in last MCU */ + int last_row_height; /* # of non-dummy blocks down in last MCU */ + + /* Saved quantization table for component; NULL if none yet saved. + * See jdinput.c comments about the need for this information. + * This field is currently used only for decompression. + */ + JQUANT_TBL * quant_table; + + /* Private per-component storage for DCT or IDCT subsystem. */ + void * dct_table; +} jpeg_component_info; + + +/* The script for encoding a multiple-scan file is an array of these: */ + +typedef struct { + int comps_in_scan; /* number of components encoded in this scan */ + int component_index[MAX_COMPS_IN_SCAN]; /* their SOF/comp_info[] indexes */ + int Ss, Se; /* progressive JPEG spectral selection parms */ + int Ah, Al; /* progressive JPEG successive approx. parms */ +} jpeg_scan_info; + +/* The decompressor can save APPn and COM markers in a list of these: */ + +typedef struct jpeg_marker_struct FAR * jpeg_saved_marker_ptr; + +struct jpeg_marker_struct { + jpeg_saved_marker_ptr next; /* next in list, or NULL */ + UINT8 marker; /* marker code: JPEG_COM, or JPEG_APP0+n */ + unsigned int original_length; /* # bytes of data in the file */ + unsigned int data_length; /* # bytes of data saved at data[] */ + JOCTET FAR * data; /* the data contained in the marker */ + /* the marker length word is not counted in data_length or original_length */ +}; + +/* Known color spaces. */ + +typedef enum { + JCS_UNKNOWN, /* error/unspecified */ + JCS_GRAYSCALE, /* monochrome */ + JCS_RGB, /* red/green/blue */ + JCS_YCbCr, /* Y/Cb/Cr (also known as YUV) */ + JCS_CMYK, /* C/M/Y/K */ + JCS_YCCK /* Y/Cb/Cr/K */ +} J_COLOR_SPACE; + +/* DCT/IDCT algorithm options. */ + +typedef enum { + JDCT_ISLOW, /* slow but accurate integer algorithm */ + JDCT_IFAST, /* faster, less accurate integer method */ + JDCT_FLOAT /* floating-point: accurate, fast on fast HW */ +} J_DCT_METHOD; + +#ifndef JDCT_DEFAULT /* may be overridden in jconfig.h */ +#define JDCT_DEFAULT JDCT_ISLOW +#endif +#ifndef JDCT_FASTEST /* may be overridden in jconfig.h */ +#define JDCT_FASTEST JDCT_IFAST +#endif + +/* Dithering options for decompression. */ + +typedef enum { + JDITHER_NONE, /* no dithering */ + JDITHER_ORDERED, /* simple ordered dither */ + JDITHER_FS /* Floyd-Steinberg error diffusion dither */ +} J_DITHER_MODE; + + +/* Common fields between JPEG compression and decompression master structs. */ + +#define jpeg_common_fields \ + struct jpeg_error_mgr * err; /* Error handler module */\ + struct jpeg_memory_mgr * mem; /* Memory manager module */\ + struct jpeg_progress_mgr * progress; /* Progress monitor, or NULL if none */\ + void * client_data; /* Available for use by application */\ + boolean is_decompressor; /* So common code can tell which is which */\ + int global_state /* For checking call sequence validity */ + +/* Routines that are to be used by both halves of the library are declared + * to receive a pointer to this structure. There are no actual instances of + * jpeg_common_struct, only of jpeg_compress_struct and jpeg_decompress_struct. + */ +struct jpeg_common_struct { + jpeg_common_fields; /* Fields common to both master struct types */ + /* Additional fields follow in an actual jpeg_compress_struct or + * jpeg_decompress_struct. All three structs must agree on these + * initial fields! (This would be a lot cleaner in C++.) + */ +}; + +typedef struct jpeg_common_struct * j_common_ptr; +typedef struct jpeg_compress_struct * j_compress_ptr; +typedef struct jpeg_decompress_struct * j_decompress_ptr; + + +/* Master record for a compression instance */ + +struct jpeg_compress_struct { + jpeg_common_fields; /* Fields shared with jpeg_decompress_struct */ + + /* Destination for compressed data */ + struct jpeg_destination_mgr * dest; + + /* Description of source image --- these fields must be filled in by + * outer application before starting compression. in_color_space must + * be correct before you can even call jpeg_set_defaults(). + */ + + JDIMENSION image_width; /* input image width */ + JDIMENSION image_height; /* input image height */ + int input_components; /* # of color components in input image */ + J_COLOR_SPACE in_color_space; /* colorspace of input image */ + + double input_gamma; /* image gamma of input image */ + + /* Compression parameters --- these fields must be set before calling + * jpeg_start_compress(). We recommend calling jpeg_set_defaults() to + * initialize everything to reasonable defaults, then changing anything + * the application specifically wants to change. That way you won't get + * burnt when new parameters are added. Also note that there are several + * helper routines to simplify changing parameters. + */ + + int data_precision; /* bits of precision in image data */ + + int num_components; /* # of color components in JPEG image */ + J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */ + + jpeg_component_info * comp_info; + /* comp_info[i] describes component that appears i'th in SOF */ + + JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS]; + /* ptrs to coefficient quantization tables, or NULL if not defined */ + + JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS]; + JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS]; + /* ptrs to Huffman coding tables, or NULL if not defined */ + + UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */ + UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */ + UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */ + + int num_scans; /* # of entries in scan_info array */ + const jpeg_scan_info * scan_info; /* script for multi-scan file, or NULL */ + /* The default value of scan_info is NULL, which causes a single-scan + * sequential JPEG file to be emitted. To create a multi-scan file, + * set num_scans and scan_info to point to an array of scan definitions. + */ + + boolean raw_data_in; /* TRUE=caller supplies downsampled data */ + boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */ + boolean optimize_coding; /* TRUE=optimize entropy encoding parms */ + boolean CCIR601_sampling; /* TRUE=first samples are cosited */ + int smoothing_factor; /* 1..100, or 0 for no input smoothing */ + J_DCT_METHOD dct_method; /* DCT algorithm selector */ + + /* The restart interval can be specified in absolute MCUs by setting + * restart_interval, or in MCU rows by setting restart_in_rows + * (in which case the correct restart_interval will be figured + * for each scan). + */ + unsigned int restart_interval; /* MCUs per restart, or 0 for no restart */ + int restart_in_rows; /* if > 0, MCU rows per restart interval */ + + /* Parameters controlling emission of special markers. */ + + boolean write_JFIF_header; /* should a JFIF marker be written? */ + UINT8 JFIF_major_version; /* What to write for the JFIF version number */ + UINT8 JFIF_minor_version; + /* These three values are not used by the JPEG code, merely copied */ + /* into the JFIF APP0 marker. density_unit can be 0 for unknown, */ + /* 1 for dots/inch, or 2 for dots/cm. Note that the pixel aspect */ + /* ratio is defined by X_density/Y_density even when density_unit=0. */ + UINT8 density_unit; /* JFIF code for pixel size units */ + UINT16 X_density; /* Horizontal pixel density */ + UINT16 Y_density; /* Vertical pixel density */ + boolean write_Adobe_marker; /* should an Adobe marker be written? */ + + /* State variable: index of next scanline to be written to + * jpeg_write_scanlines(). Application may use this to control its + * processing loop, e.g., "while (next_scanline < image_height)". + */ + + JDIMENSION next_scanline; /* 0 .. image_height-1 */ + + /* Remaining fields are known throughout compressor, but generally + * should not be touched by a surrounding application. + */ + + /* + * These fields are computed during compression startup + */ + boolean progressive_mode; /* TRUE if scan script uses progressive mode */ + int max_h_samp_factor; /* largest h_samp_factor */ + int max_v_samp_factor; /* largest v_samp_factor */ + + JDIMENSION total_iMCU_rows; /* # of iMCU rows to be input to coef ctlr */ + /* The coefficient controller receives data in units of MCU rows as defined + * for fully interleaved scans (whether the JPEG file is interleaved or not). + * There are v_samp_factor * DCTSIZE sample rows of each component in an + * "iMCU" (interleaved MCU) row. + */ + + /* + * These fields are valid during any one scan. + * They describe the components and MCUs actually appearing in the scan. + */ + int comps_in_scan; /* # of JPEG components in this scan */ + jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]; + /* *cur_comp_info[i] describes component that appears i'th in SOS */ + + JDIMENSION MCUs_per_row; /* # of MCUs across the image */ + JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */ + + int blocks_in_MCU; /* # of DCT blocks per MCU */ + int MCU_membership[C_MAX_BLOCKS_IN_MCU]; + /* MCU_membership[i] is index in cur_comp_info of component owning */ + /* i'th block in an MCU */ + + int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */ + + /* + * Links to compression subobjects (methods and private variables of modules) + */ + struct jpeg_comp_master * master; + struct jpeg_c_main_controller * main; + struct jpeg_c_prep_controller * prep; + struct jpeg_c_coef_controller * coef; + struct jpeg_marker_writer * marker; + struct jpeg_color_converter * cconvert; + struct jpeg_downsampler * downsample; + struct jpeg_forward_dct * fdct; + struct jpeg_entropy_encoder * entropy; + jpeg_scan_info * script_space; /* workspace for jpeg_simple_progression */ + int script_space_size; +}; + + +/* Master record for a decompression instance */ + +struct jpeg_decompress_struct { + jpeg_common_fields; /* Fields shared with jpeg_compress_struct */ + + /* Source of compressed data */ + struct jpeg_source_mgr * src; + + /* Basic description of image --- filled in by jpeg_read_header(). */ + /* Application may inspect these values to decide how to process image. */ + + JDIMENSION image_width; /* nominal image width (from SOF marker) */ + JDIMENSION image_height; /* nominal image height */ + int num_components; /* # of color components in JPEG image */ + J_COLOR_SPACE jpeg_color_space; /* colorspace of JPEG image */ + + /* Decompression processing parameters --- these fields must be set before + * calling jpeg_start_decompress(). Note that jpeg_read_header() initializes + * them to default values. + */ + + J_COLOR_SPACE out_color_space; /* colorspace for output */ + + unsigned int scale_num, scale_denom; /* fraction by which to scale image */ + + double output_gamma; /* image gamma wanted in output */ + + boolean buffered_image; /* TRUE=multiple output passes */ + boolean raw_data_out; /* TRUE=downsampled data wanted */ + + J_DCT_METHOD dct_method; /* IDCT algorithm selector */ + boolean do_fancy_upsampling; /* TRUE=apply fancy upsampling */ + boolean do_block_smoothing; /* TRUE=apply interblock smoothing */ + + boolean quantize_colors; /* TRUE=colormapped output wanted */ + /* the following are ignored if not quantize_colors: */ + J_DITHER_MODE dither_mode; /* type of color dithering to use */ + boolean two_pass_quantize; /* TRUE=use two-pass color quantization */ + int desired_number_of_colors; /* max # colors to use in created colormap */ + /* these are significant only in buffered-image mode: */ + boolean enable_1pass_quant; /* enable future use of 1-pass quantizer */ + boolean enable_external_quant;/* enable future use of external colormap */ + boolean enable_2pass_quant; /* enable future use of 2-pass quantizer */ + + /* Description of actual output image that will be returned to application. + * These fields are computed by jpeg_start_decompress(). + * You can also use jpeg_calc_output_dimensions() to determine these values + * in advance of calling jpeg_start_decompress(). + */ + + JDIMENSION output_width; /* scaled image width */ + JDIMENSION output_height; /* scaled image height */ + int out_color_components; /* # of color components in out_color_space */ + int output_components; /* # of color components returned */ + /* output_components is 1 (a colormap index) when quantizing colors; + * otherwise it equals out_color_components. + */ + int rec_outbuf_height; /* min recommended height of scanline buffer */ + /* If the buffer passed to jpeg_read_scanlines() is less than this many rows + * high, space and time will be wasted due to unnecessary data copying. + * Usually rec_outbuf_height will be 1 or 2, at most 4. + */ + + /* When quantizing colors, the output colormap is described by these fields. + * The application can supply a colormap by setting colormap non-NULL before + * calling jpeg_start_decompress; otherwise a colormap is created during + * jpeg_start_decompress or jpeg_start_output. + * The map has out_color_components rows and actual_number_of_colors columns. + */ + int actual_number_of_colors; /* number of entries in use */ + JSAMPARRAY colormap; /* The color map as a 2-D pixel array */ + + /* State variables: these variables indicate the progress of decompression. + * The application may examine these but must not modify them. + */ + + /* Row index of next scanline to be read from jpeg_read_scanlines(). + * Application may use this to control its processing loop, e.g., + * "while (output_scanline < output_height)". + */ + JDIMENSION output_scanline; /* 0 .. output_height-1 */ + + /* Current input scan number and number of iMCU rows completed in scan. + * These indicate the progress of the decompressor input side. + */ + int input_scan_number; /* Number of SOS markers seen so far */ + JDIMENSION input_iMCU_row; /* Number of iMCU rows completed */ + + /* The "output scan number" is the notional scan being displayed by the + * output side. The decompressor will not allow output scan/row number + * to get ahead of input scan/row, but it can fall arbitrarily far behind. + */ + int output_scan_number; /* Nominal scan number being displayed */ + JDIMENSION output_iMCU_row; /* Number of iMCU rows read */ + + /* Current progression status. coef_bits[c][i] indicates the precision + * with which component c's DCT coefficient i (in zigzag order) is known. + * It is -1 when no data has yet been received, otherwise it is the point + * transform (shift) value for the most recent scan of the coefficient + * (thus, 0 at completion of the progression). + * This pointer is NULL when reading a non-progressive file. + */ + int (*coef_bits)[DCTSIZE2]; /* -1 or current Al value for each coef */ + + /* Internal JPEG parameters --- the application usually need not look at + * these fields. Note that the decompressor output side may not use + * any parameters that can change between scans. + */ + + /* Quantization and Huffman tables are carried forward across input + * datastreams when processing abbreviated JPEG datastreams. + */ + + JQUANT_TBL * quant_tbl_ptrs[NUM_QUANT_TBLS]; + /* ptrs to coefficient quantization tables, or NULL if not defined */ + + JHUFF_TBL * dc_huff_tbl_ptrs[NUM_HUFF_TBLS]; + JHUFF_TBL * ac_huff_tbl_ptrs[NUM_HUFF_TBLS]; + /* ptrs to Huffman coding tables, or NULL if not defined */ + + /* These parameters are never carried across datastreams, since they + * are given in SOF/SOS markers or defined to be reset by SOI. + */ + + int data_precision; /* bits of precision in image data */ + + jpeg_component_info * comp_info; + /* comp_info[i] describes component that appears i'th in SOF */ + + boolean progressive_mode; /* TRUE if SOFn specifies progressive mode */ + boolean arith_code; /* TRUE=arithmetic coding, FALSE=Huffman */ + + UINT8 arith_dc_L[NUM_ARITH_TBLS]; /* L values for DC arith-coding tables */ + UINT8 arith_dc_U[NUM_ARITH_TBLS]; /* U values for DC arith-coding tables */ + UINT8 arith_ac_K[NUM_ARITH_TBLS]; /* Kx values for AC arith-coding tables */ + + unsigned int restart_interval; /* MCUs per restart interval, or 0 for no restart */ + + /* These fields record data obtained from optional markers recognized by + * the JPEG library. + */ + boolean saw_JFIF_marker; /* TRUE iff a JFIF APP0 marker was found */ + /* Data copied from JFIF marker; only valid if saw_JFIF_marker is TRUE: */ + UINT8 JFIF_major_version; /* JFIF version number */ + UINT8 JFIF_minor_version; + UINT8 density_unit; /* JFIF code for pixel size units */ + UINT16 X_density; /* Horizontal pixel density */ + UINT16 Y_density; /* Vertical pixel density */ + boolean saw_Adobe_marker; /* TRUE iff an Adobe APP14 marker was found */ + UINT8 Adobe_transform; /* Color transform code from Adobe marker */ + + boolean CCIR601_sampling; /* TRUE=first samples are cosited */ + + /* Aside from the specific data retained from APPn markers known to the + * library, the uninterpreted contents of any or all APPn and COM markers + * can be saved in a list for examination by the application. + */ + jpeg_saved_marker_ptr marker_list; /* Head of list of saved markers */ + + /* Remaining fields are known throughout decompressor, but generally + * should not be touched by a surrounding application. + */ + + /* + * These fields are computed during decompression startup + */ + int max_h_samp_factor; /* largest h_samp_factor */ + int max_v_samp_factor; /* largest v_samp_factor */ + + int min_DCT_scaled_size; /* smallest DCT_scaled_size of any component */ + + JDIMENSION total_iMCU_rows; /* # of iMCU rows in image */ + /* The coefficient controller's input and output progress is measured in + * units of "iMCU" (interleaved MCU) rows. These are the same as MCU rows + * in fully interleaved JPEG scans, but are used whether the scan is + * interleaved or not. We define an iMCU row as v_samp_factor DCT block + * rows of each component. Therefore, the IDCT output contains + * v_samp_factor*DCT_scaled_size sample rows of a component per iMCU row. + */ + + JSAMPLE * sample_range_limit; /* table for fast range-limiting */ + + /* + * These fields are valid during any one scan. + * They describe the components and MCUs actually appearing in the scan. + * Note that the decompressor output side must not use these fields. + */ + int comps_in_scan; /* # of JPEG components in this scan */ + jpeg_component_info * cur_comp_info[MAX_COMPS_IN_SCAN]; + /* *cur_comp_info[i] describes component that appears i'th in SOS */ + + JDIMENSION MCUs_per_row; /* # of MCUs across the image */ + JDIMENSION MCU_rows_in_scan; /* # of MCU rows in the image */ + + int blocks_in_MCU; /* # of DCT blocks per MCU */ + int MCU_membership[D_MAX_BLOCKS_IN_MCU]; + /* MCU_membership[i] is index in cur_comp_info of component owning */ + /* i'th block in an MCU */ + + int Ss, Se, Ah, Al; /* progressive JPEG parameters for scan */ + + /* This field is shared between entropy decoder and marker parser. + * It is either zero or the code of a JPEG marker that has been + * read from the data source, but has not yet been processed. + */ + int unread_marker; + + /* + * Links to decompression subobjects (methods, private variables of modules) + */ + struct jpeg_decomp_master * master; + struct jpeg_d_main_controller * main; + struct jpeg_d_coef_controller * coef; + struct jpeg_d_post_controller * post; + struct jpeg_input_controller * inputctl; + struct jpeg_marker_reader * marker; + struct jpeg_entropy_decoder * entropy; + struct jpeg_inverse_dct * idct; + struct jpeg_upsampler * upsample; + struct jpeg_color_deconverter * cconvert; + struct jpeg_color_quantizer * cquantize; +}; + + +/* "Object" declarations for JPEG modules that may be supplied or called + * directly by the surrounding application. + * As with all objects in the JPEG library, these structs only define the + * publicly visible methods and state variables of a module. Additional + * private fields may exist after the public ones. + */ + + +/* Error handler object */ + +struct jpeg_error_mgr { + /* Error exit handler: does not return to caller */ + JMETHOD(void, error_exit, (j_common_ptr cinfo)); + /* Conditionally emit a trace or warning message */ + JMETHOD(void, emit_message, (j_common_ptr cinfo, int msg_level)); + /* Routine that actually outputs a trace or error message */ + JMETHOD(void, output_message, (j_common_ptr cinfo)); + /* Format a message string for the most recent JPEG error or message */ + JMETHOD(void, format_message, (j_common_ptr cinfo, char * buffer)); +#define JMSG_LENGTH_MAX 200 /* recommended size of format_message buffer */ + /* Reset error state variables at start of a new image */ + JMETHOD(void, reset_error_mgr, (j_common_ptr cinfo)); + + /* The message ID code and any parameters are saved here. + * A message can have one string parameter or up to 8 int parameters. + */ + int msg_code; +#define JMSG_STR_PARM_MAX 80 + union { + int i[8]; + char s[JMSG_STR_PARM_MAX]; + } msg_parm; + + /* Standard state variables for error facility */ + + int trace_level; /* max msg_level that will be displayed */ + + /* For recoverable corrupt-data errors, we emit a warning message, + * but keep going unless emit_message chooses to abort. emit_message + * should count warnings in num_warnings. The surrounding application + * can check for bad data by seeing if num_warnings is nonzero at the + * end of processing. + */ + long num_warnings; /* number of corrupt-data warnings */ + + /* These fields point to the table(s) of error message strings. + * An application can change the table pointer to switch to a different + * message list (typically, to change the language in which errors are + * reported). Some applications may wish to add additional error codes + * that will be handled by the JPEG library error mechanism; the second + * table pointer is used for this purpose. + * + * First table includes all errors generated by JPEG library itself. + * Error code 0 is reserved for a "no such error string" message. + */ + const char * const * jpeg_message_table; /* Library errors */ + int last_jpeg_message; /* Table contains strings 0..last_jpeg_message */ + /* Second table can be added by application (see cjpeg/djpeg for example). + * It contains strings numbered first_addon_message..last_addon_message. + */ + const char * const * addon_message_table; /* Non-library errors */ + int first_addon_message; /* code for first string in addon table */ + int last_addon_message; /* code for last string in addon table */ +}; + + +/* Progress monitor object */ + +struct jpeg_progress_mgr { + JMETHOD(void, progress_monitor, (j_common_ptr cinfo)); + + long pass_counter; /* work units completed in this pass */ + long pass_limit; /* total number of work units in this pass */ + int completed_passes; /* passes completed so far */ + int total_passes; /* total number of passes expected */ +}; + + +/* Data destination object for compression */ + +struct jpeg_destination_mgr { + JOCTET * next_output_byte; /* => next byte to write in buffer */ + size_t free_in_buffer; /* # of byte spaces remaining in buffer */ + + JMETHOD(void, init_destination, (j_compress_ptr cinfo)); + JMETHOD(boolean, empty_output_buffer, (j_compress_ptr cinfo)); + JMETHOD(void, term_destination, (j_compress_ptr cinfo)); +}; + + +/* Data source object for decompression */ + +struct jpeg_source_mgr { + const JOCTET * next_input_byte; /* => next byte to read from buffer */ + size_t bytes_in_buffer; /* # of bytes remaining in buffer */ + + JMETHOD(void, init_source, (j_decompress_ptr cinfo)); + JMETHOD(boolean, fill_input_buffer, (j_decompress_ptr cinfo)); + JMETHOD(void, skip_input_data, (j_decompress_ptr cinfo, long num_bytes)); + JMETHOD(boolean, resync_to_restart, (j_decompress_ptr cinfo, int desired)); + JMETHOD(void, term_source, (j_decompress_ptr cinfo)); +}; + + +/* Memory manager object. + * Allocates "small" objects (a few K total), "large" objects (tens of K), + * and "really big" objects (virtual arrays with backing store if needed). + * The memory manager does not allow individual objects to be freed; rather, + * each created object is assigned to a pool, and whole pools can be freed + * at once. This is faster and more convenient than remembering exactly what + * to free, especially where malloc()/free() are not too speedy. + * NB: alloc routines never return NULL. They exit to error_exit if not + * successful. + */ + +#define JPOOL_PERMANENT 0 /* lasts until master record is destroyed */ +#define JPOOL_IMAGE 1 /* lasts until done with image/datastream */ +#define JPOOL_NUMPOOLS 2 + +typedef struct jvirt_sarray_control * jvirt_sarray_ptr; +typedef struct jvirt_barray_control * jvirt_barray_ptr; + + +struct jpeg_memory_mgr { + /* Method pointers */ + JMETHOD(void *, alloc_small, (j_common_ptr cinfo, int pool_id, + size_t sizeofobject)); + JMETHOD(void FAR *, alloc_large, (j_common_ptr cinfo, int pool_id, + size_t sizeofobject)); + JMETHOD(JSAMPARRAY, alloc_sarray, (j_common_ptr cinfo, int pool_id, + JDIMENSION samplesperrow, + JDIMENSION numrows)); + JMETHOD(JBLOCKARRAY, alloc_barray, (j_common_ptr cinfo, int pool_id, + JDIMENSION blocksperrow, + JDIMENSION numrows)); + JMETHOD(jvirt_sarray_ptr, request_virt_sarray, (j_common_ptr cinfo, + int pool_id, + boolean pre_zero, + JDIMENSION samplesperrow, + JDIMENSION numrows, + JDIMENSION maxaccess)); + JMETHOD(jvirt_barray_ptr, request_virt_barray, (j_common_ptr cinfo, + int pool_id, + boolean pre_zero, + JDIMENSION blocksperrow, + JDIMENSION numrows, + JDIMENSION maxaccess)); + JMETHOD(void, realize_virt_arrays, (j_common_ptr cinfo)); + JMETHOD(JSAMPARRAY, access_virt_sarray, (j_common_ptr cinfo, + jvirt_sarray_ptr ptr, + JDIMENSION start_row, + JDIMENSION num_rows, + boolean writable)); + JMETHOD(JBLOCKARRAY, access_virt_barray, (j_common_ptr cinfo, + jvirt_barray_ptr ptr, + JDIMENSION start_row, + JDIMENSION num_rows, + boolean writable)); + JMETHOD(void, free_pool, (j_common_ptr cinfo, int pool_id)); + JMETHOD(void, self_destruct, (j_common_ptr cinfo)); + + /* Limit on memory allocation for this JPEG object. (Note that this is + * merely advisory, not a guaranteed maximum; it only affects the space + * used for virtual-array buffers.) May be changed by outer application + * after creating the JPEG object. + */ + long max_memory_to_use; + + /* Maximum allocation request accepted by alloc_large. */ + long max_alloc_chunk; +}; + + +/* Routine signature for application-supplied marker processing methods. + * Need not pass marker code since it is stored in cinfo->unread_marker. + */ +typedef JMETHOD(boolean, jpeg_marker_parser_method, (j_decompress_ptr cinfo)); + + +/* Declarations for routines called by application. + * The JPP macro hides prototype parameters from compilers that can't cope. + * Note JPP requires double parentheses. + */ + +#ifdef HAVE_PROTOTYPES +#define JPP(arglist) arglist +#else +#define JPP(arglist) () +#endif + + +/* Short forms of external names for systems with brain-damaged linkers. + * We shorten external names to be unique in the first six letters, which + * is good enough for all known systems. + * (If your compiler itself needs names to be unique in less than 15 + * characters, you are out of luck. Get a better compiler.) + */ + +#ifdef NEED_SHORT_EXTERNAL_NAMES +#define jpeg_std_error jStdError +#define jpeg_CreateCompress jCreaCompress +#define jpeg_CreateDecompress jCreaDecompress +#define jpeg_destroy_compress jDestCompress +#define jpeg_destroy_decompress jDestDecompress +#define jpeg_stdio_dest jStdDest +#define jpeg_stdio_src jStdSrc +#define jpeg_set_defaults jSetDefaults +#define jpeg_set_colorspace jSetColorspace +#define jpeg_default_colorspace jDefColorspace +#define jpeg_set_quality jSetQuality +#define jpeg_set_linear_quality jSetLQuality +#define jpeg_add_quant_table jAddQuantTable +#define jpeg_quality_scaling jQualityScaling +#define jpeg_simple_progression jSimProgress +#define jpeg_suppress_tables jSuppressTables +#define jpeg_alloc_quant_table jAlcQTable +#define jpeg_alloc_huff_table jAlcHTable +#define jpeg_start_compress jStrtCompress +#define jpeg_write_scanlines jWrtScanlines +#define jpeg_finish_compress jFinCompress +#define jpeg_write_raw_data jWrtRawData +#define jpeg_write_marker jWrtMarker +#define jpeg_write_m_header jWrtMHeader +#define jpeg_write_m_byte jWrtMByte +#define jpeg_write_tables jWrtTables +#define jpeg_read_header jReadHeader +#define jpeg_start_decompress jStrtDecompress +#define jpeg_read_scanlines jReadScanlines +#define jpeg_finish_decompress jFinDecompress +#define jpeg_read_raw_data jReadRawData +#define jpeg_has_multiple_scans jHasMultScn +#define jpeg_start_output jStrtOutput +#define jpeg_finish_output jFinOutput +#define jpeg_input_complete jInComplete +#define jpeg_new_colormap jNewCMap +#define jpeg_consume_input jConsumeInput +#define jpeg_calc_output_dimensions jCalcDimensions +#define jpeg_save_markers jSaveMarkers +#define jpeg_set_marker_processor jSetMarker +#define jpeg_read_coefficients jReadCoefs +#define jpeg_write_coefficients jWrtCoefs +#define jpeg_copy_critical_parameters jCopyCrit +#define jpeg_abort_compress jAbrtCompress +#define jpeg_abort_decompress jAbrtDecompress +#define jpeg_abort jAbort +#define jpeg_destroy jDestroy +#define jpeg_resync_to_restart jResyncRestart +#endif /* NEED_SHORT_EXTERNAL_NAMES */ + + +/* Default error-management setup */ +EXTERN(struct jpeg_error_mgr *) jpeg_std_error + JPP((struct jpeg_error_mgr * err)); + +/* Initialization of JPEG compression objects. + * jpeg_create_compress() and jpeg_create_decompress() are the exported + * names that applications should call. These expand to calls on + * jpeg_CreateCompress and jpeg_CreateDecompress with additional information + * passed for version mismatch checking. + * NB: you must set up the error-manager BEFORE calling jpeg_create_xxx. + */ +#define jpeg_create_compress(cinfo) \ + jpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, \ + (size_t) sizeof(struct jpeg_compress_struct)) +#define jpeg_create_decompress(cinfo) \ + jpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, \ + (size_t) sizeof(struct jpeg_decompress_struct)) +EXTERN(void) jpeg_CreateCompress JPP((j_compress_ptr cinfo, + int version, size_t structsize)); +EXTERN(void) jpeg_CreateDecompress JPP((j_decompress_ptr cinfo, + int version, size_t structsize)); +/* Destruction of JPEG compression objects */ +EXTERN(void) jpeg_destroy_compress JPP((j_compress_ptr cinfo)); +EXTERN(void) jpeg_destroy_decompress JPP((j_decompress_ptr cinfo)); + +/* Standard data source and destination managers: stdio streams. */ +/* Caller is responsible for opening the file before and closing after. */ +EXTERN(void) jpeg_stdio_dest JPP((j_compress_ptr cinfo, FILE * outfile)); +EXTERN(void) jpeg_stdio_src JPP((j_decompress_ptr cinfo, FILE * infile)); + +/* Default parameter setup for compression */ +EXTERN(void) jpeg_set_defaults JPP((j_compress_ptr cinfo)); +/* Compression parameter setup aids */ +EXTERN(void) jpeg_set_colorspace JPP((j_compress_ptr cinfo, + J_COLOR_SPACE colorspace)); +EXTERN(void) jpeg_default_colorspace JPP((j_compress_ptr cinfo)); +EXTERN(void) jpeg_set_quality JPP((j_compress_ptr cinfo, int quality, + boolean force_baseline)); +EXTERN(void) jpeg_set_linear_quality JPP((j_compress_ptr cinfo, + int scale_factor, + boolean force_baseline)); +EXTERN(void) jpeg_add_quant_table JPP((j_compress_ptr cinfo, int which_tbl, + const unsigned int *basic_table, + int scale_factor, + boolean force_baseline)); +EXTERN(int) jpeg_quality_scaling JPP((int quality)); +EXTERN(void) jpeg_simple_progression JPP((j_compress_ptr cinfo)); +EXTERN(void) jpeg_suppress_tables JPP((j_compress_ptr cinfo, + boolean suppress)); +EXTERN(JQUANT_TBL *) jpeg_alloc_quant_table JPP((j_common_ptr cinfo)); +EXTERN(JHUFF_TBL *) jpeg_alloc_huff_table JPP((j_common_ptr cinfo)); + +/* Main entry points for compression */ +EXTERN(void) jpeg_start_compress JPP((j_compress_ptr cinfo, + boolean write_all_tables)); +EXTERN(JDIMENSION) jpeg_write_scanlines JPP((j_compress_ptr cinfo, + JSAMPARRAY scanlines, + JDIMENSION num_lines)); +EXTERN(void) jpeg_finish_compress JPP((j_compress_ptr cinfo)); + +/* Replaces jpeg_write_scanlines when writing raw downsampled data. */ +EXTERN(JDIMENSION) jpeg_write_raw_data JPP((j_compress_ptr cinfo, + JSAMPIMAGE data, + JDIMENSION num_lines)); + +/* Write a special marker. See libjpeg.doc concerning safe usage. */ +EXTERN(void) jpeg_write_marker + JPP((j_compress_ptr cinfo, int marker, + const JOCTET * dataptr, unsigned int datalen)); +/* Same, but piecemeal. */ +EXTERN(void) jpeg_write_m_header + JPP((j_compress_ptr cinfo, int marker, unsigned int datalen)); +EXTERN(void) jpeg_write_m_byte + JPP((j_compress_ptr cinfo, int val)); + +/* Alternate compression function: just write an abbreviated table file */ +EXTERN(void) jpeg_write_tables JPP((j_compress_ptr cinfo)); + +/* Decompression startup: read start of JPEG datastream to see what's there */ +EXTERN(int) jpeg_read_header JPP((j_decompress_ptr cinfo, + boolean require_image)); +/* Return value is one of: */ +#define JPEG_SUSPENDED 0 /* Suspended due to lack of input data */ +#define JPEG_HEADER_OK 1 /* Found valid image datastream */ +#define JPEG_HEADER_TABLES_ONLY 2 /* Found valid table-specs-only datastream */ +/* If you pass require_image = TRUE (normal case), you need not check for + * a TABLES_ONLY return code; an abbreviated file will cause an error exit. + * JPEG_SUSPENDED is only possible if you use a data source module that can + * give a suspension return (the stdio source module doesn't). + */ + +/* Main entry points for decompression */ +EXTERN(boolean) jpeg_start_decompress JPP((j_decompress_ptr cinfo)); +EXTERN(JDIMENSION) jpeg_read_scanlines JPP((j_decompress_ptr cinfo, + JSAMPARRAY scanlines, + JDIMENSION max_lines)); +EXTERN(boolean) jpeg_finish_decompress JPP((j_decompress_ptr cinfo)); + +/* Replaces jpeg_read_scanlines when reading raw downsampled data. */ +EXTERN(JDIMENSION) jpeg_read_raw_data JPP((j_decompress_ptr cinfo, + JSAMPIMAGE data, + JDIMENSION max_lines)); + +/* Additional entry points for buffered-image mode. */ +EXTERN(boolean) jpeg_has_multiple_scans JPP((j_decompress_ptr cinfo)); +EXTERN(boolean) jpeg_start_output JPP((j_decompress_ptr cinfo, + int scan_number)); +EXTERN(boolean) jpeg_finish_output JPP((j_decompress_ptr cinfo)); +EXTERN(boolean) jpeg_input_complete JPP((j_decompress_ptr cinfo)); +EXTERN(void) jpeg_new_colormap JPP((j_decompress_ptr cinfo)); +EXTERN(int) jpeg_consume_input JPP((j_decompress_ptr cinfo)); +/* Return value is one of: */ +/* #define JPEG_SUSPENDED 0 Suspended due to lack of input data */ +#define JPEG_REACHED_SOS 1 /* Reached start of new scan */ +#define JPEG_REACHED_EOI 2 /* Reached end of image */ +#define JPEG_ROW_COMPLETED 3 /* Completed one iMCU row */ +#define JPEG_SCAN_COMPLETED 4 /* Completed last iMCU row of a scan */ + +/* Precalculate output dimensions for current decompression parameters. */ +EXTERN(void) jpeg_calc_output_dimensions JPP((j_decompress_ptr cinfo)); + +/* Control saving of COM and APPn markers into marker_list. */ +EXTERN(void) jpeg_save_markers + JPP((j_decompress_ptr cinfo, int marker_code, + unsigned int length_limit)); + +/* Install a special processing method for COM or APPn markers. */ +EXTERN(void) jpeg_set_marker_processor + JPP((j_decompress_ptr cinfo, int marker_code, + jpeg_marker_parser_method routine)); + +/* Read or write raw DCT coefficients --- useful for lossless transcoding. */ +EXTERN(jvirt_barray_ptr *) jpeg_read_coefficients JPP((j_decompress_ptr cinfo)); +EXTERN(void) jpeg_write_coefficients JPP((j_compress_ptr cinfo, + jvirt_barray_ptr * coef_arrays)); +EXTERN(void) jpeg_copy_critical_parameters JPP((j_decompress_ptr srcinfo, + j_compress_ptr dstinfo)); + +/* If you choose to abort compression or decompression before completing + * jpeg_finish_(de)compress, then you need to clean up to release memory, + * temporary files, etc. You can just call jpeg_destroy_(de)compress + * if you're done with the JPEG object, but if you want to clean it up and + * reuse it, call this: + */ +EXTERN(void) jpeg_abort_compress JPP((j_compress_ptr cinfo)); +EXTERN(void) jpeg_abort_decompress JPP((j_decompress_ptr cinfo)); + +/* Generic versions of jpeg_abort and jpeg_destroy that work on either + * flavor of JPEG object. These may be more convenient in some places. + */ +EXTERN(void) jpeg_abort JPP((j_common_ptr cinfo)); +EXTERN(void) jpeg_destroy JPP((j_common_ptr cinfo)); + +/* Default restart-marker-resync procedure for use by data source modules */ +EXTERN(boolean) jpeg_resync_to_restart JPP((j_decompress_ptr cinfo, + int desired)); + + +/* These marker codes are exported since applications and data source modules + * are likely to want to use them. + */ + +#define JPEG_RST0 0xD0 /* RST0 marker code */ +#define JPEG_EOI 0xD9 /* EOI marker code */ +#define JPEG_APP0 0xE0 /* APP0 marker code */ +#define JPEG_COM 0xFE /* COM marker code */ + + +/* If we have a brain-damaged compiler that emits warnings (or worse, errors) + * for structure definitions that are never filled in, keep it quiet by + * supplying dummy definitions for the various substructures. + */ + +#ifdef INCOMPLETE_TYPES_BROKEN +#ifndef JPEG_INTERNALS /* will be defined in jpegint.h */ +struct jvirt_sarray_control { long dummy; }; +struct jvirt_barray_control { long dummy; }; +struct jpeg_comp_master { long dummy; }; +struct jpeg_c_main_controller { long dummy; }; +struct jpeg_c_prep_controller { long dummy; }; +struct jpeg_c_coef_controller { long dummy; }; +struct jpeg_marker_writer { long dummy; }; +struct jpeg_color_converter { long dummy; }; +struct jpeg_downsampler { long dummy; }; +struct jpeg_forward_dct { long dummy; }; +struct jpeg_entropy_encoder { long dummy; }; +struct jpeg_decomp_master { long dummy; }; +struct jpeg_d_main_controller { long dummy; }; +struct jpeg_d_coef_controller { long dummy; }; +struct jpeg_d_post_controller { long dummy; }; +struct jpeg_input_controller { long dummy; }; +struct jpeg_marker_reader { long dummy; }; +struct jpeg_entropy_decoder { long dummy; }; +struct jpeg_inverse_dct { long dummy; }; +struct jpeg_upsampler { long dummy; }; +struct jpeg_color_deconverter { long dummy; }; +struct jpeg_color_quantizer { long dummy; }; +#endif /* JPEG_INTERNALS */ +#endif /* INCOMPLETE_TYPES_BROKEN */ + + +/* + * The JPEG library modules define JPEG_INTERNALS before including this file. + * The internal structure declarations are read only when that is true. + * Applications using the library should not include jpegint.h, but may wish + * to include jerror.h. + */ + +#ifdef JPEG_INTERNALS +#include "jpegint.h" /* fetch private declarations */ +#include "jerror.h" /* fetch error codes too */ +#endif + +#endif /* JPEGLIB_H */ diff --git a/misc/builddeps/emscripten/jpeg/libjpeg.a b/misc/builddeps/emscripten/jpeg/libjpeg.a new file mode 100644 index 0000000000000000000000000000000000000000..27370d9d7a3017f15a1ecef9f66b90e3dbe006b3 GIT binary patch literal 177686 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%0ARH=@vzR+7g&19vi%8K%+0%?GP3fJbAH4Q1W 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±W8g z|JurR-h&-$yw9&%>;3hrX7AC}YrQwDY0Cd(jpyCEwl)7RYcXA4*P4F~{<7{~-cg9&-=4Yt@-zz?&ZIQAFD@CU!8wr1Urxor-3 zq0vEZO7uQXNh#v?UcGYYAXD9^ahoP!y%#LoN`cfR=Mc0jAb-iz3~d|#KQHt|LjV8( literal 0 HcmV?d00001 diff --git a/misc/tools/all/xonotic.subr b/misc/tools/all/xonotic.subr index 0040f266..d463dbae 100755 --- a/misc/tools/all/xonotic.subr +++ b/misc/tools/all/xonotic.subr @@ -310,7 +310,7 @@ case "$cmd" in verbose emmake make $MAKEFLAGS clean fi for T in $TARGETS; do - verbose emmake make $MAKEFLAGS EXE_UNIXSDL="darkplaces-emscripten.html" DP_SSE=0 CFLAGS_EXTRA="-I../../../../misc/builddeps/emscripten/d0_blind_id/include -L../../../../misc/builddeps/emscripten/d0_blind_id/lib -Wl,-rpath,../../../../misc/builddeps/emscripten/d0_blind_id/lib -I../../../../misc/builddeps/emscripten/gmp/include -L../../../../misc/builddeps/emscripten/gmp/lib -Wl,-rpath,../../../../misc/builddeps/emscripten/gmp/lib -sUSE_SDL=2 -sUSE_ZLIB=1 -sUSE_LIBJPEG=1 -sALLOW_MEMORY_GROWTH -sINITIAL_MEMORY=100MB" LDFLAGS_EXTRA="-sINITIAL_MEMORY=100MB -sSINGLE_FILE -sFULL_ES2" STRIP=: "$@" "$T" + verbose emmake make $MAKEFLAGS EXE_UNIXSDL="darkplaces-emscripten.html" DP_SSE=0 CFLAGS_EXTRA=" -DLINK_TO_LIBJPEG -L../../../../misc/builddeps/emscripten/jpeg/lib -I../../../../misc/builddeps/emscripten/jpeg/include -I../../../../misc/builddeps/emscripten/d0_blind_id/include -L../../../../misc/builddeps/emscripten/d0_blind_id/lib -Wl,-rpath,../../../../misc/builddeps/emscripten/d0_blind_id/lib -I../../../../misc/builddeps/emscripten/gmp/include -L../../../../misc/builddeps/emscripten/gmp/lib -Wl,-rpath,../../../../misc/builddeps/emscripten/gmp/lib -sUSE_SDL=2 -sUSE_ZLIB=1 -sALLOW_MEMORY_GROWTH -sINITIAL_MEMORY=100MB" LDFLAGS_EXTRA="-sINITIAL_MEMORY=100MB -sSINGLE_FILE -sUSE_REGAL" STRIP=: "$@" "$T" done for T in $BAD_TARGETS; do $ECHO "Warning: discarded invalid client $T." -- 2.39.2