kc3-lang/libjpeg-turbo

Log

Author Commit Date CI Message
DRC 437a4993 2024-09-12T21:11:00 Merge branch 'main' into dev
DRC bcbca8b9 2024-09-12T20:55:39 Fuzz: Calc. xformed buf size based on dst. subsamp (oversight from b3f0abe377f2dd83396c9d0d4176f684c122af3f)
DRC 6f1fe2d1 2024-09-09T10:52:18 turbojpeg-jni.c: Fix int. conv. warnings w/ VC++
DRC e3e353fe 2024-09-06T20:30:03 tjunittest.c: Store/retrieve original buf size ... ... between iterations. (oversight from c519d7b67913e69b667f5fac49650f825e56218d)
DRC a2728582 2024-09-03T07:54:17 TurboJPEG: ICC profile support
DRC c6de7d87 2024-09-06T09:21:47 tjdecomp.c: Remove extraneous #defines
DRC c519d7b6 2024-09-05T11:10:44 Don't ignore JPEG buf size with TJPARAM_NOREALLOC Since the introduction of TJFLAG_NOREALLOC in libjpeg-turbo 1.2.x, the TurboJPEG C API documentation has (confusingly) stated that: - if the JPEG buffer pointer points to a pre-allocated buffer, then the JPEG buffer size must be specified, and - the JPEG buffer size should be specified if the JPEG buffer is pre-allocated to an arbitrary size. The documentation never explicitly stated that the JPEG buffer size should be specified if the JPEG buffer is pre-allocated to a worst-case size, but since focus does not imply exclusion, it also never explicitly stated the reverse. Furthermore, the documentation never stated that this was contingent upon TJPARAM_NOREALLOC/TJFLAG_NOREALLOC. However, effectively the compression and lossless transformation functions ignored the JPEG buffer size(s) passed to them, and assumed that the JPEG buffer(s) had been allocated to a worst-case size, if TJPARAM_NOREALLOC/TJFLAG_NOREALLOC was set. This behavior was an accidental and undocumented throwback to libjpeg-turbo 1.1.x, in which the tjCompress() function provided no way to specify the JPEG buffer size. It was always a bad idea for applications to rely upon that behavior (although our own TJBench application unfortunately did.) However, if such applications exist in the wild, the new behavior would constitute a breaking change, so it has been introduced only into libjpeg-turbo 3.1.x and only into TurboJPEG 3 API functions. The previous behavior has been retained when calling functions from the TurboJPEG 2.1.x API and prior versions. Did I mention that APIs are hard?
DRC 5f05c75a 2024-09-06T19:55:20 Merge branch 'main' into dev
DRC b3f0abe3 2024-09-06T10:23:02 TJ: Calc. xformed buf sizes based on dst. subsamp With respect to tj3Transform(), this addresses an oversight from bb1d540a807783a3db8b85bab2993d70b1330287. Note to self: A convenience function/method for computing the worst-case transformed JPEG size for a particular transform would be nice.
DRC 6d959170 2024-09-05T21:57:16 Minor TurboJPEG doc tweaks - When transforming, the worst-case JPEG buffer size depends on the subsampling level used in the destination image, since a grayscale transform might have been applied. - Parentheses Police
DRC e3dac188 2024-09-05T17:07:50 Merge branch 'main' into dev
DRC 2e40a687 2024-09-05T16:49:44 turbojpeg.c: Fix -Wsign-compare compiler warning (introduced by previous commit)
DRC 8db41dad 2024-09-05T15:15:08 Merge branch 'main' into dev
DRC 758e8a8e 2024-09-05T14:55:50 Java: Use Java-style method nomenclature :: is a C++ thing.
DRC fe1e555a 2024-09-05T14:45:53 tjbenchtest.in: Grammar Police
DRC bb1d540a 2024-09-05T12:00:04 TJ: Explicitly reject OOB lossless crop regions tj*Transform() relied upon the underlying transupp API to check the cropping region. However, transupp uses unsigned integers for the cropping region, whereas the tjregion structure uses signed integers. Thus, casting negative values from a tjregion structure produced very large unsigned values. In the case of the left and upper boundary, this was innocuous, because jtransform_request_workspace() rejected the values as being out of bounds. However, jtransform_request_workspace() did not always reject very large width and height values, because it supports expanding the destination image by specifying a cropping region larger than the source image. In certain cases, it allowed those values, and the libjpeg memory manager subsequently ran out of memory. NOTE: Prior to this commit, image expansion technically worked with tj*Transform() as long as the cropping width and height were valid and automatic JPEG buffer (re)allocation was used. However, that behavior is not a documented feature of the TurboJPEG API, nor do we have any way of testing it at the moment. Official support for image expansion can be added later, if there is sufficient demand for it. Similarly, this commit modifies tj3SetCroppingRegion() so that it explicitly checks for left boundary values exactly equal to the scaled image width and upper boundary values exactly equal to the scaled image height. If the specified cropping width or height was 0 (which is interpreted as {scaled image width} - {left boundary} or {scaled image height} - {upper boundary}), then such values caused a cropping width or height of 0 to be passed to the libjpeg API. In the case of the width, this was innocuous, because jpeg_crop_scanline() rejected the value. In the case of the height, however, this caused unexpected and hard-to-diagnose errors farther down the pipeline.
DRC e4c67aff 2024-09-04T12:06:42 TJBench: More argument consistification -copynone --> -copy none Add '-copy all', even though it's the default. -rgb, -bgr, -rgbx, -bgrx, -xbgr, -xrgb, -gray, -cmyk --> -pixelformat {rgb|bgr|rgbx|bgrx|xbgr|xrgb|gray|cmyk} (This is mainly so -gray won't interfere with -grayscale.) Fix an ArrayIndexOutOfBoundsException that occurred when passing -dct to the Java version without specifying the DCT algorithm (oversight from 24fbf64d31a0758c63bcc27cf5d92fc5611717d0.)
DRC d43ed7a1 2024-09-04T08:38:13 Merge branch 'main' into dev
DRC dd8b15ee 2024-09-04T07:52:51 tjbenchtest.in: Formatting tweak (oversight from a5689cd45ba290bcf698a172d24c74aada8c5595)
DRC e7e9344d 2024-09-04T06:58:48 TJ: Honor TJ*OPT_COPYNONE for individual xforms jcopy_markers_execute() has historically ignored its option argument, which is OK for jpegtran, but tj*Transform() needs to be able to save a set of markers from the source image and write a subset of those markers to each destination image. Without that ability, the function effectively behaved as if TJ*OPT_COPYNONE was not specified unless all transforms specified it.
DRC 5550c80f 2024-09-03T17:20:10 Doc: "compress operation"="compression operation" (consistification)
DRC 939f3814 2024-09-03T15:35:25 Test: Replace test2.icc with test3.icc test3.icc is smaller, and it is also an RGB profile rather than a CMYK profile. (test1.icc is a CMYK profile.)
DRC a5689cd4 2024-09-03T15:26:52 Test: Replace big_tree8.bmp and big_building16.ppm These images were only used with tjbenchtest and tjexampletest, but I was concerned about introducing additional licensing provisions into the libjpeg-turbo source tree. Thus, this commit replaces them with images that I own and can thus make available under the libjpeg-turbo licenses with no additional provisions.
DRC a4d19a45 2024-09-03T09:27:04 Merge branch 'main' into dev
DRC 37851a32 2024-09-01T15:07:27 TurboJPEG: Add restart markers when transforming
DRC f5f8f5aa 2024-09-03T08:59:37 TJ: Reorder functions to improve readability Put all general functions at the top of the list, and ensure that all functions are defined before they are mentioned. Also consistify the function ordering between turbojpeg.h and turbojpeg.c
DRC a66398fe 2024-09-02T08:52:42 Move md5cmp/md5sum into ${CMAKE_BINARY_DIR}/test
DRC f0bc90d9 2024-09-02T08:44:49 Test: Move test logs into ${CMAKE_BINARY_DIR}/test
DRC df04d26a 2024-09-01T16:24:19 Test: Clean up TurboJPEG example test logs
DRC f464728a 2024-09-02T08:00:08 ChangeLog.md: Minor wordsmithing
DRC debf57bc 2024-09-01T10:59:35 TJBench: Improve usage screen readability
DRC fad61007 2024-08-20T18:52:53 Replace TJExample with IJG workalike programs
DRC 6d9f1f81 2024-09-01T14:04:20 Merge branch 'main' into dev
DRC 843d04d9 2024-09-01T11:52:01 CI: Run regression tests in parallel
DRC 797c6ccd 2024-09-01T11:23:31 Doc: Further clarify MCU definition
DRC 7f45663d 2024-09-01T10:05:57 Merge branch 'main' into dev
DRC 7ec70ee8 2024-09-01T09:59:10 testclean.cmake: Remove croptest.log
DRC 174672af 2024-09-01T09:55:52 jquant1.c: Formatting tweak Extending the Bayer matrix past Column 80 seems like a lesser readability sin than not putting a space after each comma, especially since we had to explicitly whitelist the file in checkstyle.
DRC 3e303e72 2024-08-31T18:38:05 TJBench: Allow British spellings in arguments
DRC 9b119896 2024-08-31T17:46:37 Move test scripts into test/
DRC 64567381 2024-08-31T17:31:02 Merge branch 'main' into dev
DRC eb753630 2024-08-31T16:50:08 Update URLs - Eliminate unnecessary "www." - Use HTTPS. - Update Java, MSYS, tdm-gcc, and NSIS URLs. - Update URL and title of Agner Fog's assembly language optimization manual. - Remove extraneous information about MASM and Borland Turbo Assembler and outdated NASM URLs from the x86 assembly headers, and mention Yasm.
DRC 0fb8fbe1 2024-08-31T15:39:34 CMakeLists.txt: libjpeg-turbo "2.2.x" = "3.0.x"
DRC 8d76e4e5 2024-08-31T15:33:55 Doc: "EXIF" = "Exif"
DRC 9983840e 2024-08-31T12:41:13 TJ/xform: Check crop region against dest. image Lossless cropping is performed after other lossless transform operations, so the cropping region must be specified relative to the destination image dimensions and level of chrominance subsampling, not the source image dimensions and level of chrominance subsampling. More specifically, if the lossless transform operation swaps the X and Y axes, or if the image is converted to grayscale, then that changes the cropping region requirements.
DRC 8456d2b9 2024-08-30T10:50:13 Doc: "MCU block" = "iMCU" or "MCU" The JPEG-1 spec never uses the term "MCU block". That term is rarely used in other literature to describe the equivalent of an MCU in an interleaved JPEG image, but the libjpeg documentation uses "iMCU" to describe the same thing. "iMCU" is a better term, since the equivalent of an interleaved MCU can contain multiple DCT blocks (or samples in lossless mode) that are only grouped together if the image is interleaved. In the case of restart markers, "MCU block" was used in the libjpeg documentation instead of "MCU", but "MCU" is more accurate and less confusing. (The restart interval is literally in MCUs, where one MCU is one data unit in a non-interleaved JPEG image and multiple data units in a multi-component interleaved JPEG image.) In the case of 9b704f96b2dccc54363ad7a2fe8e378fc1a2893b, the issue was actually with progressive JPEG images exactly two DCT blocks wide, not two MCU blocks wide. This commit also defines "MCU" and "MCU row" in the description of the various restart marker options/parameters. Although an MCU row is technically always a row of samples in lossless mode, "sample row" was confusing, since it is used in other places to describe a row of samples for a single component (whereas an MCU row in a typical lossless JPEG image consists of a row of interleaved samples for all components.)
DRC 2858783d 2024-08-28T18:16:18 JNI: Set srcX, srcY = 0 in loadSourceImage() (oversight from 79b8d65f0f86af77afc5979ecc104b1fbc97c82d)
DRC 4ceaf8b7 2024-08-26T10:31:19 TJBench: Allow 'X' in crop spec (for consistency with djpeg and jpegtran)
DRC fd9b21b6 2024-08-28T18:58:21 Merge branch 'main' into dev
DRC 5cf79606 2024-08-28T18:36:37 Undocument TJ*PARAM_RESTARTBLOCKS for lossless TJ*PARAM_RESTARTBLOCKS technically works with lossless compression, but it is not useful, since the value must be equal to the number of samples in a row. (In other words, it is no different than TJ*PARAM_RESTARTINROWS, except that it requires the user to do more math.)
DRC d6207971 2024-08-28T18:00:14 TJBench: Don't override subsamp until args parsed Otherwise, passing -subsamp after -lossless might cause the worst-case JPEG buffer size to be too small.
DRC c72bbd9c 2024-08-26T18:00:23 tjbench.c: (Re)allow unreduced scaling factors For reasons I can't recall, fc01f4673b71c0b833c59c21e8c4478a9c4bcf21 (the TurboJPEG 3 API overhaul) changed the C version of TJBench, but not the Java version, so that it requires an exact scaling factor match (as opposed to allowing unreduced scaling factors, as djpeg does and prior versions of TJBench did.) That might have been temporary testing code that was accidentally committed.
DRC 6a9565ce 2024-08-26T16:45:41 Merge branch 'main' into dev
DRC 35199878 2024-08-26T16:35:30 TurboJPEG doc: Fix incorrect/confusing parentheses
DRC 00a261c4 2024-08-26T16:31:02 tjbench.c: Code formatting tweak
DRC 4851cbe4 2024-08-26T12:14:20 djpeg/jpeg_crop_scanline(): Disallow crop vals < 0 Because the crop spec was parsed using unsigned 32-bit integers, negative numbers were interpreted as values ~= UINT_MAX (4,294,967,295). This had the following ramifications: - If the cropping region width was negative and the adjusted width + the adjusted left boundary was greater than 0, then the 32-bit unsigned integer bounds checks in djpeg and jpeg_crop_scanline() overflowed and failed to detect the out-of-bounds width, jpeg_crop_scanline() set cinfo->output_width to a value ~= UINT_MAX, and a buffer overrun and subsequent segfault occurred in the upsampling or color conversion routine. The segfault occurred in the body of jpeg_skip_scanlines() --> read_and_discard_scanlines() if the cropping region upper boundary was greater than 0 and the JPEG image used chrominance subsampling and in the body of jpeg_read_scanlines() otherwise. - If the cropping region width was negative and the adjusted width + the adjusted left boundary was 0, then a zero-width output image was generated. - If the cropping region left boundary was negative, then an output image with bogus data was generated. This commit modifies djpeg and jpeg_crop_scanline() so that the aforementioned bounds checks use 64-bit unsigned integers, thus guarding against overflow. It similarly modifies jpeg_skip_scanlines(). In the case of jpeg_skip_scanlines(), the issue was not reproducible with djpeg, but passing a negative number of lines to jpeg_skip_scanlines() caused a similar overflow if the number of lines + cinfo->output_scanline was greater than 0. That caused jpeg_skip_scanlines() to read past the end of the JPEG image, throw a warning ("Corrupt JPEG data: premature end of data segment"), and fail to return unless warnings were treated as fatal. Also, djpeg now parses the crop spec using signed integers and checks for negative values.
DRC 548f7324 2024-08-26T10:14:11 TJBench: Usage screen tweak Indicate that -maxmemory and -maxpixels take an integer argument.
DRC de4bbac5 2024-08-23T12:48:01 TJCompressor.compress(): Fix lossls buf size calc
DRC 4eedf508 2024-08-23T11:04:02 appveyor.yml: Require Java 8 or later Public support for Java 6 ended in April 2013, and extended support for it ended in October 2018. Public support for Java 7 ended in July 2015, and extended support for it ended in July 2022. Technically speaking, the only code that requires Java 8 at the moment is in TJUnitTest.java (introduced in 79b8d65f0f86af77afc5979ecc104b1fbc97c82d.) It is possible to refactor that code to be compatible with Java 6, but there are much better uses of our project's limited resources than supporting long-dead platforms.
DRC acbb4937 2024-08-22T18:31:41 JNI: Fix Windows CI build failure (introduced by previous commit) jint and int are technically the same thing, but certain compilers are a bit pedantic.
DRC 79b8d65f 2024-08-22T13:50:32 Java: Add official packed-pixel image I/O methods
DRC 8088dfc0 2024-08-22T14:32:14 TJUnitTest.java: Use boolean ret vals for check*()
DRC b577504f 2024-08-22T13:59:35 JNI: Remove deprecated constants (oversight from 07378442355e72a642e674d4fd901f64cc8291bf)
DRC e2932b68 2024-08-22T14:00:37 ChangeLog.md: Formatting tweak (oversight from d6ce7df3520a8ce83b44e51b7b557323cf0a184e)
DRC a98bc9a5 2024-08-22T17:14:37 Merge branch 'main' into dev
DRC 0acb0844 2024-08-22T16:55:55 JNI: Fix *Image() array size issues w/ align != 1 + check for mismatch between C and Java APIs in *saveImage().
DRC d44fc54f 2024-08-21T15:00:58 Java: Unset srcBuf12/16 with BufferedImage/YUV src Due to an oversight in the multi-precision feature, TJCompressor.srcBuf12 and TJCompressor.srcBuf16 were not set to null in TJCompressor.setSourceImage(YUVImage) or TJCompressor.setSourceImage(BufferedImage, ...). Thus, if an application set a 12-bit or 16-bit packed-pixel buffer as the source image then set a BufferedImage with integer pixels as the source image, TJCompress.compress() would compress from the 12-bit or 16-bit packed-pixel buffer instead of the BufferedImage. The odds of an application actually doing that are very slim, however.
DRC ecf7c8b1 2024-08-21T13:09:53 Merge branch 'main' into dev
DRC 24fbf64d 2024-08-21T11:24:44 TJBench: Consistify args with djpeg -fastdct --> -dct fast -fastupsample --> -nosmooth
DRC d6ce7df3 2024-08-20T15:22:07 TJBench: Consistify args with cjpeg/djpeg/jpegtran -hflip --> -flip horizontal -limitscans --> -maxscans N -rot90 --> -rotate 90 -rot180 --> -rotate 180 -rot270 --> -rotate 270 -stoponwarning --> -strict -vflip --> -flip vertical
DRC ab203704 2024-08-20T08:01:50 TJBench: Allow abbreviated command-line options ... using the same matching algorithm as cjpeg/djpeg/jpegtran and, where possible, the same abbreviations: -a for -arithmetic -b for -bmp -cr for -crop -g for -grayscale -l for -lossless -max for -maxmemory -o for -optimize -pre for -precision -p for -progressive -r for -restart -s for -scale -t for -transpose -transv for -transverse
DRC 07378442 2024-08-19T14:13:03 Java: Remove deprecated constants and methods
DRC 8c2e7306 2024-08-21T13:03:41 Java doc: Minor formatting tweak
DRC d55a051e 2024-08-20T15:11:34 Merge branch 'main' into dev
DRC 49f1b580 2024-08-20T12:57:37 TJBench.java: Explicitly set restartIntervalBlocks This is just a readability thing. Java initializes integer fields to 0 by default.
DRC a9723f8a 2024-08-19T16:18:37 cjpeg/djpeg/jpegtran: Restore jpeg-6b arg abbrevs There are two approaches to handling abbreviated command-line options: 1. If a new option is introduced that begins with the same letters as an existing option, require a longer abbreviation for the existing option in order to ensure that abbreviations are always unique. 2. Require a unique abbreviation only for new options, and match all non-unique abbreviations with existing options, thus maintaining backward compatibility. keymatch() supports either approach, and Tom Lane historically seemed to prefer Approach 2, whereas both approaches have been applied inconsistently in the years since. This commit consistently applies Approach 2. More specific notes: We unnecessarily required 'cjpeg -progressive' to be abbreviated as 'cjpeg -pro' rather than 'cjpeg -p' when the -precision option was introduced in libjpeg-turbo 3.0 beta. The IJG unnecessarily required 'cjpeg -scans' to be abbreviated as 'cjpeg -scan' rather than 'cjpeg -sc' when the -scale option was introduced in jpeg-7. We even more unnecessarily adopted that requirement, even though we never adopted the -scale option. We unnecessarily required 'djpeg -scale' to be abbreviated as 'djpeg -sc' rather than 'djpeg -s' when the -skip option was introduced in libjpeg-turbo 1.5 beta. The IJG unnecessarily required 'jpegtran -copy' to be abbreviated as 'jpegtran -co' rather than 'jpegtran -c' when the -crop option was introduced in jpeg-7. The IJG unnecessarily required 'jpegtran -progressive' to be abbreviated as 'jpegtran -pr' rather than 'jpegtran -p' when the -perfect option was introduced in jpeg-7.
DRC beeafa42 2024-08-19T10:32:31 Merge branch 'main' into dev
DRC 562ad761 2024-08-19T10:06:59 OSS-Fuzz: More MSan fixes We need to use tj3Alloc() (which, when ZERO_BUFFERS is defined, calls calloc() instead of malloc()) to allocate all destination buffers. Otherwise, if the compression/decompression/transform operation fails, then the buffer checksum (which is computed to prevent the compiler from optimizing out the whole test, since the destination buffer is never used otherwise) will depend upon values in the destination buffer that were never written, and MSan will complain.
DRC d3224eec 2024-08-16T12:19:30 Merge branch 'main' into dev
DRC 488d42a8 2024-08-16T12:12:09 OSS-Fuzz: Define ZERO_BUFFERS for MSan build ... and use tj3Alloc() to allocate compression/transformation destination buffers.
DRC 26d978b6 2024-08-16T11:58:02 Merge branch 'main' into dev
DRC 0c23b0ad 2024-08-14T09:21:54 Various doc tweaks - "Optimized baseline entropy coding" = "Huffman table optimization" "Optimized baseline entropy coding" was meant to emphasize that the feature is only useful when generating baseline (single-scan lossy 8-bit-per-sample Huffman-coded) JPEG images, because it is automatically enabled when generating Huffman-coded progressive (multi-scan), 12-bit-per-sample, and lossless JPEG images. However, Huffman table optimization isn't actually an integral part of those non-baseline modes. You can forego Huffman table optimization with 12-bit data precision if you supply your own Huffman tables. The spec doesn't require it with progressive or lossless mode, either, although our implementation does. Furthermore, "baseline" describes more than just the type of entropy coding used. It was incorrect to say that optimized "baseline" entropy coding is automatically enabled for Huffman-coded progressive, 12-bit-per-sample, and lossless JPEG images, since those are clearly not baseline images. - "Progressive entropy coding" = "Progressive JPEG" "Progressive" describes more than just the type of entropy coding used. (In fact, both Huffman-coded and arithmetic-coded images can be progressive.) - Mention that TJPARAM_OPTIMIZE/TJ.PARAM_OPTIMIZE can be used with lossless transformation as well. - General wordsmithing - Formatting tweaks
DRC b4336c3a 2024-08-13T15:41:54 Work around valgrind/MSan SIMD false positives Referring to https://sourceforge.net/p/libjpeg-turbo/bugs/48, https://sourceforge.net/p/libjpeg-turbo/bugs/82, #15, #238, #253, and #619, valgrind and MSan have failed to properly detect data initialization by libjpeg-turbo's x86 SIMD extensions for the entire 14 years that libjpeg-turbo has been a project, resulting in false positives unless libjpeg-turbo is built with WITH_SIMD=0 or run with JSIMD_FORCENONE=1. This commit introduces a new C preprocessor macro (ZERO_BUFFERS) that, if set, causes libjpeg-turbo to zero certain buffers in order to work around the specific valgrind/MSan test failures caused by the aforementioned false positives. This allows us to more closely approximate the production configuration of libjpeg-turbo when testing with valgrind or MSan. Closes #781
DRC 4c0e5642 2024-08-02T09:09:34 Merge branch 'main' into dev
DRC 8db03126 2024-08-02T08:45:36 example.c: Write correct dimensions to PPM header The dimensions in the PPM header of the output file generated by 'example decompress' were always 640 x 480, regardless of the size of the JPEG image being decompressed. Our regression tests (which this commit also fixes) missed the bug because they decompressed the 640 x 480 image generated by 'example compress'. Fixes #778
DRC 44c4cacf 2024-07-10T11:59:34 OSS-Fuzz: Test 2-bit through 15-bit data precision
DRC 27f09d26 2024-07-09T17:22:40 Merge branch 'main' into dev
DRC 0566d51e 2024-07-09T17:18:53 GitHub Actions: Specify Monterey for macOS build The Big Sur hosted runner is no longer available.
DRC a27d9629 2024-07-04T10:05:50 Merge branch 'main' into dev
DRC e287a357 2024-07-04T10:03:50 Build: Put gastest.o in ${CMAKE_BINARY_DIR}/simd Closes #776
DRC 6ec8e41f 2024-06-13T11:52:13 Handle lossless JPEG images w/2-15 bits per sample Closes #768 Closes #769
DRC 3290711d 2024-06-22T17:45:31 cjpeg: Only support 8-bit precision w/ GIF input Creating 12-bit-per-sample JPEG images from GIF input images was a useful testing feature when the data precision was a compile-time setting. However, now that the data precision is a runtime setting, it doesn't make sense for cjpeg to allow data precisions other than 8-bit with GIF input images. GIF images are limited to 256 colors from a palette of 8-bit-per-component RGB values, so they cannot take advantage of the additional gamut afforded by higher data precisions.
DRC ed79114a 2024-06-18T13:06:30 TJBench: Test end-to-end grayscale comp./decomp. Because the TurboJPEG API originated in VirtualGL and TurboVNC as a means of compressing from/decompressing to extended RGB framebuffers, its earliest incarnations did not handle grayscale packed-pixel images. Thus, TJBench has always converted the input image (even if it is grayscale) to an extended RGB source buffer prior to compression, and it has always decompressed JPEG images (even if they are grayscale) into an extended RGB destination buffer. That allows TJBench to benchmark the RGB-to-grayscale and grayscale-to-RGB color conversion paths used by VirtualGL and TurboVNC when grayscale subsampling (AKA the grayscale JPEG colorspace) is selected. However, more recent versions of the TurboJPEG API handle grayscale packed-pixel images, so it is beneficial to allow TJBench to benchmark the end-to-end grayscale compression and decompression paths. This commit accomplishes that by adding a new command-line option (-gray) that causes TJBench to use a grayscale source buffer (which only works if the input image is PGM or grayscale BMP), to decompress JPEG images (even if they are full-color) into a grayscale destination buffer, and to save output images in PGM or grayscale BMP format.
DRC 55bcad88 2024-06-24T22:16:07 Merge branch 'main' into dev
DRC 51d021bf 2024-06-24T12:17:22 TurboJPEG: Fix 12-bit-per-sample arith-coded compr (Regression introduced by 7bb958b732e6b4f261595e2d1527d46964fe3aed) Because of 7bb958b732e6b4f261595e2d1527d46964fe3aed, the TurboJPEG compression and encoding functions no longer transfer the value of TJPARAM_OPTIMIZE into cinfo->data_precision unless the data precision is 8. The intent of that was to prevent using_std_huff_tables() from being called more than once when reusing the same compressor object to generate multiple 12-bit-per-sample JPEG images. However, because cinfo->optimize_coding is always set to TRUE by jpeg_set_defaults() if the data precision is 12, calling applications that use 12-bit data precision had to unset cinfo->optimize_coding if they set cinfo->arith_code after calling jpeg_set_defaults(). Because of 7bb958b732e6b4f261595e2d1527d46964fe3aed, the TurboJPEG API stopped doing that except with 8-bit data precision. Thus, attempting to generate a 12-bit-per-sample arithmetic-coded lossy JPEG image using the TurboJPEG API failed with "Requested features are incompatible." Since the compressor will always fail if cinfo->arith_code and cinfo->optimize_coding are both set, and since cinfo->optimize_coding has no relevance for arithmetic coding, the most robust and user-proof solution is for jinit_c_master_control() to set cinfo->optimize_coding to FALSE if cinfo->arith_code is TRUE. This commit also: - modifies TJBench so that it no longer reports that it is using optimized baseline entropy coding in modes where that setting is irrelevant, - amends the cjpeg documentation to clarify that -optimize is implied when specifying -progressive or '-precision 12' without -arithmetic, and - prevents jpeg_set_defaults() from uselessly checking the value of cinfo->arith_code immediately after it has been set to FALSE.
DRC bb3ab531 2024-06-19T17:27:01 cjpeg: Don't enable lossless until precision known jpeg_enable_lossless() checks the point transform value against the data precision, so we need to defer calling jpeg_enable_lossless() until after all command-line options have been parsed.
DRC a8aaaf5d 2024-06-21T10:58:17 cjpeg -verbose: Print PBMPLUS input file precision This gives the user a hint as to whether converting the input file into a JPEG file with a particular data precision will result in a loss of precision. Also modify usage.txt and the cjpeg man page to warn the user about that possibility.
DRC 94c64ead 2024-06-17T20:27:57 Various doc tweaks - "bits per component" = "bits per sample" Describing the data precision of a JPEG image using "bits per component" is technically correct, but "bits per sample" is the terminology that the JPEG-1 spec uses. Also, "bits per component" is more commonly used to describe the precision of packed-pixel formats (as opposed to "bits per pixel") rather than planar formats, in which all components are grouped together. - Unmention legacy display technologies. Colormapped and monochrome displays aren't a thing anymore, and even when they were still a thing, it was possible to display full-color images to them. In 1991, when JPEG decompression time was measured in minutes per megapixel, it made sense to keep a decompressed copy of JPEG images on disk, in a format that could be displayed without further color conversion (since color conversion was slow and memory-intensive.) In 2024, JPEG decompression time is measured in milliseconds per megapixel, and color conversion is even faster. Thus, JPEG images can be decompressed, displayed, and color-converted (if necessary) "on the fly" at speeds too fast for human vision to perceive. (In fact, your TV performs much more complicated decompression algorithms at least 60 times per second.) - Document that color quantization (and associated features), GIF input/output, Targa input/output, and OS/2 BMP input/output are legacy features. Legacy status doesn't necessarily mean that the features are deprecated. Rather, it is meant to discourage users from using features that may be of little or no benefit on modern machines (such as low-quality modes that had significant performance advantages in the early 1990s but no longer do) and that are maintained on a break/fix basis only. - General wordsmithing, grammar/punctuation policing, and formatting tweaks - Clarify which data precisions each cjpeg input format and each djpeg output format supports. - cjpeg.1: Remove unnecessary and impolitic statement about the -targa switch. - Adjust or remove performance claims to reflect the fact that: * On modern machines, the djpeg "-fast" switch has a negligible effect on performance. * There is a measurable difference between the performance of Floyd- Steinberg dithering and no dithering, but it is not likely perceptible to most users. * There is a measurable difference between the performance of 1-pass and 2-pass color quantization, but it is not likely perceptible to most users. * There is a measurable difference between the performance of full-color and grayscale output when decompressing a full-color JPEG image, but it is not likely perceptible to most users. * IDCT scaling does not necessarily improve performance. (It generally does if the scaling factor is <= 1/2 and generally doesn't if the scaling factor is > 1/2, at least on my machine. The performance claim made in jpeg-6b was probably invalidated when we merged the additional scaling factors from jpeg-7.) - Clarify which djpeg switches/output formats cannot be used when decompressing lossless JPEG images. - Remove djpeg hints, since those involve quality vs. speed tradeoffs that are no longer relevant for modern machines. - Remove documentation regarding using color quantization with 16-bit data precision. (Color quantization requires lossy mode.) - Java: Fix typos in TJDecompressor.decompress12() and TJDecompressor.decompress16() documentation. - jpegtran.1: Fix truncated paragraph In a man page, a single quote at the start of a line is interpreted as a macro. Closes #775 - libjpeg.txt: * Mention J16SAMPLE data type (oversight.) * Remove statement about extending jdcolor.c. (libjpeg-turbo is not quite as DIY as libjpeg once was.) * Remove paragraph about tweaking the various typedefs in jmorecfg.h. It is no longer relevant for modern machines. * Remove caveat regarding systems with ints less than 16 bits wide. (ANSI/ISO C requires an int to be at least 16 bits wide, and libjpeg-turbo has never supported non-ANSI compilers.) - usage.txt: * Add copyright header. * Document cjpeg -icc, -memdst, -report, -strict, and -version switches. * Document djpeg -icc, -maxscans, -memsrc, -report, -skip, -crop, -strict, and -version switches. * Document jpegtran -icc, -maxscans, -report, -strict, and -version switches.
DRC 2c5312fd 2024-06-13T21:16:20 cderror.h: Always include all img I/O err messages The 8-bit-per-sample image I/O modules have always been built with BMP, GIF, PBMPLUS, and Targa support, and the 12-bit-per-sample image I/O modules have always been built with only GIF and PBMPLUS support. In libjpeg-turbo 2.1.x and prior, cjpeg and djpeg were built with the same image format support as the image I/O modules. However, because of the multi-precision feature introduced in libjpeg-turbo 3.0.x, cjpeg and djpeg are now always built with support for all image formats. Thus, the error message table compiled into cjpeg and djpeg was a superset of the error message table compiled into the 12-bit-per-sample and 16-bit-per-sample image I/O modules. If, for example, the 12-bit-per-sample PPM writer threw JERR_PPM_COLORSPACE (== 15, because it was built with only GIF and PBMPLUS support), then djpeg interpreted that as JERR_GIF_COLORSPACE (== 15, because it was built with support for all image formats.) There was no chance of a buffer overrun, since the error message table lookup was performed against the table compiled into cjpeg and djpeg, which contained all possible entries. However, this issue caused an incorrect error message to be displayed by cjpeg or djpeg if a 12-bit-per-sample or 16-bit-per-sample image I/O module threw an error. This commit simply removes the *_SUPPORTED #ifdefs from cderror.h so that all image I/O error messages are always included in every instance of the image I/O error message table. Note that a similar issue could have also occurred with the 12-bit-per-sample and 16-bit-per-sample TurboJPEG image I/O functions, since the 12-bit-per-sample and 16-bit-per-sample image I/O modules supporting those functions are built with only PBMPLUS support whereas the library as a whole is built with BMP and PBMPLUS support.
DRC 095e62b6 2024-05-29T10:16:05 Merge branch 'main' into dev
kmx.io     mail     discord kmxgit v0.4.0