jmorecfg.h 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385
  1. /*
  2. * jmorecfg.h
  3. *
  4. * This file was part of the Independent JPEG Group's software:
  5. * Copyright (C) 1991-1997, Thomas G. Lane.
  6. * Modified 1997-2009 by Guido Vollbeding.
  7. * Lossless JPEG Modifications:
  8. * Copyright (C) 1999, Ken Murchison.
  9. * libjpeg-turbo Modifications:
  10. * Copyright (C) 2009, 2011, 2014-2015, 2018, 2020, 2022, D. R. Commander.
  11. * For conditions of distribution and use, see the accompanying README.ijg
  12. * file.
  13. *
  14. * This file contains additional configuration options that customize the
  15. * JPEG software for special applications or support machine-dependent
  16. * optimizations. Most users will not need to touch this file.
  17. */
  18. /*
  19. * Maximum number of components (color channels) allowed in JPEG image.
  20. * To meet the letter of Rec. ITU-T T.81 | ISO/IEC 10918-1, set this to 255.
  21. * However, darn few applications need more than 4 channels (maybe 5 for CMYK +
  22. * alpha mask). We recommend 10 as a reasonable compromise; use 4 if you are
  23. * really short on memory. (Each allowed component costs a hundred or so
  24. * bytes of storage, whether actually used in an image or not.)
  25. */
  26. #define MAX_COMPONENTS 10 /* maximum number of image components */
  27. /*
  28. * Basic data types.
  29. * You may need to change these if you have a machine with unusual data
  30. * type sizes; for example, "char" not 8 bits, "short" not 16 bits,
  31. * or "long" not 32 bits. We don't care whether "int" is 16 or 32 bits,
  32. * but it had better be at least 16.
  33. */
  34. /* Representation of a single sample (pixel element value).
  35. * We frequently allocate large arrays of these, so it's important to keep
  36. * them small. But if you have memory to burn and access to char or short
  37. * arrays is very slow on your hardware, you might want to change these.
  38. */
  39. /* JSAMPLE should be the smallest type that will hold the values 0..255. */
  40. typedef unsigned char JSAMPLE;
  41. #define GETJSAMPLE(value) ((int)(value))
  42. #define MAXJSAMPLE 255
  43. #define CENTERJSAMPLE 128
  44. /* J12SAMPLE should be the smallest type that will hold the values 0..4095. */
  45. typedef short J12SAMPLE;
  46. #define MAXJ12SAMPLE 4095
  47. #define CENTERJ12SAMPLE 2048
  48. /* J16SAMPLE should be the smallest type that will hold the values 0..65535. */
  49. typedef unsigned short J16SAMPLE;
  50. #define MAXJ16SAMPLE 65535
  51. #define CENTERJ16SAMPLE 32768
  52. /* Representation of a DCT frequency coefficient.
  53. * This should be a signed value of at least 16 bits; "short" is usually OK.
  54. * Again, we allocate large arrays of these, but you can change to int
  55. * if you have memory to burn and "short" is really slow.
  56. */
  57. typedef short JCOEF;
  58. /* Compressed datastreams are represented as arrays of JOCTET.
  59. * These must be EXACTLY 8 bits wide, at least once they are written to
  60. * external storage. Note that when using the stdio data source/destination
  61. * managers, this is also the data type passed to fread/fwrite.
  62. */
  63. typedef unsigned char JOCTET;
  64. #define GETJOCTET(value) (value)
  65. /* These typedefs are used for various table entries and so forth.
  66. * They must be at least as wide as specified; but making them too big
  67. * won't cost a huge amount of memory, so we don't provide special
  68. * extraction code like we did for JSAMPLE. (In other words, these
  69. * typedefs live at a different point on the speed/space tradeoff curve.)
  70. */
  71. /* UINT8 must hold at least the values 0..255. */
  72. typedef unsigned char UINT8;
  73. /* UINT16 must hold at least the values 0..65535. */
  74. typedef unsigned short UINT16;
  75. /* INT16 must hold at least the values -32768..32767. */
  76. #ifndef XMD_H /* X11/xmd.h correctly defines INT16 */
  77. typedef short INT16;
  78. #endif
  79. /* INT32 must hold at least signed 32-bit values.
  80. *
  81. * NOTE: The INT32 typedef dates back to libjpeg v5 (1994.) Integers were
  82. * sometimes 16-bit back then (MS-DOS), which is why INT32 is typedef'd to
  83. * long. It also wasn't common (or at least as common) in 1994 for INT32 to be
  84. * defined by platform headers. Since then, however, INT32 is defined in
  85. * several other common places:
  86. *
  87. * Xmd.h (X11 header) typedefs INT32 to int on 64-bit platforms and long on
  88. * 32-bit platforms (i.e always a 32-bit signed type.)
  89. *
  90. * basetsd.h (Win32 header) typedefs INT32 to int (always a 32-bit signed type
  91. * on modern platforms.)
  92. *
  93. * qglobal.h (Qt header) typedefs INT32 to int (always a 32-bit signed type on
  94. * modern platforms.)
  95. *
  96. * This is a recipe for conflict, since "long" and "int" aren't always
  97. * compatible types. Since the definition of INT32 has technically been part
  98. * of the libjpeg API for more than 20 years, we can't remove it, but we do not
  99. * use it internally any longer. We instead define a separate type (JLONG)
  100. * for internal use, which ensures that internal behavior will always be the
  101. * same regardless of any external headers that may be included.
  102. */
  103. #ifndef XMD_H /* X11/xmd.h correctly defines INT32 */
  104. #ifndef _BASETSD_H_ /* Microsoft defines it in basetsd.h */
  105. #ifndef _BASETSD_H /* MinGW is slightly different */
  106. #ifndef QGLOBAL_H /* Qt defines it in qglobal.h */
  107. typedef long INT32;
  108. #endif
  109. #endif
  110. #endif
  111. #endif
  112. /* Datatype used for image dimensions. The JPEG standard only supports
  113. * images up to 64K*64K due to 16-bit fields in SOF markers. Therefore
  114. * "unsigned int" is sufficient on all machines. However, if you need to
  115. * handle larger images and you don't mind deviating from the spec, you
  116. * can change this datatype. (Note that changing this datatype will
  117. * potentially require modifying the SIMD code. The x86-64 SIMD extensions,
  118. * in particular, assume a 32-bit JDIMENSION.)
  119. */
  120. typedef unsigned int JDIMENSION;
  121. #define JPEG_MAX_DIMENSION 65500L /* a tad under 64K to prevent overflows */
  122. /* These macros are used in all function definitions and extern declarations.
  123. * You could modify them if you need to change function linkage conventions;
  124. * in particular, you'll need to do that to make the library a Windows DLL.
  125. * Another application is to make all functions global for use with debuggers
  126. * or code profilers that require it.
  127. */
  128. /* a function called through method pointers: */
  129. #define METHODDEF(type) static type
  130. /* a function used only in its module: */
  131. #define LOCAL(type) static type
  132. /* a function referenced thru EXTERNs: */
  133. #define GLOBAL(type) type
  134. /* a reference to a GLOBAL function: */
  135. #define EXTERN(type) extern type
  136. /* Originally, this macro was used as a way of defining function prototypes
  137. * for both modern compilers as well as older compilers that did not support
  138. * prototype parameters. libjpeg-turbo has never supported these older,
  139. * non-ANSI compilers, but the macro is still included because there is some
  140. * software out there that uses it.
  141. */
  142. #define JMETHOD(type, methodname, arglist) type (*methodname) arglist
  143. /* libjpeg-turbo no longer supports platforms that have far symbols (MS-DOS),
  144. * but again, some software relies on this macro.
  145. */
  146. #undef FAR
  147. #define FAR
  148. /*
  149. * On a few systems, type boolean and/or its values FALSE, TRUE may appear
  150. * in standard header files. Or you may have conflicts with application-
  151. * specific header files that you want to include together with these files.
  152. * Defining HAVE_BOOLEAN before including jpeglib.h should make it work.
  153. */
  154. #ifndef HAVE_BOOLEAN
  155. typedef int boolean;
  156. #endif
  157. #ifndef FALSE /* in case these macros already exist */
  158. #define FALSE 0 /* values of boolean */
  159. #endif
  160. #ifndef TRUE
  161. #define TRUE 1
  162. #endif
  163. /*
  164. * The remaining options affect code selection within the JPEG library,
  165. * but they don't need to be visible to most applications using the library.
  166. * To minimize application namespace pollution, the symbols won't be
  167. * defined unless JPEG_INTERNALS or JPEG_INTERNAL_OPTIONS has been defined.
  168. */
  169. #ifdef JPEG_INTERNALS
  170. #define JPEG_INTERNAL_OPTIONS
  171. #endif
  172. #ifdef JPEG_INTERNAL_OPTIONS
  173. /*
  174. * These defines indicate whether to include various optional functions.
  175. * Undefining some of these symbols will produce a smaller but less capable
  176. * library. Note that you can leave certain source files out of the
  177. * compilation/linking process if you've #undef'd the corresponding symbols.
  178. * (You may HAVE to do that if your compiler doesn't like null source files.)
  179. */
  180. /* Capability options common to encoder and decoder: */
  181. #define DCT_ISLOW_SUPPORTED /* accurate integer method */
  182. #define DCT_IFAST_SUPPORTED /* less accurate int method [legacy feature] */
  183. #define DCT_FLOAT_SUPPORTED /* floating-point method [legacy feature] */
  184. /* Encoder capability options: */
  185. #define C_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
  186. #define C_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/
  187. #define C_LOSSLESS_SUPPORTED /* Lossless JPEG? */
  188. #define ENTROPY_OPT_SUPPORTED /* Optimization of entropy coding parms? */
  189. /* Note: if you selected 12-bit data precision, it is dangerous to turn off
  190. * ENTROPY_OPT_SUPPORTED. The standard Huffman tables are only good for 8-bit
  191. * precision, so jchuff.c normally uses entropy optimization to compute
  192. * usable tables for higher precision. If you don't want to do optimization,
  193. * you'll have to supply different default Huffman tables.
  194. * The exact same statements apply for progressive and lossless JPEG:
  195. * the default tables don't work for progressive mode or lossless mode.
  196. * (This may get fixed, however.)
  197. */
  198. #define INPUT_SMOOTHING_SUPPORTED /* Input image smoothing option? */
  199. /* Decoder capability options: */
  200. #define D_MULTISCAN_FILES_SUPPORTED /* Multiple-scan JPEG files? */
  201. #define D_PROGRESSIVE_SUPPORTED /* Progressive JPEG? (Requires MULTISCAN)*/
  202. #define D_LOSSLESS_SUPPORTED /* Lossless JPEG? */
  203. #define SAVE_MARKERS_SUPPORTED /* jpeg_save_markers() needed? */
  204. #define BLOCK_SMOOTHING_SUPPORTED /* Block smoothing? (Progressive only) */
  205. #define IDCT_SCALING_SUPPORTED /* Output rescaling via IDCT? */
  206. #undef UPSAMPLE_SCALING_SUPPORTED /* Output rescaling at upsample stage? */
  207. #define UPSAMPLE_MERGING_SUPPORTED /* Fast path for sloppy upsampling? */
  208. #define QUANT_1PASS_SUPPORTED /* 1-pass color quantization? */
  209. #define QUANT_2PASS_SUPPORTED /* 2-pass color quantization? */
  210. /* more capability options later, no doubt */
  211. /*
  212. * The RGB_RED, RGB_GREEN, RGB_BLUE, and RGB_PIXELSIZE macros are a vestigial
  213. * feature of libjpeg. The idea was that, if an application developer needed
  214. * to compress from/decompress to a BGR/BGRX/RGBX/XBGR/XRGB buffer, they could
  215. * change these macros, rebuild libjpeg, and link their application statically
  216. * with it. In reality, few people ever did this, because there were some
  217. * severe restrictions involved (cjpeg and djpeg no longer worked properly,
  218. * compressing/decompressing RGB JPEGs no longer worked properly, and the color
  219. * quantizer wouldn't work with pixel sizes other than 3.) Furthermore, since
  220. * all of the O/S-supplied versions of libjpeg were built with the default
  221. * values of RGB_RED, RGB_GREEN, RGB_BLUE, and RGB_PIXELSIZE, many applications
  222. * have come to regard these values as immutable.
  223. *
  224. * The libjpeg-turbo colorspace extensions provide a much cleaner way of
  225. * compressing from/decompressing to buffers with arbitrary component orders
  226. * and pixel sizes. Thus, we do not support changing the values of RGB_RED,
  227. * RGB_GREEN, RGB_BLUE, or RGB_PIXELSIZE. In addition to the restrictions
  228. * listed above, changing these values will also break the SIMD extensions and
  229. * the regression tests.
  230. */
  231. #define RGB_RED 0 /* Offset of Red in an RGB scanline element */
  232. #define RGB_GREEN 1 /* Offset of Green */
  233. #define RGB_BLUE 2 /* Offset of Blue */
  234. #define RGB_PIXELSIZE 3 /* JSAMPLEs per RGB scanline element */
  235. #define JPEG_NUMCS 17
  236. #define EXT_RGB_RED 0
  237. #define EXT_RGB_GREEN 1
  238. #define EXT_RGB_BLUE 2
  239. #define EXT_RGB_PIXELSIZE 3
  240. #define EXT_RGBX_RED 0
  241. #define EXT_RGBX_GREEN 1
  242. #define EXT_RGBX_BLUE 2
  243. #define EXT_RGBX_PIXELSIZE 4
  244. #define EXT_BGR_RED 2
  245. #define EXT_BGR_GREEN 1
  246. #define EXT_BGR_BLUE 0
  247. #define EXT_BGR_PIXELSIZE 3
  248. #define EXT_BGRX_RED 2
  249. #define EXT_BGRX_GREEN 1
  250. #define EXT_BGRX_BLUE 0
  251. #define EXT_BGRX_PIXELSIZE 4
  252. #define EXT_XBGR_RED 3
  253. #define EXT_XBGR_GREEN 2
  254. #define EXT_XBGR_BLUE 1
  255. #define EXT_XBGR_PIXELSIZE 4
  256. #define EXT_XRGB_RED 1
  257. #define EXT_XRGB_GREEN 2
  258. #define EXT_XRGB_BLUE 3
  259. #define EXT_XRGB_PIXELSIZE 4
  260. static const int rgb_red[JPEG_NUMCS] = {
  261. -1, -1, RGB_RED, -1, -1, -1, EXT_RGB_RED, EXT_RGBX_RED,
  262. EXT_BGR_RED, EXT_BGRX_RED, EXT_XBGR_RED, EXT_XRGB_RED,
  263. EXT_RGBX_RED, EXT_BGRX_RED, EXT_XBGR_RED, EXT_XRGB_RED,
  264. -1
  265. };
  266. static const int rgb_green[JPEG_NUMCS] = {
  267. -1, -1, RGB_GREEN, -1, -1, -1, EXT_RGB_GREEN, EXT_RGBX_GREEN,
  268. EXT_BGR_GREEN, EXT_BGRX_GREEN, EXT_XBGR_GREEN, EXT_XRGB_GREEN,
  269. EXT_RGBX_GREEN, EXT_BGRX_GREEN, EXT_XBGR_GREEN, EXT_XRGB_GREEN,
  270. -1
  271. };
  272. static const int rgb_blue[JPEG_NUMCS] = {
  273. -1, -1, RGB_BLUE, -1, -1, -1, EXT_RGB_BLUE, EXT_RGBX_BLUE,
  274. EXT_BGR_BLUE, EXT_BGRX_BLUE, EXT_XBGR_BLUE, EXT_XRGB_BLUE,
  275. EXT_RGBX_BLUE, EXT_BGRX_BLUE, EXT_XBGR_BLUE, EXT_XRGB_BLUE,
  276. -1
  277. };
  278. static const int rgb_pixelsize[JPEG_NUMCS] = {
  279. -1, -1, RGB_PIXELSIZE, -1, -1, -1, EXT_RGB_PIXELSIZE, EXT_RGBX_PIXELSIZE,
  280. EXT_BGR_PIXELSIZE, EXT_BGRX_PIXELSIZE, EXT_XBGR_PIXELSIZE, EXT_XRGB_PIXELSIZE,
  281. EXT_RGBX_PIXELSIZE, EXT_BGRX_PIXELSIZE, EXT_XBGR_PIXELSIZE, EXT_XRGB_PIXELSIZE,
  282. -1
  283. };
  284. /* Definitions for speed-related optimizations. */
  285. /* On some machines (notably 68000 series) "int" is 32 bits, but multiplying
  286. * two 16-bit shorts is faster than multiplying two ints. Define MULTIPLIER
  287. * as short on such a machine. MULTIPLIER must be at least 16 bits wide.
  288. */
  289. #ifndef MULTIPLIER
  290. #ifndef WITH_SIMD
  291. #define MULTIPLIER int /* type for fastest integer multiply */
  292. #else
  293. #define MULTIPLIER short /* prefer 16-bit with SIMD for parellelism */
  294. #endif
  295. #endif
  296. /* FAST_FLOAT should be either float or double, whichever is done faster
  297. * by your compiler. (Note that this type is only used in the floating point
  298. * DCT routines, so it only matters if you've defined DCT_FLOAT_SUPPORTED.)
  299. */
  300. #ifndef FAST_FLOAT
  301. #define FAST_FLOAT float
  302. #endif
  303. #endif /* JPEG_INTERNAL_OPTIONS */