1994-09-24 04:00:00 +04:00
|
|
|
/*
|
|
|
|
|
* djpeg.c
|
|
|
|
|
*
|
2012-12-31 06:52:30 +04:00
|
|
|
* This file was part of the Independent JPEG Group's software:
|
1998-03-27 03:00:00 +03:00
|
|
|
* Copyright (C) 1991-1997, Thomas G. Lane.
|
2020-10-27 21:28:56 +03:00
|
|
|
* Modified 2013-2019 by Guido Vollbeding.
|
2013-09-28 07:23:49 +04:00
|
|
|
* libjpeg-turbo Modifications:
|
2022-01-06 21:08:46 +03:00
|
|
|
* Copyright (C) 2010-2011, 2013-2017, 2019-2020, 2022, D. R. Commander.
|
2015-06-25 06:44:36 +03:00
|
|
|
* Copyright (C) 2015, Google, Inc.
|
2015-10-10 18:25:46 +03:00
|
|
|
* For conditions of distribution and use, see the accompanying README.ijg
|
|
|
|
|
* file.
|
1994-09-24 04:00:00 +04:00
|
|
|
*
|
|
|
|
|
* This file contains a command-line user interface for the JPEG decompressor.
|
|
|
|
|
* It should work on any system with Unix- or MS-DOS-style command lines.
|
|
|
|
|
*
|
|
|
|
|
* Two different command line styles are permitted, depending on the
|
|
|
|
|
* compile-time switch TWO_FILE_COMMANDLINE:
|
2014-05-09 22:00:32 +04:00
|
|
|
* djpeg [options] inputfile outputfile
|
|
|
|
|
* djpeg [options] [inputfile]
|
1994-09-24 04:00:00 +04:00
|
|
|
* In the second style, output is always to standard output, which you'd
|
|
|
|
|
* normally redirect to a file or pipe to some other program. Input is
|
|
|
|
|
* either from a named file or from standard input (typically redirected).
|
|
|
|
|
* The second style is convenient on Unix but is unhelpful on systems that
|
|
|
|
|
* don't support pipes. Also, you MUST use the first style if your system
|
|
|
|
|
* doesn't do binary I/O to stdin/stdout.
|
|
|
|
|
* To simplify script writing, the "-outfile" switch is provided. The syntax
|
2014-05-09 22:00:32 +04:00
|
|
|
* djpeg [options] -outfile outputfile inputfile
|
1994-09-24 04:00:00 +04:00
|
|
|
* works regardless of which command line style is used.
|
|
|
|
|
*/
|
|
|
|
|
|
MSVC: Eliminate C4996 warnings in API libs
The primary purpose of this is to encourage adoption of libjpeg-turbo in
downstream Windows projects that forbid the use of "deprecated"
functions. libjpeg-turbo's usage of those functions was not actually
unsafe, because:
- libjpeg-turbo always checks the return value of fopen() and ensures
that a NULL filename can never be passed to it.
- libjpeg-turbo always checks the return value of getenv() and never
passes a NULL argument to it.
- The sprintf() calls in format_message() (jerror.c) could never
overflow the destination string buffer or leave it unterminated as
long as the buffer was at least JMSG_LENGTH_MAX bytes in length, as
instructed. (Regardless, this commit replaces those calls with
snprintf() calls.)
- libjpeg-turbo never uses sscanf() to read strings or multi-byte
character arrays.
- Because of b7d6e84d6a9283dc2bc50ef9fcaadc0cdeb25c9f, wrjpgcom
explicitly checks the bounds of the source and destination strings
before calling strcat() and strcpy().
- libjpeg-turbo always ensures that the destination string is
terminated when using strncpy().
(548490fe5e2aa31cb00f6602d5a478b068b99682 made this explicit.)
Regarding thread safety:
Technically speaking, getenv() is not thread-safe, because the returned
pointer may be invalidated if another thread sets the same environment
variable between the time that the first thread calls getenv() and the
time that that thread uses the return value. In practice, however, this
could only occur with libjpeg-turbo if:
(1) A multithreaded calling application used the deprecated and
undocumented TJFLAG_FORCEMMX/TJFLAG_FORCESSE/TJFLAG_FORCESSE2 flags in
the TurboJPEG API or set one of the corresponding environment variables
(which are only intended for testing purposes.) Since the TurboJPEG API
library only ever passed string constants to putenv(), the only inherent
risk (i.e. the only risk introduced by the library and not the calling
application) was that the SIMD extensions may have read an incorrect
value from one of the aforementioned environment variables.
or
(2) A multithreaded calling application modified the value of the
JPEGMEM environment variable in one thread while another thread was
reading the value of that environment variable (in the body of
jpeg_create_compress() or jpeg_create_decompress().) Given that the
libjpeg API provides a thread-safe way for applications to modify the
default memory limit without using the JPEGMEM environment variable,
direct modification of that environment variable by calling applications
is not supported.
Microsoft's implementation of getenv_s() does not claim to be
thread-safe either, so this commit uses getenv_s() solely to mollify
Visual Studio. New inline functions and macros (GETENV_S() and
PUTENV_S) wrap getenv_s()/_putenv_s() when building for Visual Studio
and getenv()/setenv() otherwise, but GETENV_S()/PUTENV_S() provide no
advantages over getenv()/setenv() other than parameter validation. They
are implemented solely for convenience.
Technically speaking, strerror() is not thread-safe, because the
returned pointer may be invalidated if another thread changes the locale
and/or calls strerror() between the time that the first thread calls
strerror() and the time that that thread uses the return value. In
practice, however, this could only occur with libjpeg-turbo if a
multithreaded calling application encountered a file I/O error in
tjLoadImage() or tjSaveImage(). Since both of those functions
immediately copy the string returned from strerror() into a thread-local
buffer, the risk is minimal, and the worst case would involve an
incorrect error string being reported to the calling application.
Regardless, this commit uses strerror_s() in the TurboJPEG API library
when building for Visual Studio. Note that strerror_r() could have been
used on Un*x systems, but it would have been necessary to handle both
the POSIX and GNU implementations of that function and perform
widespread compatibility testing. Such is left as an exercise for
another day.
Fixes #568
2022-02-10 20:33:49 +03:00
|
|
|
#ifdef _MSC_VER
|
|
|
|
|
#define _CRT_SECURE_NO_DEPRECATE
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-05-09 22:00:32 +04:00
|
|
|
#include "cdjpeg.h" /* Common decls for cjpeg/djpeg applications */
|
|
|
|
|
#include "jversion.h" /* for version message */
|
2014-04-20 13:17:11 +04:00
|
|
|
#include "jconfigint.h"
|
1994-09-24 04:00:00 +04:00
|
|
|
|
2014-05-09 22:00:32 +04:00
|
|
|
#include <ctype.h> /* to declare isprint() */
|
1994-09-24 04:00:00 +04:00
|
|
|
|
|
|
|
|
|
1994-12-07 03:00:00 +03:00
|
|
|
/* Create the add-on message string table. */
|
|
|
|
|
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
#define JMESSAGE(code, string) string,
|
1994-12-07 03:00:00 +03:00
|
|
|
|
|
|
|
|
static const char * const cdjpeg_message_table[] = {
|
|
|
|
|
#include "cderror.h"
|
|
|
|
|
NULL
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
1994-09-24 04:00:00 +04:00
|
|
|
/*
|
|
|
|
|
* This list defines the known output image formats
|
|
|
|
|
* (not all of which need be supported by a given version).
|
|
|
|
|
* You can change the default output format by defining DEFAULT_FMT;
|
|
|
|
|
* indeed, you had better do so if you undefine PPM_SUPPORTED.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
typedef enum {
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
FMT_BMP, /* BMP format (Windows flavor) */
|
2020-10-27 21:28:56 +03:00
|
|
|
FMT_GIF, /* GIF format (LZW-compressed) */
|
|
|
|
|
FMT_GIF0, /* GIF format (uncompressed) */
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
FMT_OS2, /* BMP format (OS/2 flavor) */
|
|
|
|
|
FMT_PPM, /* PPM/PGM (PBMPLUS formats) */
|
|
|
|
|
FMT_TARGA, /* Targa format */
|
|
|
|
|
FMT_TIFF /* TIFF format */
|
1994-09-24 04:00:00 +04:00
|
|
|
} IMAGE_FORMATS;
|
|
|
|
|
|
2014-05-09 22:00:32 +04:00
|
|
|
#ifndef DEFAULT_FMT /* so can override from CFLAGS in Makefile */
|
|
|
|
|
#define DEFAULT_FMT FMT_PPM
|
1994-09-24 04:00:00 +04:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
static IMAGE_FORMATS requested_fmt;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Argument-parsing code.
|
|
|
|
|
* The switch parser is designed to be useful with DOS-style command line
|
|
|
|
|
* syntax, ie, intermixed switches and file names, where only the switches
|
|
|
|
|
* to the left of a given file name affect processing of that file.
|
|
|
|
|
* The main program in this file doesn't actually use this capability...
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
2016-02-19 17:53:33 +03:00
|
|
|
static const char *progname; /* program name for error messages */
|
libjpeg API: Support reading/writing ICC profiles
This commit does the following:
-- Merges the two glueware functions (read_icc_profile() and
write_icc_profile()) from iccjpeg.c, which is contained in downstream
projects such as LCMS, Ghostscript, Mozilla, etc. These functions were
originally intended for inclusion in libjpeg, but Tom Lane left the IJG
before that could be accomplished. Since then, programs and libraries
that needed to embed/extract ICC profiles in JPEG files had to include
their own local copy of iccjpeg.c, which is suboptimal.
-- The new functions were prefixed with jpeg_ and split into separate
files for the compressor and decompressor, per the existing libjpeg
coding standards.
-- jpeg_write_icc_profile() was made slightly more fault-tolerant.
It will now trigger a libjpeg error if it is called before
jpeg_start_compress() or if it is passed NULL arguments.
-- jpeg_read_icc_profile() was made slightly more fault-tolerant.
It will now trigger a libjpeg error if it is called before
jpeg_read_header() or if it is passed NULL arguments. It will also
now trigger libjpeg warnings if the ICC profile data is corrupt.
-- The code comments have been wordsmithed.
-- Note that the one-line setup_read_icc_profile() function was not
included. Instead, libjpeg.txt now documents the need to call
jpeg_save_markers(cinfo, JPEG_APP0 + 2, 0xFFFF) prior to calling
jpeg_read_header(), if jpeg_read_icc_profile() is to be used.
-- Adds documentation for the new functions to libjpeg.txt.
-- Adds an -icc switch to cjpeg and jpegtran that allows those programs
to embed an ICC profile in the JPEG files they generate.
-- Adds an -icc switch to djpeg that allows that program to extract an
ICC profile from a JPEG file while decompressing.
-- Adds appropriate unit tests for all of the above.
-- Bumps the SO_AGE of the libjpeg API library to indicate the presence
of new API functions.
Note that the licensing information was obtained from:
https://github.com/mm2/Little-CMS/issues/37#issuecomment-66450180
2017-01-20 00:18:57 +03:00
|
|
|
static char *icc_filename; /* for -icc switch */
|
2019-12-19 00:12:33 +03:00
|
|
|
JDIMENSION max_scans; /* for -maxscans switch */
|
2016-02-19 17:53:33 +03:00
|
|
|
static char *outfilename; /* for -outfile switch */
|
2016-02-19 19:35:09 +03:00
|
|
|
boolean memsrc; /* for -memsrc switch */
|
2019-12-19 00:12:33 +03:00
|
|
|
boolean report; /* for -report switch */
|
2016-02-20 03:32:10 +03:00
|
|
|
boolean skip, crop;
|
|
|
|
|
JDIMENSION skip_start, skip_end;
|
|
|
|
|
JDIMENSION crop_x, crop_y, crop_width, crop_height;
|
2019-12-19 00:12:33 +03:00
|
|
|
boolean strict; /* for -strict switch */
|
2013-01-19 03:42:31 +04:00
|
|
|
#define INPUT_BUF_SIZE 4096
|
1994-09-24 04:00:00 +04:00
|
|
|
|
|
|
|
|
|
1996-02-07 03:00:00 +03:00
|
|
|
LOCAL(void)
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
usage(void)
|
1994-09-24 04:00:00 +04:00
|
|
|
/* complain about bad command line */
|
|
|
|
|
{
|
|
|
|
|
fprintf(stderr, "usage: %s [switches] ", progname);
|
|
|
|
|
#ifdef TWO_FILE_COMMANDLINE
|
|
|
|
|
fprintf(stderr, "inputfile outputfile\n");
|
|
|
|
|
#else
|
|
|
|
|
fprintf(stderr, "[inputfile]\n");
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
fprintf(stderr, "Switches (names may be abbreviated):\n");
|
|
|
|
|
fprintf(stderr, " -colors N Reduce image to no more than N colors\n");
|
|
|
|
|
fprintf(stderr, " -fast Fast, low-quality processing\n");
|
|
|
|
|
fprintf(stderr, " -grayscale Force grayscale output\n");
|
2011-03-03 19:58:47 +03:00
|
|
|
fprintf(stderr, " -rgb Force RGB output\n");
|
2014-05-12 13:23:57 +04:00
|
|
|
fprintf(stderr, " -rgb565 Force RGB565 output\n");
|
1994-09-24 04:00:00 +04:00
|
|
|
#ifdef IDCT_SCALING_SUPPORTED
|
|
|
|
|
fprintf(stderr, " -scale M/N Scale output image by fraction M/N, eg, 1/8\n");
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef BMP_SUPPORTED
|
|
|
|
|
fprintf(stderr, " -bmp Select BMP output format (Windows style)%s\n",
|
2014-05-09 22:00:32 +04:00
|
|
|
(DEFAULT_FMT == FMT_BMP ? " (default)" : ""));
|
1994-09-24 04:00:00 +04:00
|
|
|
#endif
|
|
|
|
|
#ifdef GIF_SUPPORTED
|
2020-10-27 21:28:56 +03:00
|
|
|
fprintf(stderr, " -gif Select GIF output format (LZW-compressed)%s\n",
|
2014-05-09 22:00:32 +04:00
|
|
|
(DEFAULT_FMT == FMT_GIF ? " (default)" : ""));
|
2020-01-12 03:00:00 +03:00
|
|
|
fprintf(stderr, " -gif0 Select GIF output format (uncompressed)%s\n",
|
2020-10-27 21:28:56 +03:00
|
|
|
(DEFAULT_FMT == FMT_GIF0 ? " (default)" : ""));
|
1994-09-24 04:00:00 +04:00
|
|
|
#endif
|
|
|
|
|
#ifdef BMP_SUPPORTED
|
|
|
|
|
fprintf(stderr, " -os2 Select BMP output format (OS/2 style)%s\n",
|
2014-05-09 22:00:32 +04:00
|
|
|
(DEFAULT_FMT == FMT_OS2 ? " (default)" : ""));
|
1994-09-24 04:00:00 +04:00
|
|
|
#endif
|
|
|
|
|
#ifdef PPM_SUPPORTED
|
|
|
|
|
fprintf(stderr, " -pnm Select PBMPLUS (PPM/PGM) output format%s\n",
|
2014-05-09 22:00:32 +04:00
|
|
|
(DEFAULT_FMT == FMT_PPM ? " (default)" : ""));
|
1994-09-24 04:00:00 +04:00
|
|
|
#endif
|
|
|
|
|
#ifdef TARGA_SUPPORTED
|
|
|
|
|
fprintf(stderr, " -targa Select Targa output format%s\n",
|
2014-05-09 22:00:32 +04:00
|
|
|
(DEFAULT_FMT == FMT_TARGA ? " (default)" : ""));
|
1994-09-24 04:00:00 +04:00
|
|
|
#endif
|
|
|
|
|
fprintf(stderr, "Switches for advanced users:\n");
|
|
|
|
|
#ifdef DCT_ISLOW_SUPPORTED
|
2020-11-04 19:13:06 +03:00
|
|
|
fprintf(stderr, " -dct int Use accurate integer DCT method%s\n",
|
2014-05-09 22:00:32 +04:00
|
|
|
(JDCT_DEFAULT == JDCT_ISLOW ? " (default)" : ""));
|
1994-09-24 04:00:00 +04:00
|
|
|
#endif
|
|
|
|
|
#ifdef DCT_IFAST_SUPPORTED
|
2020-11-04 19:13:06 +03:00
|
|
|
fprintf(stderr, " -dct fast Use less accurate integer DCT method [legacy feature]%s\n",
|
2014-05-09 22:00:32 +04:00
|
|
|
(JDCT_DEFAULT == JDCT_IFAST ? " (default)" : ""));
|
1994-09-24 04:00:00 +04:00
|
|
|
#endif
|
|
|
|
|
#ifdef DCT_FLOAT_SUPPORTED
|
2020-11-04 19:13:06 +03:00
|
|
|
fprintf(stderr, " -dct float Use floating-point DCT method [legacy feature]%s\n",
|
2014-05-09 22:00:32 +04:00
|
|
|
(JDCT_DEFAULT == JDCT_FLOAT ? " (default)" : ""));
|
1994-09-24 04:00:00 +04:00
|
|
|
#endif
|
|
|
|
|
fprintf(stderr, " -dither fs Use F-S dithering (default)\n");
|
|
|
|
|
fprintf(stderr, " -dither none Don't use dithering in quantization\n");
|
|
|
|
|
fprintf(stderr, " -dither ordered Use ordered dither (medium speed, quality)\n");
|
libjpeg API: Support reading/writing ICC profiles
This commit does the following:
-- Merges the two glueware functions (read_icc_profile() and
write_icc_profile()) from iccjpeg.c, which is contained in downstream
projects such as LCMS, Ghostscript, Mozilla, etc. These functions were
originally intended for inclusion in libjpeg, but Tom Lane left the IJG
before that could be accomplished. Since then, programs and libraries
that needed to embed/extract ICC profiles in JPEG files had to include
their own local copy of iccjpeg.c, which is suboptimal.
-- The new functions were prefixed with jpeg_ and split into separate
files for the compressor and decompressor, per the existing libjpeg
coding standards.
-- jpeg_write_icc_profile() was made slightly more fault-tolerant.
It will now trigger a libjpeg error if it is called before
jpeg_start_compress() or if it is passed NULL arguments.
-- jpeg_read_icc_profile() was made slightly more fault-tolerant.
It will now trigger a libjpeg error if it is called before
jpeg_read_header() or if it is passed NULL arguments. It will also
now trigger libjpeg warnings if the ICC profile data is corrupt.
-- The code comments have been wordsmithed.
-- Note that the one-line setup_read_icc_profile() function was not
included. Instead, libjpeg.txt now documents the need to call
jpeg_save_markers(cinfo, JPEG_APP0 + 2, 0xFFFF) prior to calling
jpeg_read_header(), if jpeg_read_icc_profile() is to be used.
-- Adds documentation for the new functions to libjpeg.txt.
-- Adds an -icc switch to cjpeg and jpegtran that allows those programs
to embed an ICC profile in the JPEG files they generate.
-- Adds an -icc switch to djpeg that allows that program to extract an
ICC profile from a JPEG file while decompressing.
-- Adds appropriate unit tests for all of the above.
-- Bumps the SO_AGE of the libjpeg API library to indicate the presence
of new API functions.
Note that the licensing information was obtained from:
https://github.com/mm2/Little-CMS/issues/37#issuecomment-66450180
2017-01-20 00:18:57 +03:00
|
|
|
fprintf(stderr, " -icc FILE Extract ICC profile to FILE\n");
|
1994-09-24 04:00:00 +04:00
|
|
|
#ifdef QUANT_2PASS_SUPPORTED
|
|
|
|
|
fprintf(stderr, " -map FILE Map to colors used in named image file\n");
|
|
|
|
|
#endif
|
|
|
|
|
fprintf(stderr, " -nosmooth Don't use high-quality upsampling\n");
|
|
|
|
|
#ifdef QUANT_1PASS_SUPPORTED
|
|
|
|
|
fprintf(stderr, " -onepass Use 1-pass quantization (fast, low quality)\n");
|
|
|
|
|
#endif
|
|
|
|
|
fprintf(stderr, " -maxmemory N Maximum memory to use (in kbytes)\n");
|
2019-12-19 00:12:33 +03:00
|
|
|
fprintf(stderr, " -maxscans N Maximum number of scans to allow in input file\n");
|
1994-09-24 04:00:00 +04:00
|
|
|
fprintf(stderr, " -outfile name Specify name for output file\n");
|
2013-01-19 03:42:31 +04:00
|
|
|
#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
|
|
|
|
|
fprintf(stderr, " -memsrc Load input file into memory before decompressing\n");
|
|
|
|
|
#endif
|
2019-12-19 00:12:33 +03:00
|
|
|
fprintf(stderr, " -report Report decompression progress\n");
|
2016-02-20 03:32:10 +03:00
|
|
|
fprintf(stderr, " -skip Y0,Y1 Decompress all rows except those between Y0 and Y1 (inclusive)\n");
|
|
|
|
|
fprintf(stderr, " -crop WxH+X+Y Decompress only a rectangular subregion of the image\n");
|
2017-11-14 06:01:53 +03:00
|
|
|
fprintf(stderr, " [requires PBMPLUS (PPM/PGM), GIF, or Targa output format]\n");
|
2019-12-19 00:12:33 +03:00
|
|
|
fprintf(stderr, " -strict Treat all warnings as fatal\n");
|
1994-09-24 04:00:00 +04:00
|
|
|
fprintf(stderr, " -verbose or -debug Emit debug output\n");
|
2014-11-22 07:04:38 +03:00
|
|
|
fprintf(stderr, " -version Print version information and exit\n");
|
1994-09-24 04:00:00 +04:00
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
1996-02-07 03:00:00 +03:00
|
|
|
LOCAL(int)
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
parse_switches(j_decompress_ptr cinfo, int argc, char **argv,
|
|
|
|
|
int last_file_arg_seen, boolean for_real)
|
1994-09-24 04:00:00 +04:00
|
|
|
/* Parse optional switches.
|
|
|
|
|
* Returns argv[] index of first file-name argument (== argc if none).
|
|
|
|
|
* Any file names with indexes <= last_file_arg_seen are ignored;
|
|
|
|
|
* they have presumably been processed in a previous iteration.
|
|
|
|
|
* (Pass 0 for last_file_arg_seen on the first or only iteration.)
|
|
|
|
|
* for_real is FALSE on the first (dummy) pass; we may skip any expensive
|
|
|
|
|
* processing.
|
|
|
|
|
*/
|
|
|
|
|
{
|
|
|
|
|
int argn;
|
2016-02-19 17:53:33 +03:00
|
|
|
char *arg;
|
1994-09-24 04:00:00 +04:00
|
|
|
|
|
|
|
|
/* Set up default JPEG parameters. */
|
2014-05-09 22:00:32 +04:00
|
|
|
requested_fmt = DEFAULT_FMT; /* set default output file format */
|
libjpeg API: Support reading/writing ICC profiles
This commit does the following:
-- Merges the two glueware functions (read_icc_profile() and
write_icc_profile()) from iccjpeg.c, which is contained in downstream
projects such as LCMS, Ghostscript, Mozilla, etc. These functions were
originally intended for inclusion in libjpeg, but Tom Lane left the IJG
before that could be accomplished. Since then, programs and libraries
that needed to embed/extract ICC profiles in JPEG files had to include
their own local copy of iccjpeg.c, which is suboptimal.
-- The new functions were prefixed with jpeg_ and split into separate
files for the compressor and decompressor, per the existing libjpeg
coding standards.
-- jpeg_write_icc_profile() was made slightly more fault-tolerant.
It will now trigger a libjpeg error if it is called before
jpeg_start_compress() or if it is passed NULL arguments.
-- jpeg_read_icc_profile() was made slightly more fault-tolerant.
It will now trigger a libjpeg error if it is called before
jpeg_read_header() or if it is passed NULL arguments. It will also
now trigger libjpeg warnings if the ICC profile data is corrupt.
-- The code comments have been wordsmithed.
-- Note that the one-line setup_read_icc_profile() function was not
included. Instead, libjpeg.txt now documents the need to call
jpeg_save_markers(cinfo, JPEG_APP0 + 2, 0xFFFF) prior to calling
jpeg_read_header(), if jpeg_read_icc_profile() is to be used.
-- Adds documentation for the new functions to libjpeg.txt.
-- Adds an -icc switch to cjpeg and jpegtran that allows those programs
to embed an ICC profile in the JPEG files they generate.
-- Adds an -icc switch to djpeg that allows that program to extract an
ICC profile from a JPEG file while decompressing.
-- Adds appropriate unit tests for all of the above.
-- Bumps the SO_AGE of the libjpeg API library to indicate the presence
of new API functions.
Note that the licensing information was obtained from:
https://github.com/mm2/Little-CMS/issues/37#issuecomment-66450180
2017-01-20 00:18:57 +03:00
|
|
|
icc_filename = NULL;
|
2019-12-19 00:12:33 +03:00
|
|
|
max_scans = 0;
|
1994-09-24 04:00:00 +04:00
|
|
|
outfilename = NULL;
|
2013-01-19 03:42:31 +04:00
|
|
|
memsrc = FALSE;
|
2019-12-19 00:12:33 +03:00
|
|
|
report = FALSE;
|
2015-06-25 06:44:37 +03:00
|
|
|
skip = FALSE;
|
2016-02-20 03:32:10 +03:00
|
|
|
crop = FALSE;
|
2019-12-19 00:12:33 +03:00
|
|
|
strict = FALSE;
|
1994-09-24 04:00:00 +04:00
|
|
|
cinfo->err->trace_level = 0;
|
|
|
|
|
|
|
|
|
|
/* Scan command line options, adjust parameters */
|
|
|
|
|
|
|
|
|
|
for (argn = 1; argn < argc; argn++) {
|
|
|
|
|
arg = argv[argn];
|
|
|
|
|
if (*arg != '-') {
|
|
|
|
|
/* Not a switch, must be a file name argument */
|
|
|
|
|
if (argn <= last_file_arg_seen) {
|
2014-05-09 22:00:32 +04:00
|
|
|
outfilename = NULL; /* -outfile applies to just one input file */
|
|
|
|
|
continue; /* ignore this name if previously processed */
|
1994-09-24 04:00:00 +04:00
|
|
|
}
|
2014-05-09 22:00:32 +04:00
|
|
|
break; /* else done parsing switches */
|
1994-09-24 04:00:00 +04:00
|
|
|
}
|
2014-05-09 22:00:32 +04:00
|
|
|
arg++; /* advance past switch marker character */
|
1994-09-24 04:00:00 +04:00
|
|
|
|
|
|
|
|
if (keymatch(arg, "bmp", 1)) {
|
2020-01-12 03:00:00 +03:00
|
|
|
/* BMP output format (Windows flavor). */
|
1994-09-24 04:00:00 +04:00
|
|
|
requested_fmt = FMT_BMP;
|
|
|
|
|
|
|
|
|
|
} else if (keymatch(arg, "colors", 1) || keymatch(arg, "colours", 1) ||
|
2014-05-09 22:00:32 +04:00
|
|
|
keymatch(arg, "quantize", 1) || keymatch(arg, "quantise", 1)) {
|
1994-09-24 04:00:00 +04:00
|
|
|
/* Do color quantization. */
|
|
|
|
|
int val;
|
|
|
|
|
|
2014-05-09 22:00:32 +04:00
|
|
|
if (++argn >= argc) /* advance to next argument */
|
|
|
|
|
usage();
|
1994-09-24 04:00:00 +04:00
|
|
|
if (sscanf(argv[argn], "%d", &val) != 1)
|
2014-05-09 22:00:32 +04:00
|
|
|
usage();
|
1994-09-24 04:00:00 +04:00
|
|
|
cinfo->desired_number_of_colors = val;
|
|
|
|
|
cinfo->quantize_colors = TRUE;
|
|
|
|
|
|
|
|
|
|
} else if (keymatch(arg, "dct", 2)) {
|
|
|
|
|
/* Select IDCT algorithm. */
|
2014-05-09 22:00:32 +04:00
|
|
|
if (++argn >= argc) /* advance to next argument */
|
|
|
|
|
usage();
|
1994-09-24 04:00:00 +04:00
|
|
|
if (keymatch(argv[argn], "int", 1)) {
|
2014-05-09 22:00:32 +04:00
|
|
|
cinfo->dct_method = JDCT_ISLOW;
|
1994-09-24 04:00:00 +04:00
|
|
|
} else if (keymatch(argv[argn], "fast", 2)) {
|
2014-05-09 22:00:32 +04:00
|
|
|
cinfo->dct_method = JDCT_IFAST;
|
1994-09-24 04:00:00 +04:00
|
|
|
} else if (keymatch(argv[argn], "float", 2)) {
|
2014-05-09 22:00:32 +04:00
|
|
|
cinfo->dct_method = JDCT_FLOAT;
|
1994-09-24 04:00:00 +04:00
|
|
|
} else
|
2014-05-09 22:00:32 +04:00
|
|
|
usage();
|
1994-09-24 04:00:00 +04:00
|
|
|
|
|
|
|
|
} else if (keymatch(arg, "dither", 2)) {
|
|
|
|
|
/* Select dithering algorithm. */
|
2014-05-09 22:00:32 +04:00
|
|
|
if (++argn >= argc) /* advance to next argument */
|
|
|
|
|
usage();
|
1994-09-24 04:00:00 +04:00
|
|
|
if (keymatch(argv[argn], "fs", 2)) {
|
2014-05-09 22:00:32 +04:00
|
|
|
cinfo->dither_mode = JDITHER_FS;
|
1994-09-24 04:00:00 +04:00
|
|
|
} else if (keymatch(argv[argn], "none", 2)) {
|
2014-05-09 22:00:32 +04:00
|
|
|
cinfo->dither_mode = JDITHER_NONE;
|
1994-09-24 04:00:00 +04:00
|
|
|
} else if (keymatch(argv[argn], "ordered", 2)) {
|
2014-05-09 22:00:32 +04:00
|
|
|
cinfo->dither_mode = JDITHER_ORDERED;
|
1994-09-24 04:00:00 +04:00
|
|
|
} else
|
2014-05-09 22:00:32 +04:00
|
|
|
usage();
|
1994-09-24 04:00:00 +04:00
|
|
|
|
|
|
|
|
} else if (keymatch(arg, "debug", 1) || keymatch(arg, "verbose", 1)) {
|
|
|
|
|
/* Enable debug printouts. */
|
|
|
|
|
/* On first -d, print version identification */
|
|
|
|
|
static boolean printed_version = FALSE;
|
|
|
|
|
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
if (!printed_version) {
|
2014-05-09 22:00:32 +04:00
|
|
|
fprintf(stderr, "%s version %s (build %s)\n",
|
|
|
|
|
PACKAGE_NAME, VERSION, BUILD);
|
|
|
|
|
fprintf(stderr, "%s\n\n", JCOPYRIGHT);
|
|
|
|
|
fprintf(stderr, "Emulating The Independent JPEG Group's software, version %s\n\n",
|
|
|
|
|
JVERSION);
|
|
|
|
|
printed_version = TRUE;
|
1994-09-24 04:00:00 +04:00
|
|
|
}
|
|
|
|
|
cinfo->err->trace_level++;
|
|
|
|
|
|
2014-11-22 07:04:38 +03:00
|
|
|
} else if (keymatch(arg, "version", 4)) {
|
|
|
|
|
fprintf(stderr, "%s version %s (build %s)\n",
|
|
|
|
|
PACKAGE_NAME, VERSION, BUILD);
|
2014-11-22 07:25:04 +03:00
|
|
|
exit(EXIT_SUCCESS);
|
2014-11-22 07:04:38 +03:00
|
|
|
|
1994-09-24 04:00:00 +04:00
|
|
|
} else if (keymatch(arg, "fast", 1)) {
|
|
|
|
|
/* Select recommended processing options for quick-and-dirty output. */
|
|
|
|
|
cinfo->two_pass_quantize = FALSE;
|
|
|
|
|
cinfo->dither_mode = JDITHER_ORDERED;
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
if (!cinfo->quantize_colors) /* don't override an earlier -colors */
|
2014-05-09 22:00:32 +04:00
|
|
|
cinfo->desired_number_of_colors = 216;
|
1994-09-24 04:00:00 +04:00
|
|
|
cinfo->dct_method = JDCT_FASTEST;
|
|
|
|
|
cinfo->do_fancy_upsampling = FALSE;
|
|
|
|
|
|
|
|
|
|
} else if (keymatch(arg, "gif", 1)) {
|
2020-10-27 21:28:56 +03:00
|
|
|
/* GIF output format (LZW-compressed). */
|
1994-09-24 04:00:00 +04:00
|
|
|
requested_fmt = FMT_GIF;
|
|
|
|
|
|
2020-01-12 03:00:00 +03:00
|
|
|
} else if (keymatch(arg, "gif0", 4)) {
|
|
|
|
|
/* GIF output format (uncompressed). */
|
|
|
|
|
requested_fmt = FMT_GIF0;
|
|
|
|
|
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
} else if (keymatch(arg, "grayscale", 2) ||
|
|
|
|
|
keymatch(arg, "greyscale", 2)) {
|
1994-09-24 04:00:00 +04:00
|
|
|
/* Force monochrome output. */
|
|
|
|
|
cinfo->out_color_space = JCS_GRAYSCALE;
|
|
|
|
|
|
2011-03-03 19:58:47 +03:00
|
|
|
} else if (keymatch(arg, "rgb", 2)) {
|
|
|
|
|
/* Force RGB output. */
|
|
|
|
|
cinfo->out_color_space = JCS_RGB;
|
|
|
|
|
|
2014-05-12 13:23:57 +04:00
|
|
|
} else if (keymatch(arg, "rgb565", 2)) {
|
|
|
|
|
/* Force RGB565 output. */
|
|
|
|
|
cinfo->out_color_space = JCS_RGB565;
|
|
|
|
|
|
libjpeg API: Support reading/writing ICC profiles
This commit does the following:
-- Merges the two glueware functions (read_icc_profile() and
write_icc_profile()) from iccjpeg.c, which is contained in downstream
projects such as LCMS, Ghostscript, Mozilla, etc. These functions were
originally intended for inclusion in libjpeg, but Tom Lane left the IJG
before that could be accomplished. Since then, programs and libraries
that needed to embed/extract ICC profiles in JPEG files had to include
their own local copy of iccjpeg.c, which is suboptimal.
-- The new functions were prefixed with jpeg_ and split into separate
files for the compressor and decompressor, per the existing libjpeg
coding standards.
-- jpeg_write_icc_profile() was made slightly more fault-tolerant.
It will now trigger a libjpeg error if it is called before
jpeg_start_compress() or if it is passed NULL arguments.
-- jpeg_read_icc_profile() was made slightly more fault-tolerant.
It will now trigger a libjpeg error if it is called before
jpeg_read_header() or if it is passed NULL arguments. It will also
now trigger libjpeg warnings if the ICC profile data is corrupt.
-- The code comments have been wordsmithed.
-- Note that the one-line setup_read_icc_profile() function was not
included. Instead, libjpeg.txt now documents the need to call
jpeg_save_markers(cinfo, JPEG_APP0 + 2, 0xFFFF) prior to calling
jpeg_read_header(), if jpeg_read_icc_profile() is to be used.
-- Adds documentation for the new functions to libjpeg.txt.
-- Adds an -icc switch to cjpeg and jpegtran that allows those programs
to embed an ICC profile in the JPEG files they generate.
-- Adds an -icc switch to djpeg that allows that program to extract an
ICC profile from a JPEG file while decompressing.
-- Adds appropriate unit tests for all of the above.
-- Bumps the SO_AGE of the libjpeg API library to indicate the presence
of new API functions.
Note that the licensing information was obtained from:
https://github.com/mm2/Little-CMS/issues/37#issuecomment-66450180
2017-01-20 00:18:57 +03:00
|
|
|
} else if (keymatch(arg, "icc", 1)) {
|
|
|
|
|
/* Set ICC filename. */
|
|
|
|
|
if (++argn >= argc) /* advance to next argument */
|
|
|
|
|
usage();
|
|
|
|
|
icc_filename = argv[argn];
|
|
|
|
|
jpeg_save_markers(cinfo, JPEG_APP0 + 2, 0xFFFF);
|
|
|
|
|
|
1994-09-24 04:00:00 +04:00
|
|
|
} else if (keymatch(arg, "map", 3)) {
|
|
|
|
|
/* Quantize to a color map taken from an input file. */
|
2014-05-09 22:00:32 +04:00
|
|
|
if (++argn >= argc) /* advance to next argument */
|
|
|
|
|
usage();
|
|
|
|
|
if (for_real) { /* too expensive to do twice! */
|
|
|
|
|
#ifdef QUANT_2PASS_SUPPORTED /* otherwise can't quantize to supplied map */
|
2016-02-19 17:53:33 +03:00
|
|
|
FILE *mapfile;
|
2014-05-09 22:00:32 +04:00
|
|
|
|
|
|
|
|
if ((mapfile = fopen(argv[argn], READ_BINARY)) == NULL) {
|
|
|
|
|
fprintf(stderr, "%s: can't open %s\n", progname, argv[argn]);
|
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
|
}
|
|
|
|
|
read_color_map(cinfo, mapfile);
|
|
|
|
|
fclose(mapfile);
|
|
|
|
|
cinfo->quantize_colors = TRUE;
|
1994-09-24 04:00:00 +04:00
|
|
|
#else
|
2014-05-09 22:00:32 +04:00
|
|
|
ERREXIT(cinfo, JERR_NOT_COMPILED);
|
1994-09-24 04:00:00 +04:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} else if (keymatch(arg, "maxmemory", 3)) {
|
|
|
|
|
/* Maximum memory in Kb (or Mb with 'm'). */
|
|
|
|
|
long lval;
|
|
|
|
|
char ch = 'x';
|
|
|
|
|
|
2014-05-09 22:00:32 +04:00
|
|
|
if (++argn >= argc) /* advance to next argument */
|
|
|
|
|
usage();
|
1994-09-24 04:00:00 +04:00
|
|
|
if (sscanf(argv[argn], "%ld%c", &lval, &ch) < 1)
|
2014-05-09 22:00:32 +04:00
|
|
|
usage();
|
1994-09-24 04:00:00 +04:00
|
|
|
if (ch == 'm' || ch == 'M')
|
2014-05-09 22:00:32 +04:00
|
|
|
lval *= 1000L;
|
1994-09-24 04:00:00 +04:00
|
|
|
cinfo->mem->max_memory_to_use = lval * 1000L;
|
|
|
|
|
|
2019-12-19 00:12:33 +03:00
|
|
|
} else if (keymatch(arg, "maxscans", 4)) {
|
|
|
|
|
if (++argn >= argc) /* advance to next argument */
|
|
|
|
|
usage();
|
|
|
|
|
if (sscanf(argv[argn], "%u", &max_scans) != 1)
|
|
|
|
|
usage();
|
|
|
|
|
|
1994-09-24 04:00:00 +04:00
|
|
|
} else if (keymatch(arg, "nosmooth", 3)) {
|
|
|
|
|
/* Suppress fancy upsampling */
|
|
|
|
|
cinfo->do_fancy_upsampling = FALSE;
|
|
|
|
|
|
|
|
|
|
} else if (keymatch(arg, "onepass", 3)) {
|
|
|
|
|
/* Use fast one-pass quantization. */
|
|
|
|
|
cinfo->two_pass_quantize = FALSE;
|
|
|
|
|
|
|
|
|
|
} else if (keymatch(arg, "os2", 3)) {
|
|
|
|
|
/* BMP output format (OS/2 flavor). */
|
|
|
|
|
requested_fmt = FMT_OS2;
|
|
|
|
|
|
|
|
|
|
} else if (keymatch(arg, "outfile", 4)) {
|
|
|
|
|
/* Set output file name. */
|
2014-05-09 22:00:32 +04:00
|
|
|
if (++argn >= argc) /* advance to next argument */
|
|
|
|
|
usage();
|
|
|
|
|
outfilename = argv[argn]; /* save it away for later use */
|
1994-09-24 04:00:00 +04:00
|
|
|
|
2013-01-19 03:42:31 +04:00
|
|
|
} else if (keymatch(arg, "memsrc", 2)) {
|
|
|
|
|
/* Use in-memory source manager */
|
|
|
|
|
#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
|
|
|
|
|
memsrc = TRUE;
|
|
|
|
|
#else
|
|
|
|
|
fprintf(stderr, "%s: sorry, in-memory source manager was not compiled in\n",
|
|
|
|
|
progname);
|
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
|
#endif
|
|
|
|
|
|
1994-09-24 04:00:00 +04:00
|
|
|
} else if (keymatch(arg, "pnm", 1) || keymatch(arg, "ppm", 1)) {
|
|
|
|
|
/* PPM/PGM output format. */
|
|
|
|
|
requested_fmt = FMT_PPM;
|
|
|
|
|
|
2019-12-19 00:12:33 +03:00
|
|
|
} else if (keymatch(arg, "report", 2)) {
|
|
|
|
|
report = TRUE;
|
|
|
|
|
|
2015-06-25 06:44:36 +03:00
|
|
|
} else if (keymatch(arg, "scale", 2)) {
|
1994-09-24 04:00:00 +04:00
|
|
|
/* Scale the output image by a fraction M/N. */
|
2014-05-09 22:00:32 +04:00
|
|
|
if (++argn >= argc) /* advance to next argument */
|
|
|
|
|
usage();
|
2013-01-13 04:00:00 +04:00
|
|
|
if (sscanf(argv[argn], "%u/%u",
|
2014-05-09 22:00:32 +04:00
|
|
|
&cinfo->scale_num, &cinfo->scale_denom) != 2)
|
|
|
|
|
usage();
|
1994-09-24 04:00:00 +04:00
|
|
|
|
2016-02-20 03:32:10 +03:00
|
|
|
} else if (keymatch(arg, "skip", 2)) {
|
2015-06-25 06:44:36 +03:00
|
|
|
if (++argn >= argc)
|
|
|
|
|
usage();
|
2016-02-20 03:32:10 +03:00
|
|
|
if (sscanf(argv[argn], "%u,%u", &skip_start, &skip_end) != 2 ||
|
|
|
|
|
skip_start > skip_end)
|
2015-06-25 06:44:36 +03:00
|
|
|
usage();
|
2016-02-20 03:32:10 +03:00
|
|
|
skip = TRUE;
|
2015-06-25 06:44:37 +03:00
|
|
|
|
2016-02-20 03:32:10 +03:00
|
|
|
} else if (keymatch(arg, "crop", 2)) {
|
|
|
|
|
char c;
|
2015-06-25 06:44:37 +03:00
|
|
|
if (++argn >= argc)
|
|
|
|
|
usage();
|
2016-02-20 03:32:10 +03:00
|
|
|
if (sscanf(argv[argn], "%u%c%u+%u+%u", &crop_width, &c, &crop_height,
|
|
|
|
|
&crop_x, &crop_y) != 5 ||
|
|
|
|
|
(c != 'X' && c != 'x') || crop_width < 1 || crop_height < 1)
|
2015-06-25 06:44:37 +03:00
|
|
|
usage();
|
2016-02-20 03:32:10 +03:00
|
|
|
crop = TRUE;
|
2015-06-25 06:44:37 +03:00
|
|
|
|
2019-12-19 00:12:33 +03:00
|
|
|
} else if (keymatch(arg, "strict", 2)) {
|
|
|
|
|
strict = TRUE;
|
|
|
|
|
|
1994-09-24 04:00:00 +04:00
|
|
|
} else if (keymatch(arg, "targa", 1)) {
|
|
|
|
|
/* Targa output format. */
|
|
|
|
|
requested_fmt = FMT_TARGA;
|
|
|
|
|
|
|
|
|
|
} else {
|
2014-05-09 22:00:32 +04:00
|
|
|
usage(); /* bogus switch */
|
1994-09-24 04:00:00 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-09 22:00:32 +04:00
|
|
|
return argn; /* return index of next arg (file name) */
|
1994-09-24 04:00:00 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
1998-03-27 03:00:00 +03:00
|
|
|
* Marker processor for COM and interesting APPn markers.
|
1994-09-24 04:00:00 +04:00
|
|
|
* This replaces the library's built-in processor, which just skips the marker.
|
1998-03-27 03:00:00 +03:00
|
|
|
* We want to print out the marker as text, to the extent possible.
|
1994-09-24 04:00:00 +04:00
|
|
|
* Note this code relies on a non-suspending data source.
|
|
|
|
|
*/
|
|
|
|
|
|
1996-02-07 03:00:00 +03:00
|
|
|
LOCAL(unsigned int)
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
jpeg_getc(j_decompress_ptr cinfo)
|
1994-09-24 04:00:00 +04:00
|
|
|
/* Read next byte */
|
|
|
|
|
{
|
2016-02-19 17:53:33 +03:00
|
|
|
struct jpeg_source_mgr *datasrc = cinfo->src;
|
1994-09-24 04:00:00 +04:00
|
|
|
|
|
|
|
|
if (datasrc->bytes_in_buffer == 0) {
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
if (!(*datasrc->fill_input_buffer) (cinfo))
|
1994-09-24 04:00:00 +04:00
|
|
|
ERREXIT(cinfo, JERR_CANT_SUSPEND);
|
|
|
|
|
}
|
|
|
|
|
datasrc->bytes_in_buffer--;
|
2019-12-11 04:10:55 +03:00
|
|
|
return *datasrc->next_input_byte++;
|
1994-09-24 04:00:00 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
1996-02-07 03:00:00 +03:00
|
|
|
METHODDEF(boolean)
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
print_text_marker(j_decompress_ptr cinfo)
|
1994-09-24 04:00:00 +04:00
|
|
|
{
|
|
|
|
|
boolean traceit = (cinfo->err->trace_level >= 1);
|
Replace INT32 with a new internal datatype (JLONG)
These days, INT32 is a commonly-defined datatype in system headers. We
cannot eliminate the definition of that datatype from jmorecfg.h, since
the INT32 typedef has technically been part of the libjpeg API since
version 5 (1994.) However, using INT32 internally is risky, because the
inclusion of a particular header (Xmd.h, for instance) could change the
definition of INT32 from long to int on 64-bit platforms and thus change
the internal behavior of libjpeg-turbo in unexpected ways (for instance,
failing to correctly set __INT32_IS_ACTUALLY_LONG to match the INT32
typedef-- perhaps as a result of including the wrong version of
jpeglib.h-- could cause libjpeg-turbo to produce incorrect results.)
The library has always been built in environments in which INT32 is
effectively long (on Windows, long is always 32-bit, so effectively it's
the same as int), so it makes sense to turn INT32 into an explicitly
long datatype. This ensures that libjpeg-turbo will always behave
consistently, regardless of the headers included at compile time.
Addresses a concern expressed in #26.
2015-10-15 01:32:39 +03:00
|
|
|
long length;
|
1994-09-24 04:00:00 +04:00
|
|
|
unsigned int ch;
|
|
|
|
|
unsigned int lastch = 0;
|
|
|
|
|
|
|
|
|
|
length = jpeg_getc(cinfo) << 8;
|
|
|
|
|
length += jpeg_getc(cinfo);
|
2014-05-09 22:00:32 +04:00
|
|
|
length -= 2; /* discount the length word itself */
|
1994-09-24 04:00:00 +04:00
|
|
|
|
1998-03-27 03:00:00 +03:00
|
|
|
if (traceit) {
|
|
|
|
|
if (cinfo->unread_marker == JPEG_COM)
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
fprintf(stderr, "Comment, length %ld:\n", (long)length);
|
2014-05-09 22:00:32 +04:00
|
|
|
else /* assume it is an APPn otherwise */
|
1998-03-27 03:00:00 +03:00
|
|
|
fprintf(stderr, "APP%d, length %ld:\n",
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
cinfo->unread_marker - JPEG_APP0, (long)length);
|
1998-03-27 03:00:00 +03:00
|
|
|
}
|
1994-09-24 04:00:00 +04:00
|
|
|
|
|
|
|
|
while (--length >= 0) {
|
|
|
|
|
ch = jpeg_getc(cinfo);
|
|
|
|
|
if (traceit) {
|
|
|
|
|
/* Emit the character in a readable form.
|
|
|
|
|
* Nonprintables are converted to \nnn form,
|
|
|
|
|
* while \ is converted to \\.
|
|
|
|
|
* Newlines in CR, CR/LF, or LF form will be printed as one newline.
|
|
|
|
|
*/
|
|
|
|
|
if (ch == '\r') {
|
2014-05-09 22:00:32 +04:00
|
|
|
fprintf(stderr, "\n");
|
1994-09-24 04:00:00 +04:00
|
|
|
} else if (ch == '\n') {
|
2014-05-09 22:00:32 +04:00
|
|
|
if (lastch != '\r')
|
|
|
|
|
fprintf(stderr, "\n");
|
1994-09-24 04:00:00 +04:00
|
|
|
} else if (ch == '\\') {
|
2014-05-09 22:00:32 +04:00
|
|
|
fprintf(stderr, "\\\\");
|
1994-09-24 04:00:00 +04:00
|
|
|
} else if (isprint(ch)) {
|
2014-05-09 22:00:32 +04:00
|
|
|
putc(ch, stderr);
|
1994-09-24 04:00:00 +04:00
|
|
|
} else {
|
2014-05-09 22:00:32 +04:00
|
|
|
fprintf(stderr, "\\%03o", ch);
|
1994-09-24 04:00:00 +04:00
|
|
|
}
|
|
|
|
|
lastch = ch;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (traceit)
|
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2019-12-19 00:12:33 +03:00
|
|
|
METHODDEF(void)
|
|
|
|
|
my_emit_message(j_common_ptr cinfo, int msg_level)
|
|
|
|
|
{
|
|
|
|
|
if (msg_level < 0) {
|
|
|
|
|
/* Treat warning as fatal */
|
|
|
|
|
cinfo->err->error_exit(cinfo);
|
|
|
|
|
} else {
|
|
|
|
|
if (cinfo->err->trace_level >= msg_level)
|
|
|
|
|
cinfo->err->output_message(cinfo);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
1994-09-24 04:00:00 +04:00
|
|
|
/*
|
|
|
|
|
* The main program.
|
|
|
|
|
*/
|
|
|
|
|
|
1996-02-07 03:00:00 +03:00
|
|
|
int
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
main(int argc, char **argv)
|
1994-09-24 04:00:00 +04:00
|
|
|
{
|
|
|
|
|
struct jpeg_decompress_struct cinfo;
|
|
|
|
|
struct jpeg_error_mgr jerr;
|
|
|
|
|
struct cdjpeg_progress_mgr progress;
|
|
|
|
|
int file_index;
|
|
|
|
|
djpeg_dest_ptr dest_mgr = NULL;
|
2016-02-19 17:53:33 +03:00
|
|
|
FILE *input_file;
|
|
|
|
|
FILE *output_file;
|
2013-01-19 03:42:31 +04:00
|
|
|
unsigned char *inbuffer = NULL;
|
2019-12-31 08:52:34 +03:00
|
|
|
#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
|
2013-01-19 03:42:31 +04:00
|
|
|
unsigned long insize = 0;
|
2019-12-31 08:52:34 +03:00
|
|
|
#endif
|
1994-09-24 04:00:00 +04:00
|
|
|
JDIMENSION num_scanlines;
|
|
|
|
|
|
|
|
|
|
progname = argv[0];
|
|
|
|
|
if (progname == NULL || progname[0] == 0)
|
2014-05-09 22:00:32 +04:00
|
|
|
progname = "djpeg"; /* in case C library doesn't provide it */
|
1994-09-24 04:00:00 +04:00
|
|
|
|
|
|
|
|
/* Initialize the JPEG decompression object with default error handling. */
|
|
|
|
|
cinfo.err = jpeg_std_error(&jerr);
|
|
|
|
|
jpeg_create_decompress(&cinfo);
|
|
|
|
|
/* Add some application-specific error messages (from cderror.h) */
|
1994-12-07 03:00:00 +03:00
|
|
|
jerr.addon_message_table = cdjpeg_message_table;
|
1994-09-24 04:00:00 +04:00
|
|
|
jerr.first_addon_message = JMSG_FIRSTADDONCODE;
|
|
|
|
|
jerr.last_addon_message = JMSG_LASTADDONCODE;
|
1998-03-27 03:00:00 +03:00
|
|
|
|
|
|
|
|
/* Insert custom marker processor for COM and APP12.
|
|
|
|
|
* APP12 is used by some digital camera makers for textual info,
|
|
|
|
|
* so we provide the ability to display it as text.
|
|
|
|
|
* If you like, additional APPn marker types can be selected for display,
|
2010-10-12 05:55:31 +04:00
|
|
|
* but don't try to override APP0 or APP14 this way (see libjpeg.txt).
|
1998-03-27 03:00:00 +03:00
|
|
|
*/
|
|
|
|
|
jpeg_set_marker_processor(&cinfo, JPEG_COM, print_text_marker);
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
jpeg_set_marker_processor(&cinfo, JPEG_APP0 + 12, print_text_marker);
|
1994-09-24 04:00:00 +04:00
|
|
|
|
|
|
|
|
/* Scan command line to find file names. */
|
|
|
|
|
/* It is convenient to use just one switch-parsing routine, but the switch
|
|
|
|
|
* values read here are ignored; we will rescan the switches after opening
|
|
|
|
|
* the input file.
|
|
|
|
|
* (Exception: tracing level set here controls verbosity for COM markers
|
|
|
|
|
* found during jpeg_read_header...)
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
file_index = parse_switches(&cinfo, argc, argv, 0, FALSE);
|
|
|
|
|
|
2019-12-19 00:12:33 +03:00
|
|
|
if (strict)
|
|
|
|
|
jerr.emit_message = my_emit_message;
|
|
|
|
|
|
1994-09-24 04:00:00 +04:00
|
|
|
#ifdef TWO_FILE_COMMANDLINE
|
|
|
|
|
/* Must have either -outfile switch or explicit output file name */
|
|
|
|
|
if (outfilename == NULL) {
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
if (file_index != argc - 2) {
|
1994-09-24 04:00:00 +04:00
|
|
|
fprintf(stderr, "%s: must name one input and one output file\n",
|
2014-05-09 22:00:32 +04:00
|
|
|
progname);
|
1994-09-24 04:00:00 +04:00
|
|
|
usage();
|
|
|
|
|
}
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
outfilename = argv[file_index + 1];
|
1994-09-24 04:00:00 +04:00
|
|
|
} else {
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
if (file_index != argc - 1) {
|
1994-09-24 04:00:00 +04:00
|
|
|
fprintf(stderr, "%s: must name one input and one output file\n",
|
2014-05-09 22:00:32 +04:00
|
|
|
progname);
|
1994-09-24 04:00:00 +04:00
|
|
|
usage();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
/* Unix style: expect zero or one file name */
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
if (file_index < argc - 1) {
|
1994-09-24 04:00:00 +04:00
|
|
|
fprintf(stderr, "%s: only one input file\n", progname);
|
|
|
|
|
usage();
|
|
|
|
|
}
|
|
|
|
|
#endif /* TWO_FILE_COMMANDLINE */
|
|
|
|
|
|
|
|
|
|
/* Open the input file. */
|
|
|
|
|
if (file_index < argc) {
|
|
|
|
|
if ((input_file = fopen(argv[file_index], READ_BINARY)) == NULL) {
|
|
|
|
|
fprintf(stderr, "%s: can't open %s\n", progname, argv[file_index]);
|
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
/* default input file is stdin */
|
1995-08-02 04:00:00 +04:00
|
|
|
input_file = read_stdin();
|
1994-09-24 04:00:00 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Open the output file. */
|
|
|
|
|
if (outfilename != NULL) {
|
|
|
|
|
if ((output_file = fopen(outfilename, WRITE_BINARY)) == NULL) {
|
|
|
|
|
fprintf(stderr, "%s: can't open %s\n", progname, outfilename);
|
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
/* default output file is stdout */
|
1995-08-02 04:00:00 +04:00
|
|
|
output_file = write_stdout();
|
1994-09-24 04:00:00 +04:00
|
|
|
}
|
|
|
|
|
|
2019-12-19 00:12:33 +03:00
|
|
|
if (report || max_scans != 0) {
|
|
|
|
|
start_progress_monitor((j_common_ptr)&cinfo, &progress);
|
|
|
|
|
progress.report = report;
|
|
|
|
|
progress.max_scans = max_scans;
|
|
|
|
|
}
|
1994-09-24 04:00:00 +04:00
|
|
|
|
|
|
|
|
/* Specify data source for decompression */
|
2013-01-19 03:42:31 +04:00
|
|
|
#if JPEG_LIB_VERSION >= 80 || defined(MEM_SRCDST_SUPPORTED)
|
|
|
|
|
if (memsrc) {
|
|
|
|
|
size_t nbytes;
|
|
|
|
|
do {
|
|
|
|
|
inbuffer = (unsigned char *)realloc(inbuffer, insize + INPUT_BUF_SIZE);
|
|
|
|
|
if (inbuffer == NULL) {
|
|
|
|
|
fprintf(stderr, "%s: memory allocation failure\n", progname);
|
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
|
}
|
2022-02-08 00:27:50 +03:00
|
|
|
nbytes = fread(&inbuffer[insize], 1, INPUT_BUF_SIZE, input_file);
|
2013-10-13 01:52:48 +04:00
|
|
|
if (nbytes < INPUT_BUF_SIZE && ferror(input_file)) {
|
2013-01-19 03:42:31 +04:00
|
|
|
if (file_index < argc)
|
|
|
|
|
fprintf(stderr, "%s: can't read from %s\n", progname,
|
|
|
|
|
argv[file_index]);
|
|
|
|
|
else
|
|
|
|
|
fprintf(stderr, "%s: can't read from stdin\n", progname);
|
|
|
|
|
}
|
2013-01-19 03:45:06 +04:00
|
|
|
insize += (unsigned long)nbytes;
|
2013-01-19 03:42:31 +04:00
|
|
|
} while (nbytes == INPUT_BUF_SIZE);
|
|
|
|
|
fprintf(stderr, "Compressed size: %lu bytes\n", insize);
|
|
|
|
|
jpeg_mem_src(&cinfo, inbuffer, insize);
|
|
|
|
|
} else
|
|
|
|
|
#endif
|
|
|
|
|
jpeg_stdio_src(&cinfo, input_file);
|
1994-09-24 04:00:00 +04:00
|
|
|
|
|
|
|
|
/* Read file header, set default decompression parameters */
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
(void)jpeg_read_header(&cinfo, TRUE);
|
1994-09-24 04:00:00 +04:00
|
|
|
|
|
|
|
|
/* Adjust default decompression parameters by re-parsing the options */
|
|
|
|
|
file_index = parse_switches(&cinfo, argc, argv, 0, TRUE);
|
|
|
|
|
|
|
|
|
|
/* Initialize the output module now to let it override any crucial
|
|
|
|
|
* option settings (for instance, GIF wants to force color quantization).
|
|
|
|
|
*/
|
|
|
|
|
switch (requested_fmt) {
|
|
|
|
|
#ifdef BMP_SUPPORTED
|
|
|
|
|
case FMT_BMP:
|
2017-11-17 03:09:07 +03:00
|
|
|
dest_mgr = jinit_write_bmp(&cinfo, FALSE, TRUE);
|
1994-09-24 04:00:00 +04:00
|
|
|
break;
|
|
|
|
|
case FMT_OS2:
|
2017-11-17 03:09:07 +03:00
|
|
|
dest_mgr = jinit_write_bmp(&cinfo, TRUE, TRUE);
|
1994-09-24 04:00:00 +04:00
|
|
|
break;
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef GIF_SUPPORTED
|
|
|
|
|
case FMT_GIF:
|
2020-01-12 03:00:00 +03:00
|
|
|
dest_mgr = jinit_write_gif(&cinfo, TRUE);
|
|
|
|
|
break;
|
|
|
|
|
case FMT_GIF0:
|
|
|
|
|
dest_mgr = jinit_write_gif(&cinfo, FALSE);
|
1994-09-24 04:00:00 +04:00
|
|
|
break;
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef PPM_SUPPORTED
|
|
|
|
|
case FMT_PPM:
|
|
|
|
|
dest_mgr = jinit_write_ppm(&cinfo);
|
|
|
|
|
break;
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef TARGA_SUPPORTED
|
|
|
|
|
case FMT_TARGA:
|
|
|
|
|
dest_mgr = jinit_write_targa(&cinfo);
|
|
|
|
|
break;
|
|
|
|
|
#endif
|
|
|
|
|
default:
|
|
|
|
|
ERREXIT(&cinfo, JERR_UNSUPPORTED_FORMAT);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
dest_mgr->output_file = output_file;
|
|
|
|
|
|
|
|
|
|
/* Start decompressor */
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
(void)jpeg_start_decompress(&cinfo);
|
1994-09-24 04:00:00 +04:00
|
|
|
|
2016-02-20 03:32:10 +03:00
|
|
|
/* Skip rows */
|
|
|
|
|
if (skip) {
|
2015-06-25 06:44:36 +03:00
|
|
|
JDIMENSION tmp;
|
|
|
|
|
|
2016-02-20 03:32:10 +03:00
|
|
|
/* Check for valid skip_end. We cannot check this value until after
|
2015-06-25 06:44:36 +03:00
|
|
|
* jpeg_start_decompress() is called. Note that we have already verified
|
2016-02-20 03:32:10 +03:00
|
|
|
* that skip_start <= skip_end.
|
2015-06-25 06:44:36 +03:00
|
|
|
*/
|
2016-02-20 03:32:10 +03:00
|
|
|
if (skip_end > cinfo.output_height - 1) {
|
2022-01-06 21:08:46 +03:00
|
|
|
fprintf(stderr, "%s: skip region exceeds image height %u\n", progname,
|
2016-02-20 03:32:10 +03:00
|
|
|
cinfo.output_height);
|
2015-06-25 06:44:36 +03:00
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
|
}
|
1994-09-24 04:00:00 +04:00
|
|
|
|
2015-06-25 06:44:36 +03:00
|
|
|
/* Write output file header. This is a hack to ensure that the destination
|
2016-02-20 03:32:10 +03:00
|
|
|
* manager creates an output image of the proper size.
|
2015-06-25 06:44:36 +03:00
|
|
|
*/
|
|
|
|
|
tmp = cinfo.output_height;
|
2016-02-20 03:32:10 +03:00
|
|
|
cinfo.output_height -= (skip_end - skip_start + 1);
|
2015-06-25 06:44:36 +03:00
|
|
|
(*dest_mgr->start_output) (&cinfo, dest_mgr);
|
|
|
|
|
cinfo.output_height = tmp;
|
|
|
|
|
|
|
|
|
|
/* Process data */
|
2016-02-20 03:32:10 +03:00
|
|
|
while (cinfo.output_scanline < skip_start) {
|
|
|
|
|
num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
|
|
|
|
|
dest_mgr->buffer_height);
|
|
|
|
|
(*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
|
|
|
|
|
}
|
2020-07-28 22:57:47 +03:00
|
|
|
if ((tmp = jpeg_skip_scanlines(&cinfo, skip_end - skip_start + 1)) !=
|
|
|
|
|
skip_end - skip_start + 1) {
|
2022-01-06 21:08:46 +03:00
|
|
|
fprintf(stderr, "%s: jpeg_skip_scanlines() returned %u rather than %u\n",
|
2020-07-28 22:57:47 +03:00
|
|
|
progname, tmp, skip_end - skip_start + 1);
|
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
|
}
|
2016-02-20 03:32:10 +03:00
|
|
|
while (cinfo.output_scanline < cinfo.output_height) {
|
|
|
|
|
num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
|
|
|
|
|
dest_mgr->buffer_height);
|
|
|
|
|
(*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Decompress a subregion */
|
|
|
|
|
} else if (crop) {
|
|
|
|
|
JDIMENSION tmp;
|
|
|
|
|
|
|
|
|
|
/* Check for valid crop dimensions. We cannot check these values until
|
|
|
|
|
* after jpeg_start_decompress() is called.
|
|
|
|
|
*/
|
|
|
|
|
if (crop_x + crop_width > cinfo.output_width ||
|
|
|
|
|
crop_y + crop_height > cinfo.output_height) {
|
2022-01-06 21:08:46 +03:00
|
|
|
fprintf(stderr, "%s: crop dimensions exceed image dimensions %u x %u\n",
|
2016-02-20 03:32:10 +03:00
|
|
|
progname, cinfo.output_width, cinfo.output_height);
|
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
jpeg_crop_scanline(&cinfo, &crop_x, &crop_width);
|
2017-11-14 06:01:53 +03:00
|
|
|
if (dest_mgr->calc_buffer_dimensions)
|
|
|
|
|
(*dest_mgr->calc_buffer_dimensions) (&cinfo, dest_mgr);
|
|
|
|
|
else
|
2017-11-09 06:01:57 +03:00
|
|
|
ERREXIT(&cinfo, JERR_UNSUPPORTED_FORMAT);
|
2016-02-20 03:32:10 +03:00
|
|
|
|
|
|
|
|
/* Write output file header. This is a hack to ensure that the destination
|
|
|
|
|
* manager creates an output image of the proper size.
|
|
|
|
|
*/
|
|
|
|
|
tmp = cinfo.output_height;
|
|
|
|
|
cinfo.output_height = crop_height;
|
|
|
|
|
(*dest_mgr->start_output) (&cinfo, dest_mgr);
|
|
|
|
|
cinfo.output_height = tmp;
|
|
|
|
|
|
|
|
|
|
/* Process data */
|
2020-07-28 22:57:47 +03:00
|
|
|
if ((tmp = jpeg_skip_scanlines(&cinfo, crop_y)) != crop_y) {
|
2022-01-06 21:08:46 +03:00
|
|
|
fprintf(stderr, "%s: jpeg_skip_scanlines() returned %u rather than %u\n",
|
2020-07-28 22:57:47 +03:00
|
|
|
progname, tmp, crop_y);
|
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
|
}
|
2016-02-20 03:32:10 +03:00
|
|
|
while (cinfo.output_scanline < crop_y + crop_height) {
|
|
|
|
|
num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
|
|
|
|
|
dest_mgr->buffer_height);
|
|
|
|
|
(*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
|
2015-06-25 06:44:36 +03:00
|
|
|
}
|
2020-07-28 22:57:47 +03:00
|
|
|
if ((tmp =
|
|
|
|
|
jpeg_skip_scanlines(&cinfo,
|
|
|
|
|
cinfo.output_height - crop_y - crop_height)) !=
|
|
|
|
|
cinfo.output_height - crop_y - crop_height) {
|
2022-01-06 21:08:46 +03:00
|
|
|
fprintf(stderr, "%s: jpeg_skip_scanlines() returned %u rather than %u\n",
|
2020-07-28 22:57:47 +03:00
|
|
|
progname, tmp, cinfo.output_height - crop_y - crop_height);
|
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
|
}
|
2015-06-25 06:44:36 +03:00
|
|
|
|
2016-02-20 03:32:10 +03:00
|
|
|
/* Normal full-image decompress */
|
2015-06-25 06:44:36 +03:00
|
|
|
} else {
|
|
|
|
|
/* Write output file header */
|
|
|
|
|
(*dest_mgr->start_output) (&cinfo, dest_mgr);
|
|
|
|
|
|
|
|
|
|
/* Process data */
|
|
|
|
|
while (cinfo.output_scanline < cinfo.output_height) {
|
|
|
|
|
num_scanlines = jpeg_read_scanlines(&cinfo, dest_mgr->buffer,
|
|
|
|
|
dest_mgr->buffer_height);
|
|
|
|
|
(*dest_mgr->put_pixel_rows) (&cinfo, dest_mgr, num_scanlines);
|
|
|
|
|
}
|
1994-09-24 04:00:00 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Hack: count final pass as done in case finish_output does an extra pass.
|
|
|
|
|
* The library won't have updated completed_passes.
|
|
|
|
|
*/
|
2019-12-19 00:12:33 +03:00
|
|
|
if (report || max_scans != 0)
|
|
|
|
|
progress.pub.completed_passes = progress.pub.total_passes;
|
1994-09-24 04:00:00 +04:00
|
|
|
|
libjpeg API: Support reading/writing ICC profiles
This commit does the following:
-- Merges the two glueware functions (read_icc_profile() and
write_icc_profile()) from iccjpeg.c, which is contained in downstream
projects such as LCMS, Ghostscript, Mozilla, etc. These functions were
originally intended for inclusion in libjpeg, but Tom Lane left the IJG
before that could be accomplished. Since then, programs and libraries
that needed to embed/extract ICC profiles in JPEG files had to include
their own local copy of iccjpeg.c, which is suboptimal.
-- The new functions were prefixed with jpeg_ and split into separate
files for the compressor and decompressor, per the existing libjpeg
coding standards.
-- jpeg_write_icc_profile() was made slightly more fault-tolerant.
It will now trigger a libjpeg error if it is called before
jpeg_start_compress() or if it is passed NULL arguments.
-- jpeg_read_icc_profile() was made slightly more fault-tolerant.
It will now trigger a libjpeg error if it is called before
jpeg_read_header() or if it is passed NULL arguments. It will also
now trigger libjpeg warnings if the ICC profile data is corrupt.
-- The code comments have been wordsmithed.
-- Note that the one-line setup_read_icc_profile() function was not
included. Instead, libjpeg.txt now documents the need to call
jpeg_save_markers(cinfo, JPEG_APP0 + 2, 0xFFFF) prior to calling
jpeg_read_header(), if jpeg_read_icc_profile() is to be used.
-- Adds documentation for the new functions to libjpeg.txt.
-- Adds an -icc switch to cjpeg and jpegtran that allows those programs
to embed an ICC profile in the JPEG files they generate.
-- Adds an -icc switch to djpeg that allows that program to extract an
ICC profile from a JPEG file while decompressing.
-- Adds appropriate unit tests for all of the above.
-- Bumps the SO_AGE of the libjpeg API library to indicate the presence
of new API functions.
Note that the licensing information was obtained from:
https://github.com/mm2/Little-CMS/issues/37#issuecomment-66450180
2017-01-20 00:18:57 +03:00
|
|
|
if (icc_filename != NULL) {
|
|
|
|
|
FILE *icc_file;
|
|
|
|
|
JOCTET *icc_profile;
|
|
|
|
|
unsigned int icc_len;
|
|
|
|
|
|
|
|
|
|
if ((icc_file = fopen(icc_filename, WRITE_BINARY)) == NULL) {
|
|
|
|
|
fprintf(stderr, "%s: can't open %s\n", progname, icc_filename);
|
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
|
}
|
|
|
|
|
if (jpeg_read_icc_profile(&cinfo, &icc_profile, &icc_len)) {
|
|
|
|
|
if (fwrite(icc_profile, icc_len, 1, icc_file) < 1) {
|
|
|
|
|
fprintf(stderr, "%s: can't read ICC profile from %s\n", progname,
|
|
|
|
|
icc_filename);
|
|
|
|
|
free(icc_profile);
|
|
|
|
|
fclose(icc_file);
|
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
|
}
|
|
|
|
|
free(icc_profile);
|
|
|
|
|
fclose(icc_file);
|
|
|
|
|
} else if (cinfo.err->msg_code != JWRN_BOGUS_ICC)
|
|
|
|
|
fprintf(stderr, "%s: no ICC profile data in JPEG file\n", progname);
|
|
|
|
|
}
|
|
|
|
|
|
1994-09-24 04:00:00 +04:00
|
|
|
/* Finish decompression and release memory.
|
|
|
|
|
* I must do it in this order because output module has allocated memory
|
|
|
|
|
* of lifespan JPOOL_IMAGE; it needs to finish before releasing memory.
|
|
|
|
|
*/
|
|
|
|
|
(*dest_mgr->finish_output) (&cinfo, dest_mgr);
|
Improve code formatting consistency
With rare exceptions ...
- Always separate line continuation characters by one space from
preceding code.
- Always use two-space indentation. Never use tabs.
- Always use K&R-style conditional blocks.
- Always surround operators with spaces, except in raw assembly code.
- Always put a space after, but not before, a comma.
- Never put a space between type casts and variables/function calls.
- Never put a space between the function name and the argument list in
function declarations and prototypes.
- Always surround braces ('{' and '}') with spaces.
- Always surround statements (if, for, else, catch, while, do, switch)
with spaces.
- Always attach pointer symbols ('*' and '**') to the variable or
function name.
- Always precede pointer symbols ('*' and '**') by a space in type
casts.
- Use the MIN() macro from jpegint.h within the libjpeg and TurboJPEG
API libraries (using min() from tjutil.h is still necessary for
TJBench.)
- Where it makes sense (particularly in the TurboJPEG code), put a blank
line after variable declaration blocks.
- Always separate statements in one-liners by two spaces.
The purpose of this was to ease maintenance on my part and also to make
it easier for contributors to figure out how to format patch
submissions. This was admittedly confusing (even to me sometimes) when
we had 3 or 4 different style conventions in the same source tree. The
new convention is more consistent with the formatting of other OSS code
bases.
This commit corrects deviations from the chosen formatting style in the
libjpeg API code and reformats the TurboJPEG API code such that it
conforms to the same standard.
NOTES:
- Although it is no longer necessary for the function name in function
declarations to begin in Column 1 (this was historically necessary
because of the ansi2knr utility, which allowed libjpeg to be built
with non-ANSI compilers), we retain that formatting for the libjpeg
code because it improves readability when using libjpeg's function
attribute macros (GLOBAL(), etc.)
- This reformatting project was accomplished with the help of AStyle and
Uncrustify, although neither was completely up to the task, and thus
a great deal of manual tweaking was required. Note to developers of
code formatting utilities: the libjpeg-turbo code base is an
excellent test bed, because AFAICT, it breaks every single one of the
utilities that are currently available.
- The legacy (MMX, SSE, 3DNow!) assembly code for i386 has been
formatted to match the SSE2 code (refer to
ff5685d5344273df321eb63a005eaae19d2496e3.) I hadn't intended to
bother with this, but the Loongson MMI implementation demonstrated
that there is still academic value to the MMX implementation, as an
algorithmic model for other 64-bit vector implementations. Thus, it
is desirable to improve its readability in the same manner as that of
the SSE2 implementation.
2018-03-08 19:55:20 +03:00
|
|
|
(void)jpeg_finish_decompress(&cinfo);
|
1994-09-24 04:00:00 +04:00
|
|
|
jpeg_destroy_decompress(&cinfo);
|
|
|
|
|
|
1994-12-07 03:00:00 +03:00
|
|
|
/* Close files, if we opened them */
|
|
|
|
|
if (input_file != stdin)
|
|
|
|
|
fclose(input_file);
|
|
|
|
|
if (output_file != stdout)
|
|
|
|
|
fclose(output_file);
|
|
|
|
|
|
2019-12-19 00:12:33 +03:00
|
|
|
if (report || max_scans != 0)
|
|
|
|
|
end_progress_monitor((j_common_ptr)&cinfo);
|
1994-09-24 04:00:00 +04:00
|
|
|
|
2020-01-09 00:01:38 +03:00
|
|
|
if (memsrc)
|
2013-01-19 03:42:31 +04:00
|
|
|
free(inbuffer);
|
|
|
|
|
|
1994-09-24 04:00:00 +04:00
|
|
|
/* All done. */
|
|
|
|
|
exit(jerr.num_warnings ? EXIT_WARNING : EXIT_SUCCESS);
|
2014-05-09 22:00:32 +04:00
|
|
|
return 0; /* suppress no-return-value warnings */
|
1994-09-24 04:00:00 +04:00
|
|
|
}
|
