19c791cdac
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.
396 lines
15 KiB
C
396 lines
15 KiB
C
/*
|
|
* Copyright (C)2011-2012, 2014-2015, 2017 D. R. Commander.
|
|
* All Rights Reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* - Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* - Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* - Neither the name of the libjpeg-turbo Project nor the names of its
|
|
* contributors may be used to endorse or promote products derived from this
|
|
* software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/*
|
|
* This program demonstrates how to compress, decompress, and transform JPEG
|
|
* images using the TurboJPEG C API
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <turbojpeg.h>
|
|
|
|
|
|
#ifdef _WIN32
|
|
#define strcasecmp stricmp
|
|
#define strncasecmp strnicmp
|
|
#endif
|
|
|
|
#define _throw(action, message) { \
|
|
printf("ERROR in line %d while %s:\n%s\n", __LINE__, action, message); \
|
|
retval = -1; goto bailout; \
|
|
}
|
|
|
|
#define _throwtj(action) _throw(action, tjGetErrorStr2(tjInstance))
|
|
|
|
#define _throwunix(action) _throw(action, strerror(errno))
|
|
|
|
#define DEFAULT_SUBSAMP TJSAMP_444
|
|
#define DEFAULT_QUALITY 95
|
|
|
|
|
|
const char *subsampName[TJ_NUMSAMP] = {
|
|
"4:4:4", "4:2:2", "4:2:0", "Grayscale", "4:4:0", "4:1:1"
|
|
};
|
|
|
|
const char *colorspaceName[TJ_NUMCS] = {
|
|
"RGB", "YCbCr", "GRAY", "CMYK", "YCCK"
|
|
};
|
|
|
|
tjscalingfactor *scalingFactors = NULL;
|
|
int numScalingFactors = 0;
|
|
|
|
|
|
/* DCT filter example. This produces a negative of the image. */
|
|
|
|
int customFilter(short *coeffs, tjregion arrayRegion, tjregion planeRegion,
|
|
int componentIndex, int transformIndex,
|
|
tjtransform *transform)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < arrayRegion.w * arrayRegion.h; i++)
|
|
coeffs[i] = -coeffs[i];
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
void usage(char *programName)
|
|
{
|
|
int i;
|
|
|
|
printf("\nUSAGE: %s <Input image> <Output image> [options]\n\n",
|
|
programName);
|
|
|
|
printf("Input and output images can be in Windows BMP or PBMPLUS (PPM/PGM) format. If\n");
|
|
printf("either filename ends in a .jpg extension, then the TurboJPEG API will be used\n");
|
|
printf("to compress or decompress the image.\n\n");
|
|
|
|
printf("Compression Options (used if the output image is a JPEG image)\n");
|
|
printf("--------------------------------------------------------------\n\n");
|
|
|
|
printf("-subsamp <444|422|420|gray> = Apply this level of chrominance subsampling when\n");
|
|
printf(" compressing the output image. The default is to use the same level of\n");
|
|
printf(" subsampling as in the input image, if the input image is also a JPEG\n");
|
|
printf(" image, or to use grayscale if the input image is a grayscale non-JPEG\n");
|
|
printf(" image, or to use %s subsampling otherwise.\n\n",
|
|
subsampName[DEFAULT_SUBSAMP]);
|
|
|
|
printf("-q <1-100> = Compress the output image with this JPEG quality level\n");
|
|
printf(" (default = %d).\n\n", DEFAULT_QUALITY);
|
|
|
|
printf("Decompression Options (used if the input image is a JPEG image)\n");
|
|
printf("---------------------------------------------------------------\n\n");
|
|
|
|
printf("-scale M/N = Scale the input image by a factor of M/N when decompressing it.\n");
|
|
printf("(M/N = ");
|
|
for (i = 0; i < numScalingFactors; i++) {
|
|
printf("%d/%d", scalingFactors[i].num, scalingFactors[i].denom);
|
|
if (numScalingFactors == 2 && i != numScalingFactors - 1)
|
|
printf(" or ");
|
|
else if (numScalingFactors > 2) {
|
|
if (i != numScalingFactors - 1)
|
|
printf(", ");
|
|
if (i == numScalingFactors - 2)
|
|
printf("or ");
|
|
}
|
|
}
|
|
printf(")\n\n");
|
|
|
|
printf("-hflip, -vflip, -transpose, -transverse, -rot90, -rot180, -rot270 =\n");
|
|
printf(" Perform one of these lossless transform operations on the input image\n");
|
|
printf(" prior to decompressing it (these options are mutually exclusive.)\n\n");
|
|
|
|
printf("-grayscale = Perform lossless grayscale conversion on the input image prior\n");
|
|
printf(" to decompressing it (can be combined with the other transform operations\n");
|
|
printf(" above.)\n\n");
|
|
|
|
printf("-crop WxH+X+Y = Perform lossless cropping on the input image prior to\n");
|
|
printf(" decompressing it. X and Y specify the upper left corner of the cropping\n");
|
|
printf(" region, and W and H specify the width and height of the cropping region.\n");
|
|
printf(" X and Y must be evenly divible by the MCU block size (8x8 if the input\n");
|
|
printf(" image was compressed using no subsampling or grayscale, 16x8 if it was\n");
|
|
printf(" compressed using 4:2:2 subsampling, or 16x16 if it was compressed using\n");
|
|
printf(" 4:2:0 subsampling.)\n\n");
|
|
|
|
printf("General Options\n");
|
|
printf("---------------\n\n");
|
|
|
|
printf("-fastupsample = Use the fastest chrominance upsampling algorithm available in\n");
|
|
printf(" the underlying codec.\n\n");
|
|
|
|
printf("-fastdct = Use the fastest DCT/IDCT algorithms available in the underlying\n");
|
|
printf(" codec.\n\n");
|
|
|
|
printf("-accuratedct = Use the most accurate DCT/IDCT algorithms available in the\n");
|
|
printf(" underlying codec.\n\n");
|
|
|
|
exit(1);
|
|
}
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
tjscalingfactor scalingFactor = { 1, 1 };
|
|
int outSubsamp = -1, outQual = -1;
|
|
tjtransform xform;
|
|
int flags = 0;
|
|
int width, height;
|
|
char *inFormat, *outFormat;
|
|
FILE *jpegFile = NULL;
|
|
unsigned char *imgBuf = NULL, *jpegBuf = NULL;
|
|
int retval = 0, i, pixelFormat = TJPF_UNKNOWN;
|
|
tjhandle tjInstance = NULL;
|
|
|
|
if ((scalingFactors = tjGetScalingFactors(&numScalingFactors)) == NULL)
|
|
_throwtj("getting scaling factors");
|
|
memset(&xform, 0, sizeof(tjtransform));
|
|
|
|
if (argc < 3)
|
|
usage(argv[0]);
|
|
|
|
/* Parse arguments. */
|
|
for (i = 3; i < argc; i++) {
|
|
if (!strncasecmp(argv[i], "-sc", 3) && i < argc - 1) {
|
|
int match = 0, temp1 = 0, temp2 = 0, j;
|
|
|
|
if (sscanf(argv[++i], "%d/%d", &temp1, &temp2) < 2)
|
|
usage(argv[0]);
|
|
for (j = 0; j < numScalingFactors; j++) {
|
|
if ((double)temp1 / (double)temp2 == (double)scalingFactors[j].num /
|
|
(double)scalingFactors[j].denom) {
|
|
scalingFactor = scalingFactors[j];
|
|
match = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (match != 1)
|
|
usage(argv[0]);
|
|
} else if (!strncasecmp(argv[i], "-su", 3) && i < argc - 1) {
|
|
i++;
|
|
if (!strncasecmp(argv[i], "g", 1))
|
|
outSubsamp = TJSAMP_GRAY;
|
|
else if (!strcasecmp(argv[i], "444"))
|
|
outSubsamp = TJSAMP_444;
|
|
else if (!strcasecmp(argv[i], "422"))
|
|
outSubsamp = TJSAMP_422;
|
|
else if (!strcasecmp(argv[i], "420"))
|
|
outSubsamp = TJSAMP_420;
|
|
else
|
|
usage(argv[0]);
|
|
} else if (!strncasecmp(argv[i], "-q", 2) && i < argc - 1) {
|
|
outQual = atoi(argv[++i]);
|
|
if (outQual < 1 || outQual > 100)
|
|
usage(argv[0]);
|
|
} else if (!strncasecmp(argv[i], "-g", 2))
|
|
xform.options |= TJXOPT_GRAY;
|
|
else if (!strcasecmp(argv[i], "-hflip"))
|
|
xform.op = TJXOP_HFLIP;
|
|
else if (!strcasecmp(argv[i], "-vflip"))
|
|
xform.op = TJXOP_VFLIP;
|
|
else if (!strcasecmp(argv[i], "-transpose"))
|
|
xform.op = TJXOP_TRANSPOSE;
|
|
else if (!strcasecmp(argv[i], "-transverse"))
|
|
xform.op = TJXOP_TRANSVERSE;
|
|
else if (!strcasecmp(argv[i], "-rot90"))
|
|
xform.op = TJXOP_ROT90;
|
|
else if (!strcasecmp(argv[i], "-rot180"))
|
|
xform.op = TJXOP_ROT180;
|
|
else if (!strcasecmp(argv[i], "-rot270"))
|
|
xform.op = TJXOP_ROT270;
|
|
else if (!strcasecmp(argv[i], "-custom"))
|
|
xform.customFilter = customFilter;
|
|
else if (!strncasecmp(argv[i], "-c", 2) && i < argc - 1) {
|
|
if (sscanf(argv[++i], "%dx%d+%d+%d", &xform.r.w, &xform.r.h, &xform.r.x,
|
|
&xform.r.y) < 4 ||
|
|
xform.r.x < 0 || xform.r.y < 0 || xform.r.w < 1 || xform.r.h < 1)
|
|
usage(argv[0]);
|
|
xform.options |= TJXOPT_CROP;
|
|
} else if (!strcasecmp(argv[i], "-fastupsample")) {
|
|
printf("Using fast upsampling code\n");
|
|
flags |= TJFLAG_FASTUPSAMPLE;
|
|
} else if (!strcasecmp(argv[i], "-fastdct")) {
|
|
printf("Using fastest DCT/IDCT algorithm\n");
|
|
flags |= TJFLAG_FASTDCT;
|
|
} else if (!strcasecmp(argv[i], "-accuratedct")) {
|
|
printf("Using most accurate DCT/IDCT algorithm\n");
|
|
flags |= TJFLAG_ACCURATEDCT;
|
|
} else usage(argv[0]);
|
|
}
|
|
|
|
/* Determine input and output image formats based on file extensions. */
|
|
inFormat = strrchr(argv[1], '.');
|
|
outFormat = strrchr(argv[2], '.');
|
|
if (inFormat == NULL || outFormat == NULL || strlen(inFormat) < 2 ||
|
|
strlen(outFormat) < 2)
|
|
usage(argv[0]);
|
|
inFormat = &inFormat[1];
|
|
outFormat = &outFormat[1];
|
|
|
|
if (!strcasecmp(inFormat, "jpg")) {
|
|
/* Input image is a JPEG image. Decompress and/or transform it. */
|
|
long size;
|
|
int inSubsamp, inColorspace;
|
|
int doTransform = (xform.op != TJXOP_NONE || xform.options != 0 ||
|
|
xform.customFilter != NULL);
|
|
unsigned long jpegSize;
|
|
|
|
/* Read the JPEG file into memory. */
|
|
if ((jpegFile = fopen(argv[1], "rb")) == NULL)
|
|
_throwunix("opening input file");
|
|
if (fseek(jpegFile, 0, SEEK_END) < 0 || ((size = ftell(jpegFile)) < 0) ||
|
|
fseek(jpegFile, 0, SEEK_SET) < 0)
|
|
_throwunix("determining input file size");
|
|
if (size == 0)
|
|
_throw("determining input file size", "Input file contains no data");
|
|
jpegSize = (unsigned long)size;
|
|
if ((jpegBuf = (unsigned char *)tjAlloc(jpegSize)) == NULL)
|
|
_throwunix("allocating JPEG buffer");
|
|
if (fread(jpegBuf, jpegSize, 1, jpegFile) < 1)
|
|
_throwunix("reading input file");
|
|
fclose(jpegFile); jpegFile = NULL;
|
|
|
|
if (doTransform) {
|
|
/* Transform it. */
|
|
unsigned char *dstBuf = NULL; /* Dynamically allocate the JPEG buffer */
|
|
unsigned long dstSize = 0;
|
|
|
|
if ((tjInstance = tjInitTransform()) == NULL)
|
|
_throwtj("initializing transformer");
|
|
xform.options |= TJXOPT_TRIM;
|
|
if (tjTransform(tjInstance, jpegBuf, jpegSize, 1, &dstBuf, &dstSize,
|
|
&xform, flags) < 0)
|
|
_throwtj("transforming input image");
|
|
tjFree(jpegBuf);
|
|
jpegBuf = dstBuf;
|
|
jpegSize = dstSize;
|
|
} else {
|
|
if ((tjInstance = tjInitDecompress()) == NULL)
|
|
_throwtj("initializing decompressor");
|
|
}
|
|
|
|
if (tjDecompressHeader3(tjInstance, jpegBuf, jpegSize, &width, &height,
|
|
&inSubsamp, &inColorspace) < 0)
|
|
_throwtj("reading JPEG header");
|
|
|
|
printf("%s Image: %d x %d pixels, %s subsampling, %s colorspace\n",
|
|
(doTransform ? "Transformed" : "Input"), width, height,
|
|
subsampName[inSubsamp], colorspaceName[inColorspace]);
|
|
|
|
if (!strcasecmp(outFormat, "jpg") && doTransform &&
|
|
scalingFactor.num == 1 && scalingFactor.denom == 1 && outSubsamp < 0 &&
|
|
outQual < 0) {
|
|
/* Input image has been transformed, and no re-compression options
|
|
have been selected. Write the transformed image to disk and exit. */
|
|
if ((jpegFile = fopen(argv[2], "wb")) == NULL)
|
|
_throwunix("opening output file");
|
|
if (fwrite(jpegBuf, jpegSize, 1, jpegFile) < 1)
|
|
_throwunix("writing output file");
|
|
fclose(jpegFile); jpegFile = NULL;
|
|
goto bailout;
|
|
}
|
|
|
|
/* Scaling and/or a non-JPEG output image format and/or compression options
|
|
have been selected, so we need to decompress the input/transformed
|
|
image. */
|
|
width = TJSCALED(width, scalingFactor);
|
|
height = TJSCALED(height, scalingFactor);
|
|
if (outSubsamp < 0)
|
|
outSubsamp = inSubsamp;
|
|
|
|
pixelFormat = TJPF_BGRX;
|
|
if ((imgBuf = (unsigned char *)tjAlloc(width * height *
|
|
tjPixelSize[pixelFormat])) == NULL)
|
|
_throwunix("allocating uncompressed image buffer");
|
|
|
|
if (tjDecompress2(tjInstance, jpegBuf, jpegSize, imgBuf, width, 0, height,
|
|
pixelFormat, flags) < 0)
|
|
_throwtj("decompressing JPEG image");
|
|
tjFree(jpegBuf); jpegBuf = NULL;
|
|
tjDestroy(tjInstance); tjInstance = NULL;
|
|
} else {
|
|
/* Input image is not a JPEG image. Load it into memory. */
|
|
if ((imgBuf = tjLoadImage(argv[1], &width, 1, &height, &pixelFormat,
|
|
0)) == NULL)
|
|
_throwtj("loading input image");
|
|
if (outSubsamp < 0) {
|
|
if (pixelFormat == TJPF_GRAY)
|
|
outSubsamp = TJSAMP_GRAY;
|
|
else
|
|
outSubsamp = TJSAMP_444;
|
|
}
|
|
printf("Input Image: %d x %d pixels\n", width, height);
|
|
}
|
|
|
|
printf("Output Image (%s): %d x %d pixels", outFormat, width, height);
|
|
|
|
if (!strcasecmp(outFormat, "jpg")) {
|
|
/* Output image format is JPEG. Compress the uncompressed image. */
|
|
unsigned char *jpegBuf = NULL; /* Dynamically allocate the JPEG buffer */
|
|
unsigned long jpegSize = 0;
|
|
|
|
if (outQual < 0)
|
|
outQual = DEFAULT_QUALITY;
|
|
printf(", %s subsampling, quality = %d\n", subsampName[outSubsamp],
|
|
outQual);
|
|
|
|
if ((tjInstance = tjInitCompress()) == NULL)
|
|
_throwtj("initializing compressor");
|
|
if (tjCompress2(tjInstance, imgBuf, width, 0, height, pixelFormat,
|
|
&jpegBuf, &jpegSize, outSubsamp, outQual, flags) < 0)
|
|
_throwtj("compressing image");
|
|
tjDestroy(tjInstance); tjInstance = NULL;
|
|
|
|
/* Write the JPEG image to disk. */
|
|
if ((jpegFile = fopen(argv[2], "wb")) == NULL)
|
|
_throwunix("opening output file");
|
|
if (fwrite(jpegBuf, jpegSize, 1, jpegFile) < 1)
|
|
_throwunix("writing output file");
|
|
tjDestroy(tjInstance); tjInstance = NULL;
|
|
fclose(jpegFile); jpegFile = NULL;
|
|
tjFree(jpegBuf); jpegBuf = NULL;
|
|
} else {
|
|
/* Output image format is not JPEG. Save the uncompressed image
|
|
directly to disk. */
|
|
printf("\n");
|
|
if (tjSaveImage(argv[2], imgBuf, width, 0, height, pixelFormat, 0) < 0)
|
|
_throwtj("saving output image");
|
|
}
|
|
|
|
bailout:
|
|
if (imgBuf) tjFree(imgBuf);
|
|
if (tjInstance) tjDestroy(tjInstance);
|
|
if (jpegBuf) tjFree(jpegBuf);
|
|
if (jpegFile) fclose(jpegFile);
|
|
return retval;
|
|
}
|