/*
- * Copyright (C)2009-2014 D. R. Commander. All Rights Reserved.
+ * Copyright (C)2009-2014, 2017-2019, 2022-2023 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:
* This program tests the various code paths in the TurboJPEG C Wrapper
*/
+#ifdef _MSC_VER
+#define _CRT_SECURE_NO_DEPRECATE
+#endif
+
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <limits.h>
#include <errno.h>
-#include "./tjutil.h"
-#include "./turbojpeg.h"
+#include "tjutil.h"
+#include "turbojpeg.h"
+#include "md5/md5.h"
+#include "jconfigint.h"
#ifdef _WIN32
- #include <time.h>
- #define random() rand()
+#include <time.h>
+#include <process.h>
+#define random() rand()
+#define getpid() _getpid()
+#else
+#include <unistd.h>
#endif
-void usage(char *progName)
+static void usage(char *progName)
{
- printf("\nUSAGE: %s [options]\n", progName);
- printf("Options:\n");
- printf("-yuv = test YUV encoding/decoding support\n");
- printf("-noyuvpad = do not pad each line of each Y, U, and V plane to the nearest\n");
- printf(" 4-byte boundary\n");
- printf("-alloc = test automatic buffer allocation\n");
- exit(1);
+ printf("\nUSAGE: %s [options]\n\n", progName);
+ printf("Options:\n");
+ printf("-yuv = test YUV encoding/compression/decompression/decoding\n");
+ printf(" (8-bit data precision only)\n");
+ printf("-noyuvpad = do not pad each row in each Y, U, and V plane to the nearest\n");
+ printf(" multiple of 4 bytes\n");
+ printf("-precision N = test N-bit data precision (N is 8, 12, or 16; default is 8; if N\n");
+ printf(" is 16, then -lossless is implied)\n");
+ printf("-lossless = test lossless JPEG compression/decompression\n");
+ printf("-alloc = test automatic JPEG buffer allocation\n");
+ printf("-bmp = test packed-pixel image I/O\n");
+ exit(1);
}
-#define _throwtj() {printf("TurboJPEG ERROR:\n%s\n", tjGetErrorStr()); \
- bailout();}
-#define _tj(f) {if((f)==-1) _throwtj();}
-#define _throw(m) {printf("ERROR: %s\n", m); bailout();}
+#define THROW_TJ(handle) { \
+ printf("TurboJPEG ERROR:\n%s\n", tj3GetErrorStr(handle)); \
+ BAILOUT() \
+}
+#define TRY_TJ(handle, f) { if ((f) == -1) THROW_TJ(handle); }
+#define THROW(m) { printf("ERROR: %s\n", m); BAILOUT() }
+#define THROW_MD5(filename, md5sum, ref) { \
+ printf("\n%s has an MD5 sum of %s.\n Should be %s.\n", filename, md5sum, \
+ ref); \
+ BAILOUT() \
+}
-const char *subNameLong[TJ_NUMSAMP]=
-{
- "4:4:4", "4:2:2", "4:2:0", "GRAY", "4:4:0", "4:1:1"
+const char *subNameLong[TJ_NUMSAMP] = {
+ "4:4:4", "4:2:2", "4:2:0", "GRAY", "4:4:0", "4:1:1", "4:4:1"
+};
+const char *subName[TJ_NUMSAMP] = {
+ "444", "422", "420", "GRAY", "440", "411", "441"
};
-const char *subName[TJ_NUMSAMP]={"444", "422", "420", "GRAY", "440", "411"};
-const char *pixFormatStr[TJ_NUMPF]=
-{
- "RGB", "BGR", "RGBX", "BGRX", "XBGR", "XRGB", "Grayscale",
- "RGBA", "BGRA", "ABGR", "ARGB", "CMYK"
+const char *pixFormatStr[TJ_NUMPF] = {
+ "RGB", "BGR", "RGBX", "BGRX", "XBGR", "XRGB", "Grayscale",
+ "RGBA", "BGRA", "ABGR", "ARGB", "CMYK"
};
-const int alphaOffset[TJ_NUMPF] = {-1, -1, -1, -1, -1, -1, -1, 3, 3, 0, 0, -1};
+const int _3sampleFormats[] = { TJPF_RGB, TJPF_BGR };
+const int _4sampleFormats[] = {
+ TJPF_RGBX, TJPF_BGRX, TJPF_XBGR, TJPF_XRGB, TJPF_CMYK
+};
+const int _onlyGray[] = { TJPF_GRAY };
+const int _onlyRGB[] = { TJPF_RGB };
+
+int doYUV = 0, lossless = 0, psv = 1, alloc = 0, yuvAlign = 4;
+int precision = 8, sampleSize, maxSample, tolerance, redToY, yellowToY;
+
+int exitStatus = 0;
+#define BAILOUT() { exitStatus = -1; goto bailout; }
+
+
+static void setVal(void *buf, int index, int value)
+{
+ if (precision == 8)
+ ((unsigned char *)buf)[index] = (unsigned char)value;
+ else if (precision == 12)
+ ((short *)buf)[index] = (short)value;
+ else
+ ((unsigned short *)buf)[index] = (unsigned short)value;
+}
-const int _3byteFormats[]={TJPF_RGB, TJPF_BGR};
-const int _4byteFormats[]={TJPF_RGBX, TJPF_BGRX, TJPF_XBGR, TJPF_XRGB,
- TJPF_CMYK};
-const int _onlyGray[]={TJPF_GRAY};
-const int _onlyRGB[]={TJPF_RGB};
+static void initBuf(void *buf, int w, int h, int pf, int bottomUp)
+{
+ int roffset = tjRedOffset[pf];
+ int goffset = tjGreenOffset[pf];
+ int boffset = tjBlueOffset[pf];
+ int ps = tjPixelSize[pf];
+ int i, index, row, col, halfway = 16;
+
+ if (pf == TJPF_GRAY) {
+ memset(buf, 0, w * h * ps * sampleSize);
+ for (row = 0; row < h; row++) {
+ for (col = 0; col < w; col++) {
+ if (bottomUp) index = (h - row - 1) * w + col;
+ else index = row * w + col;
+ if (((row / 8) + (col / 8)) % 2 == 0)
+ setVal(buf, index, (row < halfway) ? maxSample : 0);
+ else setVal(buf, index, (row < halfway) ? redToY : yellowToY);
+ }
+ }
+ } else if (pf == TJPF_CMYK) {
+ for (i = 0; i < w * h * ps; i++)
+ setVal(buf, i, maxSample);
+ for (row = 0; row < h; row++) {
+ for (col = 0; col < w; col++) {
+ if (bottomUp) index = (h - row - 1) * w + col;
+ else index = row * w + col;
+ if (((row / 8) + (col / 8)) % 2 == 0) {
+ if (row >= halfway) setVal(buf, index * ps + 3, 0);
+ } else {
+ setVal(buf, index * ps + 2, 0);
+ if (row < halfway) setVal(buf, index * ps + 1, 0);
+ }
+ }
+ }
+ } else {
+ memset(buf, 0, w * h * ps * sampleSize);
+ for (row = 0; row < h; row++) {
+ for (col = 0; col < w; col++) {
+ if (bottomUp) index = (h - row - 1) * w + col;
+ else index = row * w + col;
+ if (((row / 8) + (col / 8)) % 2 == 0) {
+ if (row < halfway) {
+ setVal(buf, index * ps + roffset, maxSample);
+ setVal(buf, index * ps + goffset, maxSample);
+ setVal(buf, index * ps + boffset, maxSample);
+ }
+ } else {
+ setVal(buf, index * ps + roffset, maxSample);
+ if (row >= halfway) setVal(buf, index * ps + goffset, maxSample);
+ }
+ }
+ }
+ }
+}
+
+
+#define CHECKVAL(v, cv) { \
+ if (v < cv - tolerance || v > cv + tolerance) { \
+ printf("\nComp. %s at %d,%d should be %d, not %d\n", #v, row, col, cv, \
+ v); \
+ retval = 0; exitStatus = -1; goto bailout; \
+ } \
+}
+
+#define CHECKVAL0(v) { \
+ if (v > tolerance) { \
+ printf("\nComp. %s at %d,%d should be 0, not %d\n", #v, row, col, v); \
+ retval = 0; exitStatus = -1; goto bailout; \
+ } \
+}
+
+#define CHECKVALMAX(v) { \
+ if (v < maxSample - tolerance) { \
+ printf("\nComp. %s at %d,%d should be %d, not %d\n", #v, row, col, \
+ maxSample, v); \
+ retval = 0; exitStatus = -1; goto bailout; \
+ } \
+}
+
+
+static int getVal(void *buf, int index)
+{
+ if (precision == 8)
+ return ((unsigned char *)buf)[index];
+ else if (precision == 12)
+ return ((short *)buf)[index];
+ else
+ return ((unsigned short *)buf)[index];
+}
-int doyuv=0, alloc=0, pad=4;
+static int checkBuf(void *buf, int w, int h, int pf, int subsamp,
+ tjscalingfactor sf, int bottomUp)
+{
+ int roffset = tjRedOffset[pf];
+ int goffset = tjGreenOffset[pf];
+ int boffset = tjBlueOffset[pf];
+ int aoffset = tjAlphaOffset[pf];
+ int ps = tjPixelSize[pf];
+ int index, row, col, retval = 1;
+ int halfway = 16 * sf.num / sf.denom;
+ int blocksize = 8 * sf.num / sf.denom;
+
+ if (pf == TJPF_GRAY) roffset = goffset = boffset = 0;
+
+ if (pf == TJPF_CMYK) {
+ for (row = 0; row < h; row++) {
+ for (col = 0; col < w; col++) {
+ int c, m, y, k;
+
+ if (bottomUp) index = (h - row - 1) * w + col;
+ else index = row * w + col;
+ c = getVal(buf, index * ps);
+ m = getVal(buf, index * ps + 1);
+ y = getVal(buf, index * ps + 2);
+ k = getVal(buf, index * ps + 3);
+ if (((row / blocksize) + (col / blocksize)) % 2 == 0) {
+ CHECKVALMAX(c); CHECKVALMAX(m); CHECKVALMAX(y);
+ if (row < halfway) CHECKVALMAX(k)
+ else CHECKVAL0(k)
+ } else {
+ CHECKVALMAX(c); CHECKVAL0(y); CHECKVALMAX(k);
+ if (row < halfway) CHECKVAL0(m)
+ else CHECKVALMAX(m)
+ }
+ }
+ }
+ return 1;
+ }
+
+ for (row = 0; row < h; row++) {
+ for (col = 0; col < w; col++) {
+ int r, g, b, a;
+
+ if (bottomUp) index = (h - row - 1) * w + col;
+ else index = row * w + col;
+ r = getVal(buf, index * ps + roffset);
+ g = getVal(buf, index * ps + goffset);
+ b = getVal(buf, index * ps + boffset);
+ a = aoffset >= 0 ? getVal(buf, index * ps + aoffset) : maxSample;
+ if (((row / blocksize) + (col / blocksize)) % 2 == 0) {
+ if (row < halfway) {
+ CHECKVALMAX(r); CHECKVALMAX(g); CHECKVALMAX(b);
+ } else {
+ CHECKVAL0(r); CHECKVAL0(g); CHECKVAL0(b);
+ }
+ } else {
+ if (subsamp == TJSAMP_GRAY) {
+ if (row < halfway) {
+ CHECKVAL(r, redToY); CHECKVAL(g, redToY); CHECKVAL(b, redToY);
+ } else {
+ CHECKVAL(r, yellowToY); CHECKVAL(g, yellowToY);
+ CHECKVAL(b, yellowToY);
+ }
+ } else {
+ if (row < halfway) {
+ CHECKVALMAX(r); CHECKVAL0(g); CHECKVAL0(b);
+ } else {
+ CHECKVALMAX(r); CHECKVALMAX(g); CHECKVAL0(b);
+ }
+ }
+ }
+ CHECKVALMAX(a);
+ }
+ }
+
+bailout:
+ if (retval == 0) {
+ for (row = 0; row < h; row++) {
+ for (col = 0; col < w; col++) {
+ if (pf == TJPF_CMYK)
+ printf("%.3d/%.3d/%.3d/%.3d ", getVal(buf, (row * w + col) * ps),
+ getVal(buf, (row * w + col) * ps + 1),
+ getVal(buf, (row * w + col) * ps + 2),
+ getVal(buf, (row * w + col) * ps + 3));
+ else
+ printf("%.3d/%.3d/%.3d ",
+ getVal(buf, (row * w + col) * ps + roffset),
+ getVal(buf, (row * w + col) * ps + goffset),
+ getVal(buf, (row * w + col) * ps + boffset));
+ }
+ printf("\n");
+ }
+ }
+ return retval;
+}
-int exitStatus=0;
-#define bailout() {exitStatus=-1; goto bailout;}
+#define PAD(v, p) ((v + (p) - 1) & (~((p) - 1)))
-void initBuf(unsigned char *buf, int w, int h, int pf, int flags)
+static int checkBufYUV(unsigned char *buf, int w, int h, int subsamp,
+ tjscalingfactor sf)
{
- int roffset=tjRedOffset[pf];
- int goffset=tjGreenOffset[pf];
- int boffset=tjBlueOffset[pf];
- int ps=tjPixelSize[pf];
- int index, row, col, halfway=16;
-
- if(pf==TJPF_GRAY)
- {
- memset(buf, 0, w*h*ps);
- for(row=0; row<h; row++)
- {
- for(col=0; col<w; col++)
- {
- if(flags&TJFLAG_BOTTOMUP) index=(h-row-1)*w+col;
- else index=row*w+col;
- if(((row/8)+(col/8))%2==0) buf[index]=(row<halfway)? 255:0;
- else buf[index]=(row<halfway)? 76:226;
- }
- }
- }
- else if(pf==TJPF_CMYK)
- {
- memset(buf, 255, w*h*ps);
- for(row=0; row<h; row++)
- {
- for(col=0; col<w; col++)
- {
- if(flags&TJFLAG_BOTTOMUP) index=(h-row-1)*w+col;
- else index=row*w+col;
- if(((row/8)+(col/8))%2==0)
- {
- if(row>=halfway) buf[index*ps+3]=0;
- }
- else
- {
- buf[index*ps+2]=0;
- if(row<halfway) buf[index*ps+1]=0;
- }
- }
- }
- }
- else
- {
- memset(buf, 0, w*h*ps);
- for(row=0; row<h; row++)
- {
- for(col=0; col<w; col++)
- {
- if(flags&TJFLAG_BOTTOMUP) index=(h-row-1)*w+col;
- else index=row*w+col;
- if(((row/8)+(col/8))%2==0)
- {
- if(row<halfway)
- {
- buf[index*ps+roffset]=255;
- buf[index*ps+goffset]=255;
- buf[index*ps+boffset]=255;
- }
- }
- else
- {
- buf[index*ps+roffset]=255;
- if(row>=halfway) buf[index*ps+goffset]=255;
- }
- }
- }
- }
+ int row, col;
+ int hsf = tjMCUWidth[subsamp] / 8, vsf = tjMCUHeight[subsamp] / 8;
+ int pw = PAD(w, hsf), ph = PAD(h, vsf);
+ int cw = pw / hsf, ch = ph / vsf;
+ int ypitch = PAD(pw, yuvAlign), uvpitch = PAD(cw, yuvAlign);
+ int retval = 1;
+ int halfway = 16 * sf.num / sf.denom;
+ int blocksize = 8 * sf.num / sf.denom;
+
+ for (row = 0; row < ph; row++) {
+ for (col = 0; col < pw; col++) {
+ unsigned char y = buf[ypitch * row + col];
+
+ if (((row / blocksize) + (col / blocksize)) % 2 == 0) {
+ if (row < halfway) CHECKVALMAX(y)
+ else CHECKVAL0(y);
+ } else {
+ if (row < halfway) CHECKVAL(y, 76)
+ else CHECKVAL(y, 225);
+ }
+ }
+ }
+ if (subsamp != TJSAMP_GRAY) {
+ halfway = 16 / vsf * sf.num / sf.denom;
+
+ for (row = 0; row < ch; row++) {
+ for (col = 0; col < cw; col++) {
+ unsigned char u = buf[ypitch * ph + (uvpitch * row + col)],
+ v = buf[ypitch * ph + uvpitch * ch + (uvpitch * row + col)];
+
+ if (((row * vsf / blocksize) + (col * hsf / blocksize)) % 2 == 0) {
+ CHECKVAL(u, 128); CHECKVAL(v, 128);
+ } else {
+ if (row < halfway) {
+ CHECKVAL(u, 85); CHECKVALMAX(v);
+ } else {
+ CHECKVAL0(u); CHECKVAL(v, 149);
+ }
+ }
+ }
+ }
+ }
+
+bailout:
+ if (retval == 0) {
+ for (row = 0; row < ph; row++) {
+ for (col = 0; col < pw; col++)
+ printf("%.3d ", buf[ypitch * row + col]);
+ printf("\n");
+ }
+ printf("\n");
+ for (row = 0; row < ch; row++) {
+ for (col = 0; col < cw; col++)
+ printf("%.3d ", buf[ypitch * ph + (uvpitch * row + col)]);
+ printf("\n");
+ }
+ printf("\n");
+ for (row = 0; row < ch; row++) {
+ for (col = 0; col < cw; col++)
+ printf("%.3d ",
+ buf[ypitch * ph + uvpitch * ch + (uvpitch * row + col)]);
+ printf("\n");
+ }
+ }
+
+ return retval;
}
-#define checkval(v, cv) { \
- if(v<cv-1 || v>cv+1) { \
- printf("\nComp. %s at %d,%d should be %d, not %d\n", \
- #v, row, col, cv, v); \
- retval=0; exitStatus=-1; goto bailout; \
- }}
+static void writeJPEG(unsigned char *jpegBuf, size_t jpegSize, char *filename)
+{
+ FILE *file = fopen(filename, "wb");
+
+ if (!file || fwrite(jpegBuf, jpegSize, 1, file) != 1) {
+#if _USE_PRODUCT_TV
+ char err_str[256];
+ strerror_r(errno, err_str, 256);
+ printf("ERROR: Could not write to %s.\n%s\n", filename, err_str);
+#else
+ printf("ERROR: Could not write to %s.\n%s\n", filename, strerror(errno));
+#endif
+ BAILOUT()
+ }
+
+bailout:
+ if (file) fclose(file);
+}
-#define checkval0(v) { \
- if(v>1) { \
- printf("\nComp. %s at %d,%d should be 0, not %d\n", #v, row, col, v); \
- retval=0; exitStatus=-1; goto bailout; \
- }}
-#define checkval255(v) { \
- if(v<254) { \
- printf("\nComp. %s at %d,%d should be 255, not %d\n", #v, row, col, v); \
- retval=0; exitStatus=-1; goto bailout; \
- }}
+static void compTest(tjhandle handle, unsigned char **dstBuf, size_t *dstSize,
+ int w, int h, int pf, char *basename)
+{
+ char tempStr[1024];
+ void *srcBuf = NULL;
+ unsigned char *yuvBuf = NULL;
+ const char *pfStr = pixFormatStr[pf];
+ int bottomUp = tj3Get(handle, TJPARAM_BOTTOMUP);
+ int subsamp = tj3Get(handle, TJPARAM_SUBSAMP);
+ int jpegPSV = tj3Get(handle, TJPARAM_LOSSLESSPSV);
+ int jpegQual = tj3Get(handle, TJPARAM_QUALITY);
+ const char *buStrLong = bottomUp ? "Bottom-Up" : "Top-Down ";
+ const char *buStr = bottomUp ? "BU" : "TD";
+
+ if ((srcBuf = malloc(w * h * tjPixelSize[pf] * sampleSize)) == NULL)
+ THROW("Memory allocation failure");
+ initBuf(srcBuf, w, h, pf, bottomUp);
+
+ if (*dstBuf && *dstSize > 0) memset(*dstBuf, 0, *dstSize);
+
+ if (doYUV) {
+ size_t yuvSize = tj3YUVBufSize(w, yuvAlign, h, subsamp);
+ tjscalingfactor sf = { 1, 1 };
+ tjhandle handle2 = NULL;
+
+ if ((handle2 = tj3Init(TJINIT_COMPRESS)) == NULL)
+ THROW_TJ(NULL);
+ TRY_TJ(handle2, tj3Set(handle2, TJPARAM_BOTTOMUP, bottomUp));
+ TRY_TJ(handle2, tj3Set(handle2, TJPARAM_SUBSAMP, subsamp));
+
+ if ((yuvBuf = (unsigned char *)malloc(yuvSize)) == NULL)
+ THROW("Memory allocation failure");
+ memset(yuvBuf, 0, yuvSize);
+
+ printf("%s %s -> YUV %s ... ", pfStr, buStrLong, subNameLong[subsamp]);
+ TRY_TJ(handle2, tj3EncodeYUV8(handle2, (unsigned char *)srcBuf, w, 0, h,
+ pf, yuvBuf, yuvAlign));
+ tj3Destroy(handle2);
+ if (checkBufYUV(yuvBuf, w, h, subsamp, sf)) printf("Passed.\n");
+ else printf("FAILED!\n");
+
+ printf("YUV %s %s -> JPEG Q%d ... ", subNameLong[subsamp], buStrLong,
+ jpegQual);
+ TRY_TJ(handle, tj3CompressFromYUV8(handle, yuvBuf, w, yuvAlign, h, dstBuf,
+ dstSize));
+ } else {
+ if (lossless)
+ printf("%s %s -> LOSSLESS PSV%d ... ", pfStr, buStrLong, jpegPSV);
+ else
+ printf("%s %s -> %s Q%d ... ", pfStr, buStrLong, subNameLong[subsamp],
+ jpegQual);
+ if (precision == 8) {
+ TRY_TJ(handle, tj3Compress8(handle, (unsigned char *)srcBuf, w, 0, h, pf,
+ dstBuf, dstSize));
+ } else if (precision == 12) {
+ TRY_TJ(handle, tj3Compress12(handle, (short *)srcBuf, w, 0, h, pf,
+ dstBuf, dstSize));
+ } else {
+ TRY_TJ(handle, tj3Compress16(handle, (unsigned short *)srcBuf, w, 0, h,
+ pf, dstBuf, dstSize));
+ }
+ }
+
+ if (lossless)
+ SNPRINTF(tempStr, 1024, "%s_enc%d_%s_%s_LOSSLESS_PSV%d.jpg", basename,
+ precision, pfStr, buStr, jpegPSV);
+ else
+ SNPRINTF(tempStr, 1024, "%s_enc%d_%s_%s_%s_Q%d.jpg", basename, precision,
+ pfStr, buStr, subName[subsamp], jpegQual);
+ writeJPEG(*dstBuf, *dstSize, tempStr);
+ printf("Done.\n Result in %s\n", tempStr);
+
+bailout:
+ free(yuvBuf);
+ free(srcBuf);
+}
-int checkBuf(unsigned char *buf, int w, int h, int pf, int subsamp,
- tjscalingfactor sf, int flags)
+static void _decompTest(tjhandle handle, unsigned char *jpegBuf,
+ size_t jpegSize, int w, int h, int pf, char *basename,
+ int subsamp, tjscalingfactor sf)
{
- int roffset=tjRedOffset[pf];
- int goffset=tjGreenOffset[pf];
- int boffset=tjBlueOffset[pf];
- int aoffset=alphaOffset[pf];
- int ps=tjPixelSize[pf];
- int index, row, col, retval=1;
- int halfway=16*sf.num/sf.denom;
- int blocksize=8*sf.num/sf.denom;
-
- if(pf==TJPF_CMYK)
- {
- for(row=0; row<h; row++)
- {
- for(col=0; col<w; col++)
- {
- unsigned char c, m, y, k;
- if(flags&TJFLAG_BOTTOMUP) index=(h-row-1)*w+col;
- else index=row*w+col;
- c=buf[index*ps];
- m=buf[index*ps+1];
- y=buf[index*ps+2];
- k=buf[index*ps+3];
- if(((row/blocksize)+(col/blocksize))%2==0)
- {
- checkval255(c); checkval255(m); checkval255(y);
- if(row<halfway) checkval255(k)
- else checkval0(k)
- }
- else
- {
- checkval255(c); checkval0(y); checkval255(k);
- if(row<halfway) checkval0(m)
- else checkval255(m)
- }
- }
- }
- return 1;
- }
-
- for(row=0; row<h; row++)
- {
- for(col=0; col<w; col++)
- {
- unsigned char r, g, b, a;
- if(flags&TJFLAG_BOTTOMUP) index=(h-row-1)*w+col;
- else index=row*w+col;
- r=buf[index*ps+roffset];
- g=buf[index*ps+goffset];
- b=buf[index*ps+boffset];
- a=aoffset>=0? buf[index*ps+aoffset]:0xFF;
- if(((row/blocksize)+(col/blocksize))%2==0)
- {
- if(row<halfway)
- {
- checkval255(r); checkval255(g); checkval255(b);
- }
- else
- {
- checkval0(r); checkval0(g); checkval0(b);
- }
- }
- else
- {
- if(subsamp==TJSAMP_GRAY)
- {
- if(row<halfway)
- {
- checkval(r, 76); checkval(g, 76); checkval(b, 76);
- }
- else
- {
- checkval(r, 226); checkval(g, 226); checkval(b, 226);
- }
- }
- else
- {
- if(row<halfway)
- {
- checkval255(r); checkval0(g); checkval0(b);
- }
- else
- {
- checkval255(r); checkval255(g); checkval0(b);
- }
- }
- }
- checkval255(a);
- }
- }
-
- bailout:
- if(retval==0)
- {
- for(row=0; row<h; row++)
- {
- for(col=0; col<w; col++)
- {
- if(pf==TJPF_CMYK)
- printf("%.3d/%.3d/%.3d/%.3d ", buf[(row*w+col)*ps],
- buf[(row*w+col)*ps+1], buf[(row*w+col)*ps+2],
- buf[(row*w+col)*ps+3]);
- else
- printf("%.3d/%.3d/%.3d ", buf[(row*w+col)*ps+roffset],
- buf[(row*w+col)*ps+goffset], buf[(row*w+col)*ps+boffset]);
- }
- printf("\n");
- }
- }
- return retval;
+ void *dstBuf = NULL;
+ unsigned char *yuvBuf = NULL;
+ int _hdrw = 0, _hdrh = 0, _hdrsubsamp;
+ int scaledWidth = TJSCALED(w, sf);
+ int scaledHeight = TJSCALED(h, sf);
+ size_t dstSize = 0;
+ int bottomUp = tj3Get(handle, TJPARAM_BOTTOMUP);
+
+ TRY_TJ(handle, tj3SetScalingFactor(handle, sf));
+
+ TRY_TJ(handle, tj3DecompressHeader(handle, jpegBuf, jpegSize));
+ _hdrw = tj3Get(handle, TJPARAM_JPEGWIDTH);
+ _hdrh = tj3Get(handle, TJPARAM_JPEGHEIGHT);
+ _hdrsubsamp = tj3Get(handle, TJPARAM_SUBSAMP);
+ if (lossless && subsamp != TJSAMP_444 && subsamp != TJSAMP_GRAY)
+ subsamp = TJSAMP_444;
+ if (_hdrw != w || _hdrh != h || _hdrsubsamp != subsamp)
+ THROW("Incorrect JPEG header");
+
+ dstSize = scaledWidth * scaledHeight * tjPixelSize[pf];
+ if ((dstBuf = malloc(dstSize * sampleSize)) == NULL)
+ THROW("Memory allocation failure");
+ memset(dstBuf, 0, dstSize * sampleSize);
+
+ if (doYUV) {
+ size_t yuvSize = tj3YUVBufSize(scaledWidth, yuvAlign, scaledHeight,
+ subsamp);
+ tjhandle handle2 = NULL;
+
+ if ((handle2 = tj3Init(TJINIT_DECOMPRESS)) == NULL)
+ THROW_TJ(NULL);
+ TRY_TJ(handle2, tj3Set(handle2, TJPARAM_BOTTOMUP, bottomUp));
+ TRY_TJ(handle2, tj3Set(handle2, TJPARAM_SUBSAMP, subsamp));
+
+ if ((yuvBuf = (unsigned char *)malloc(yuvSize)) == NULL)
+ THROW("Memory allocation failure");
+ memset(yuvBuf, 0, yuvSize);
+
+ printf("JPEG -> YUV %s ", subNameLong[subsamp]);
+ if (sf.num != 1 || sf.denom != 1)
+ printf("%d/%d ... ", sf.num, sf.denom);
+ else printf("... ");
+ TRY_TJ(handle, tj3DecompressToYUV8(handle, jpegBuf, jpegSize, yuvBuf,
+ yuvAlign));
+ if (checkBufYUV(yuvBuf, scaledWidth, scaledHeight, subsamp, sf))
+ printf("Passed.\n");
+ else printf("FAILED!\n");
+
+ printf("YUV %s -> %s %s ... ", subNameLong[subsamp], pixFormatStr[pf],
+ bottomUp ? "Bottom-Up" : "Top-Down ");
+ TRY_TJ(handle2, tj3DecodeYUV8(handle2, yuvBuf, yuvAlign,
+ (unsigned char *)dstBuf, scaledWidth, 0,
+ scaledHeight, pf));
+ tj3Destroy(handle2);
+ } else {
+ printf("JPEG -> %s %s ", pixFormatStr[pf],
+ bottomUp ? "Bottom-Up" : "Top-Down ");
+ if (sf.num != 1 || sf.denom != 1)
+ printf("%d/%d ... ", sf.num, sf.denom);
+ else printf("... ");
+ if (precision == 8) {
+ TRY_TJ(handle, tj3Decompress8(handle, jpegBuf, jpegSize,
+ (unsigned char *)dstBuf, 0, pf));
+ } else if (precision == 12) {
+ TRY_TJ(handle, tj3Decompress12(handle, jpegBuf, jpegSize,
+ (short *)dstBuf, 0, pf));
+ } else {
+ TRY_TJ(handle, tj3Decompress16(handle, jpegBuf, jpegSize,
+ (unsigned short *)dstBuf, 0, pf));
+ }
+ }
+
+ if (checkBuf(dstBuf, scaledWidth, scaledHeight, pf, subsamp, sf, bottomUp))
+ printf("Passed.");
+ else printf("FAILED!");
+ printf("\n");
+
+bailout:
+ free(yuvBuf);
+ free(dstBuf);
}
-#define PAD(v, p) ((v+(p)-1)&(~((p)-1)))
+static void decompTest(tjhandle handle, unsigned char *jpegBuf,
+ size_t jpegSize, int w, int h, int pf, char *basename,
+ int subsamp)
+{
+ int i, n = 0;
+ tjscalingfactor *sf = NULL;
+
+ if (lossless) {
+ _decompTest(handle, jpegBuf, jpegSize, w, h, pf, basename, subsamp,
+ TJUNSCALED);
+ return;
+ }
+
+ sf = tj3GetScalingFactors(&n);
+ if (!sf || !n) THROW_TJ(NULL);
+
+ for (i = 0; i < n; i++) {
+ if (subsamp == TJSAMP_444 || subsamp == TJSAMP_GRAY ||
+ ((subsamp == TJSAMP_411 || subsamp == TJSAMP_441) && sf[i].num == 1 &&
+ (sf[i].denom == 2 || sf[i].denom == 1)) ||
+ (subsamp != TJSAMP_411 && subsamp != TJSAMP_441 && sf[i].num == 1 &&
+ (sf[i].denom == 4 || sf[i].denom == 2 || sf[i].denom == 1)))
+ _decompTest(handle, jpegBuf, jpegSize, w, h, pf, basename, subsamp,
+ sf[i]);
+ }
+
+bailout:
+ return;
+}
+
-int checkBufYUV(unsigned char *buf, int w, int h, int subsamp,
- tjscalingfactor sf)
+static void doTest(int w, int h, const int *formats, int nformats, int subsamp,
+ char *basename)
{
- int row, col;
- int hsf=tjMCUWidth[subsamp]/8, vsf=tjMCUHeight[subsamp]/8;
- int pw=PAD(w, hsf), ph=PAD(h, vsf);
- int cw=pw/hsf, ch=ph/vsf;
- int ypitch=PAD(pw, pad), uvpitch=PAD(cw, pad);
- int retval=1;
- int halfway=16*sf.num/sf.denom;
- int blocksize=8*sf.num/sf.denom;
-
- for(row=0; row<ph; row++)
- {
- for(col=0; col<pw; col++)
- {
- unsigned char y=buf[ypitch*row+col];
- if(((row/blocksize)+(col/blocksize))%2==0)
- {
- if(row<halfway) checkval255(y) else checkval0(y);
- }
- else
- {
- if(row<halfway) checkval(y, 76) else checkval(y, 226);
- }
- }
- }
- if(subsamp!=TJSAMP_GRAY)
- {
- int halfway=16/vsf*sf.num/sf.denom;
- for(row=0; row<ch; row++)
- {
- for(col=0; col<cw; col++)
- {
- unsigned char u=buf[ypitch*ph + (uvpitch*row+col)],
- v=buf[ypitch*ph + uvpitch*ch + (uvpitch*row+col)];
- if(((row*vsf/blocksize)+(col*hsf/blocksize))%2==0)
- {
- checkval(u, 128); checkval(v, 128);
- }
- else
- {
- if(row<halfway)
- {
- checkval(u, 85); checkval255(v);
- }
- else
- {
- checkval0(u); checkval(v, 149);
- }
- }
- }
- }
- }
-
- bailout:
- if(retval==0)
- {
- for(row=0; row<ph; row++)
- {
- for(col=0; col<pw; col++)
- printf("%.3d ", buf[ypitch*row+col]);
- printf("\n");
- }
- printf("\n");
- for(row=0; row<ch; row++)
- {
- for(col=0; col<cw; col++)
- printf("%.3d ", buf[ypitch*ph + (uvpitch*row+col)]);
- printf("\n");
- }
- printf("\n");
- for(row=0; row<ch; row++)
- {
- for(col=0; col<cw; col++)
- printf("%.3d ", buf[ypitch*ph + uvpitch*ch + (uvpitch*row+col)]);
- printf("\n");
- }
- }
-
- return retval;
+ tjhandle chandle = NULL, dhandle = NULL;
+ unsigned char *dstBuf = NULL;
+ size_t size = 0;
+ int pfi, pf, i;
+
+ if (lossless && subsamp != TJSAMP_GRAY)
+ subsamp = TJSAMP_444;
+
+ if (!alloc)
+ size = tj3JPEGBufSize(w, h, subsamp);
+ if (size != 0)
+ if ((dstBuf = (unsigned char *)tj3Alloc(size)) == NULL)
+ THROW("Memory allocation failure.");
+
+ if ((chandle = tj3Init(TJINIT_COMPRESS)) == NULL ||
+ (dhandle = tj3Init(TJINIT_DECOMPRESS)) == NULL)
+ THROW_TJ(NULL);
+
+ TRY_TJ(chandle, tj3Set(chandle, TJPARAM_NOREALLOC, !alloc));
+ if (lossless) {
+ TRY_TJ(chandle, tj3Set(chandle, TJPARAM_LOSSLESS, lossless));
+ TRY_TJ(chandle, tj3Set(chandle, TJPARAM_LOSSLESSPSV,
+ ((psv++ - 1) % 7) + 1));
+ } else {
+ TRY_TJ(chandle, tj3Set(chandle, TJPARAM_QUALITY, 100));
+ if (subsamp == TJSAMP_422 || subsamp == TJSAMP_420 ||
+ subsamp == TJSAMP_440 || subsamp == TJSAMP_411 ||
+ subsamp == TJSAMP_441)
+ TRY_TJ(dhandle, tj3Set(dhandle, TJPARAM_FASTUPSAMPLE, 1));
+ }
+ TRY_TJ(chandle, tj3Set(chandle, TJPARAM_SUBSAMP, subsamp));
+
+ for (pfi = 0; pfi < nformats; pfi++) {
+ for (i = 0; i < 2; i++) {
+ TRY_TJ(chandle, tj3Set(chandle, TJPARAM_BOTTOMUP, i == 1));
+ TRY_TJ(dhandle, tj3Set(dhandle, TJPARAM_BOTTOMUP, i == 1));
+ pf = formats[pfi];
+ compTest(chandle, &dstBuf, &size, w, h, pf, basename);
+ decompTest(dhandle, dstBuf, size, w, h, pf, basename, subsamp);
+ if (pf >= TJPF_RGBX && pf <= TJPF_XRGB) {
+ printf("\n");
+ decompTest(dhandle, dstBuf, size, w, h, pf + (TJPF_RGBA - TJPF_RGBX),
+ basename, subsamp);
+ }
+ printf("\n");
+ }
+ }
+ printf("--------------------\n\n");
+
+bailout:
+ tj3Destroy(chandle);
+ tj3Destroy(dhandle);
+ tj3Free(dstBuf);
}
-void writeJPEG(unsigned char *jpegBuf, unsigned long jpegSize, char *filename)
+#if SIZEOF_SIZE_T == 8
+#define CHECKSIZE(function) { \
+ if (size && size < (size_t)0xFFFFFFFF) \
+ THROW(#function " overflow"); \
+}
+#define CHECKSIZEUL(function) { \
+ if ((unsigned long long)ulsize < (unsigned long long)0xFFFFFFFF) \
+ THROW(#function " overflow"); \
+}
+#else
+#define CHECKSIZE(function) { \
+ if (size != 0 || !strcmp(tj3GetErrorStr(NULL), "No error")) \
+ THROW(#function " overflow"); \
+}
+#define CHECKSIZEUL(function) { \
+ if (ulsize != (unsigned long)(-1) || \
+ !strcmp(tj3GetErrorStr(NULL), "No error")) \
+ THROW(#function " overflow"); \
+}
+#endif
+#define CHECKSIZEINT(function) { \
+ if (intsize != 0 || !strcmp(tj3GetErrorStr(NULL), "No error")) \
+ THROW(#function " overflow"); \
+}
+
+static void overflowTest(void)
{
- FILE *file=fopen(filename, "wb");
- if(!file || fwrite(jpegBuf, jpegSize, 1, file)!=1)
- {
- printf("ERROR: Could not write to %s.\n%s\n", filename, strerror(errno));
- bailout();
- }
-
- bailout:
- if(file) fclose(file);
+ /* Ensure that the various buffer size functions don't overflow */
+ size_t size;
+ unsigned long ulsize;
+ int intsize;
+
+ size = tj3JPEGBufSize(26755, 26755, TJSAMP_444);
+ CHECKSIZE(tj3JPEGBufSize());
+ ulsize = tjBufSize(26755, 26755, TJSAMP_444);
+ CHECKSIZEUL(tjBufSize());
+ ulsize = TJBUFSIZE(26755, 26755);
+ CHECKSIZEUL(TJBUFSIZE());
+ size = tj3YUVBufSize(37838, 1, 37838, TJSAMP_444);
+ CHECKSIZE(tj3YUVBufSize());
+ size = tj3YUVBufSize(37837, 3, 37837, TJSAMP_444);
+ CHECKSIZE(tj3YUVBufSize());
+ size = tj3YUVBufSize(37837, -1, 37837, TJSAMP_444);
+ CHECKSIZE(tj3YUVBufSize());
+ ulsize = tjBufSizeYUV2(37838, 1, 37838, TJSAMP_444);
+ CHECKSIZEUL(tjBufSizeYUV2());
+ ulsize = tjBufSizeYUV2(37837, 3, 37837, TJSAMP_444);
+ CHECKSIZEUL(tjBufSizeYUV2());
+ ulsize = tjBufSizeYUV2(37837, -1, 37837, TJSAMP_444);
+ CHECKSIZEUL(tjBufSizeYUV2());
+ ulsize = TJBUFSIZEYUV(37838, 37838, TJSAMP_444);
+ CHECKSIZEUL(TJBUFSIZEYUV());
+ ulsize = tjBufSizeYUV(37838, 37838, TJSAMP_444);
+ CHECKSIZEUL(tjBufSizeYUV());
+ size = tj3YUVPlaneSize(0, 65536, 0, 65536, TJSAMP_444);
+ CHECKSIZE(tj3YUVPlaneSize());
+ ulsize = tjPlaneSizeYUV(0, 65536, 0, 65536, TJSAMP_444);
+ CHECKSIZEUL(tjPlaneSizeYUV());
+ intsize = tj3YUVPlaneWidth(0, INT_MAX, TJSAMP_420);
+ CHECKSIZEINT(tj3YUVPlaneWidth());
+ intsize = tj3YUVPlaneHeight(0, INT_MAX, TJSAMP_420);
+ CHECKSIZEINT(tj3YUVPlaneHeight());
+
+bailout:
+ return;
}
-void compTest(tjhandle handle, unsigned char **dstBuf,
- unsigned long *dstSize, int w, int h, int pf, char *basename,
- int subsamp, int jpegQual, int flags)
+static void bufSizeTest(void)
{
- char tempStr[1024]; unsigned char *srcBuf=NULL, *yuvBuf=NULL;
- const char *pfStr=pixFormatStr[pf];
- const char *buStrLong=(flags&TJFLAG_BOTTOMUP)? "Bottom-Up":"Top-Down ";
- const char *buStr=(flags&TJFLAG_BOTTOMUP)? "BU":"TD";
-
- if((srcBuf=(unsigned char *)malloc(w*h*tjPixelSize[pf]))==NULL)
- _throw("Memory allocation failure");
- initBuf(srcBuf, w, h, pf, flags);
-
- if(*dstBuf && *dstSize>0) memset(*dstBuf, 0, *dstSize);
-
-
- if(!alloc) flags|=TJFLAG_NOREALLOC;
- if(doyuv)
- {
- unsigned long yuvSize=tjBufSizeYUV2(w, pad, h, subsamp);
- tjscalingfactor sf={1, 1};
- tjhandle handle2=tjInitCompress();
- if(!handle2) _throwtj();
-
- if((yuvBuf=(unsigned char *)malloc(yuvSize))==NULL)
- _throw("Memory allocation failure");
- memset(yuvBuf, 0, yuvSize);
-
- printf("%s %s -> YUV %s ... ", pfStr, buStrLong, subNameLong[subsamp]);
- _tj(tjEncodeYUV3(handle2, srcBuf, w, 0, h, pf, yuvBuf, pad, subsamp,
- flags));
- tjDestroy(handle2);
- if(checkBufYUV(yuvBuf, w, h, subsamp, sf)) printf("Passed.\n");
- else printf("FAILED!\n");
-
- printf("YUV %s %s -> JPEG Q%d ... ", subNameLong[subsamp], buStrLong,
- jpegQual);
- _tj(tjCompressFromYUV(handle, yuvBuf, w, pad, h, subsamp, dstBuf,
- dstSize, jpegQual, flags));
- }
- else
- {
- printf("%s %s -> %s Q%d ... ", pfStr, buStrLong, subNameLong[subsamp],
- jpegQual);
- _tj(tjCompress2(handle, srcBuf, w, 0, h, pf, dstBuf, dstSize, subsamp,
- jpegQual, flags));
- }
-
- snprintf(tempStr, 1024, "%s_enc_%s_%s_%s_Q%d.jpg", basename, pfStr, buStr,
- subName[subsamp], jpegQual);
- writeJPEG(*dstBuf, *dstSize, tempStr);
- printf("Done.\n Result in %s\n", tempStr);
-
- bailout:
- if(yuvBuf) free(yuvBuf);
- if(srcBuf) free(srcBuf);
+ int w, h, i, subsamp;
+ void *srcBuf = NULL;
+ unsigned char *dstBuf = NULL;
+ tjhandle handle = NULL;
+ size_t dstSize = 0;
+ int numSamp = TJ_NUMSAMP;
+
+ if ((handle = tj3Init(TJINIT_COMPRESS)) == NULL)
+ THROW_TJ(NULL);
+
+ TRY_TJ(handle, tj3Set(handle, TJPARAM_NOREALLOC, !alloc));
+ if (lossless) {
+ TRY_TJ(handle, tj3Set(handle, TJPARAM_LOSSLESS, lossless));
+ TRY_TJ(handle, tj3Set(handle, TJPARAM_LOSSLESSPSV,
+ ((psv++ - 1) % 7) + 1));
+ numSamp = 1;
+ } else
+ TRY_TJ(handle, tj3Set(handle, TJPARAM_QUALITY, 100));
+
+ printf("Buffer size regression test\n");
+ for (subsamp = 0; subsamp < numSamp; subsamp++) {
+ TRY_TJ(handle, tj3Set(handle, TJPARAM_SUBSAMP, subsamp));
+ for (w = 1; w < 48; w++) {
+ int maxh = (w == 1) ? 2048 : 48;
+
+ for (h = 1; h < maxh; h++) {
+ if (h % 100 == 0) printf("%.4d x %.4d\b\b\b\b\b\b\b\b\b\b\b", w, h);
+ if ((srcBuf = malloc(w * h * 4 * sampleSize)) == NULL)
+ THROW("Memory allocation failure");
+ if (!alloc || doYUV) {
+ if (doYUV) dstSize = tj3YUVBufSize(w, yuvAlign, h, subsamp);
+ else dstSize = tj3JPEGBufSize(w, h, subsamp);
+ if ((dstBuf = (unsigned char *)tj3Alloc(dstSize)) == NULL)
+ THROW("Memory allocation failure");
+ }
+
+ for (i = 0; i < w * h * 4; i++) {
+ if (random() < RAND_MAX / 2) setVal(srcBuf, i, 0);
+ else setVal(srcBuf, i, maxSample);
+ }
+
+ if (doYUV) {
+ TRY_TJ(handle, tj3EncodeYUV8(handle, (unsigned char *)srcBuf, w, 0,
+ h, TJPF_BGRX, dstBuf, yuvAlign));
+ } else {
+ if (precision == 8) {
+ TRY_TJ(handle, tj3Compress8(handle, (unsigned char *)srcBuf, w, 0,
+ h, TJPF_BGRX, &dstBuf, &dstSize));
+ } else if (precision == 12) {
+ TRY_TJ(handle, tj3Compress12(handle, (short *)srcBuf, w, 0, h,
+ TJPF_BGRX, &dstBuf, &dstSize));
+ } else {
+ TRY_TJ(handle, tj3Compress16(handle, (unsigned short *)srcBuf, w,
+ 0, h, TJPF_BGRX, &dstBuf, &dstSize));
+ }
+ }
+ free(srcBuf); srcBuf = NULL;
+ if (!alloc || doYUV) {
+ tj3Free(dstBuf); dstBuf = NULL;
+ }
+
+ if ((srcBuf = malloc(h * w * 4 * sampleSize)) == NULL)
+ THROW("Memory allocation failure");
+ if (!alloc || doYUV) {
+ if (doYUV) dstSize = tj3YUVBufSize(h, yuvAlign, w, subsamp);
+ else dstSize = tj3JPEGBufSize(h, w, subsamp);
+ if ((dstBuf = (unsigned char *)tj3Alloc(dstSize)) == NULL)
+ THROW("Memory allocation failure");
+ }
+
+ for (i = 0; i < h * w * 4; i++) {
+ if (random() < RAND_MAX / 2) setVal(srcBuf, i, 0);
+ else setVal(srcBuf, i, maxSample);
+ }
+
+ if (doYUV) {
+ TRY_TJ(handle, tj3EncodeYUV8(handle, (unsigned char *)srcBuf, h, 0,
+ w, TJPF_BGRX, dstBuf, yuvAlign));
+ } else {
+ if (precision == 8) {
+ TRY_TJ(handle, tj3Compress8(handle, (unsigned char *)srcBuf, h, 0,
+ w, TJPF_BGRX, &dstBuf, &dstSize));
+ } else if (precision == 12) {
+ TRY_TJ(handle, tj3Compress12(handle, (short *)srcBuf, h, 0, w,
+ TJPF_BGRX, &dstBuf, &dstSize));
+ } else {
+ TRY_TJ(handle, tj3Compress16(handle, (unsigned short *)srcBuf, h,
+ 0, w, TJPF_BGRX, &dstBuf, &dstSize));
+ }
+ }
+ free(srcBuf); srcBuf = NULL;
+ if (!alloc || doYUV) {
+ tj3Free(dstBuf); dstBuf = NULL;
+ }
+ }
+ }
+ }
+ printf("Done. \n");
+
+bailout:
+ free(srcBuf);
+ tj3Free(dstBuf);
+ tj3Destroy(handle);
}
-void _decompTest(tjhandle handle, unsigned char *jpegBuf,
- unsigned long jpegSize, int w, int h, int pf, char *basename, int subsamp,
- int flags, tjscalingfactor sf)
+static void rgb_to_cmyk(int r, int g, int b, int *c, int *m, int *y, int *k)
+{
+ double ctmp = 1.0 - ((double)r / (double)maxSample);
+ double mtmp = 1.0 - ((double)g / (double)maxSample);
+ double ytmp = 1.0 - ((double)b / (double)maxSample);
+ double ktmp = min(min(ctmp, mtmp), ytmp);
+
+ if (ktmp == 1.0) ctmp = mtmp = ytmp = 0.0;
+ else {
+ ctmp = (ctmp - ktmp) / (1.0 - ktmp);
+ mtmp = (mtmp - ktmp) / (1.0 - ktmp);
+ ytmp = (ytmp - ktmp) / (1.0 - ktmp);
+ }
+ *c = (int)((double)maxSample - ctmp * (double)maxSample + 0.5);
+ *m = (int)((double)maxSample - mtmp * (double)maxSample + 0.5);
+ *y = (int)((double)maxSample - ytmp * (double)maxSample + 0.5);
+ *k = (int)((double)maxSample - ktmp * (double)maxSample + 0.5);
+}
+
+static void initBitmap(void *buf, int width, int pitch, int height, int pf,
+ int bottomUp)
{
- unsigned char *dstBuf=NULL, *yuvBuf=NULL;
- int _hdrw=0, _hdrh=0, _hdrsubsamp=-1;
- int scaledWidth=TJSCALED(w, sf);
- int scaledHeight=TJSCALED(h, sf);
- unsigned long dstSize=0;
-
- _tj(tjDecompressHeader2(handle, jpegBuf, jpegSize, &_hdrw, &_hdrh,
- &_hdrsubsamp));
- if(_hdrw!=w || _hdrh!=h || _hdrsubsamp!=subsamp)
- _throw("Incorrect JPEG header");
-
- dstSize=scaledWidth*scaledHeight*tjPixelSize[pf];
- if((dstBuf=(unsigned char *)malloc(dstSize))==NULL)
- _throw("Memory allocation failure");
- memset(dstBuf, 0, dstSize);
-
- if(doyuv)
- {
- unsigned long yuvSize=tjBufSizeYUV2(scaledWidth, pad, scaledHeight,
- subsamp);
- tjhandle handle2=tjInitDecompress();
- if(!handle2) _throwtj();
-
- if((yuvBuf=(unsigned char *)malloc(yuvSize))==NULL)
- _throw("Memory allocation failure");
- memset(yuvBuf, 0, yuvSize);
-
- printf("JPEG -> YUV %s ", subNameLong[subsamp]);
- if(sf.num!=1 || sf.denom!=1)
- printf("%d/%d ... ", sf.num, sf.denom);
- else printf("... ");
- _tj(tjDecompressToYUV2(handle, jpegBuf, jpegSize, yuvBuf, scaledWidth,
- pad, scaledHeight, flags));
- if(checkBufYUV(yuvBuf, scaledWidth, scaledHeight, subsamp, sf))
- printf("Passed.\n");
- else printf("FAILED!\n");
-
- printf("YUV %s -> %s %s ... ", subNameLong[subsamp], pixFormatStr[pf],
- (flags&TJFLAG_BOTTOMUP)? "Bottom-Up":"Top-Down ");
- _tj(tjDecodeYUV(handle2, yuvBuf, pad, subsamp, dstBuf, scaledWidth, 0,
- scaledHeight, pf, flags));
- tjDestroy(handle2);
- }
- else
- {
- printf("JPEG -> %s %s ", pixFormatStr[pf],
- (flags&TJFLAG_BOTTOMUP)? "Bottom-Up":"Top-Down ");
- if(sf.num!=1 || sf.denom!=1)
- printf("%d/%d ... ", sf.num, sf.denom);
- else printf("... ");
- _tj(tjDecompress2(handle, jpegBuf, jpegSize, dstBuf, scaledWidth, 0,
- scaledHeight, pf, flags));
- }
-
- if(checkBuf(dstBuf, scaledWidth, scaledHeight, pf, subsamp, sf, flags))
- printf("Passed.");
- else printf("FAILED!");
- printf("\n");
-
- bailout:
- if(yuvBuf) free(yuvBuf);
- if(dstBuf) free(dstBuf);
+ int roffset = tjRedOffset[pf];
+ int goffset = tjGreenOffset[pf];
+ int boffset = tjBlueOffset[pf];
+ int ps = tjPixelSize[pf];
+ int i, j, ci;
+
+ for (j = 0; j < height; j++) {
+ int row = bottomUp ? height - j - 1 : j;
+
+ for (i = 0; i < width; i++) {
+ int r = (i * (maxSample + 1) / width) % (maxSample + 1);
+ int g = (j * (maxSample + 1) / height) % (maxSample + 1);
+ int b = (j * (maxSample + 1) / height +
+ i * (maxSample + 1) / width) % (maxSample + 1);
+
+ for (ci = 0; ci < ps; ci++)
+ setVal(buf, row * pitch + i * ps + ci, 0);
+ if (pf == TJPF_GRAY) setVal(buf, row * pitch + i * ps, b);
+ else if (pf == TJPF_CMYK) {
+ int c, m, y, k;
+
+ rgb_to_cmyk(r, g, b, &c, &m, &y, &k);
+ setVal(buf, row * pitch + i * ps + 0, c);
+ setVal(buf, row * pitch + i * ps + 1, m);
+ setVal(buf, row * pitch + i * ps + 2, y);
+ setVal(buf, row * pitch + i * ps + 3, k);
+ } else {
+ setVal(buf, row * pitch + i * ps + roffset, r);
+ setVal(buf, row * pitch + i * ps + goffset, g);
+ setVal(buf, row * pitch + i * ps + boffset, b);
+ }
+ }
+ }
}
-void decompTest(tjhandle handle, unsigned char *jpegBuf,
- unsigned long jpegSize, int w, int h, int pf, char *basename, int subsamp,
- int flags)
+static void cmyk_to_rgb(int c, int m, int y, int k, int *r, int *g, int *b)
{
- int i, n=0;
- tjscalingfactor *sf=tjGetScalingFactors(&n);
- if(!sf || !n) _throwtj();
-
- for(i=0; i<n; i++)
- {
- if(subsamp==TJSAMP_444 || subsamp==TJSAMP_GRAY ||
- (subsamp==TJSAMP_411 && sf[i].num==1 &&
- (sf[i].denom==2 || sf[i].denom==1)) ||
- (subsamp!=TJSAMP_411 && sf[i].num==1 &&
- (sf[i].denom==4 || sf[i].denom==2 || sf[i].denom==1)))
- _decompTest(handle, jpegBuf, jpegSize, w, h, pf, basename, subsamp,
- flags, sf[i]);
- }
-
- bailout:
- return;
+ *r = (int)((double)c * (double)k / (double)maxSample + 0.5);
+ *g = (int)((double)m * (double)k / (double)maxSample + 0.5);
+ *b = (int)((double)y * (double)k / (double)maxSample + 0.5);
+}
+
+static int cmpBitmap(void *buf, int width, int pitch, int height, int pf,
+ int bottomUp, int gray2rgb)
+{
+ int roffset = tjRedOffset[pf];
+ int goffset = tjGreenOffset[pf];
+ int boffset = tjBlueOffset[pf];
+ int aoffset = tjAlphaOffset[pf];
+ int ps = tjPixelSize[pf];
+ int i, j;
+
+ for (j = 0; j < height; j++) {
+ int row = bottomUp ? height - j - 1 : j;
+
+ for (i = 0; i < width; i++) {
+ int r = (i * (maxSample + 1) / width) % (maxSample + 1);
+ int g = (j * (maxSample + 1) / height) % (maxSample + 1);
+ int b = (j * (maxSample + 1) / height +
+ i * (maxSample + 1) / width) % (maxSample + 1);
+
+ if (pf == TJPF_GRAY) {
+ if (getVal(buf, row * pitch + i * ps) != b)
+ return 0;
+ } else if (pf == TJPF_CMYK) {
+ int rf, gf, bf;
+
+ cmyk_to_rgb(getVal(buf, row * pitch + i * ps + 0),
+ getVal(buf, row * pitch + i * ps + 1),
+ getVal(buf, row * pitch + i * ps + 2),
+ getVal(buf, row * pitch + i * ps + 3), &rf, &gf, &bf);
+ if (gray2rgb) {
+ if (rf != b || gf != b || bf != b)
+ return 0;
+ } else if (rf != r || gf != g || bf != b) return 0;
+ } else {
+ if (gray2rgb) {
+ if (getVal(buf, row * pitch + i * ps + roffset) != b ||
+ getVal(buf, row * pitch + i * ps + goffset) != b ||
+ getVal(buf, row * pitch + i * ps + boffset) != b)
+ return 0;
+ } else if (getVal(buf, row * pitch + i * ps + roffset) != r ||
+ getVal(buf, row * pitch + i * ps + goffset) != g ||
+ getVal(buf, row * pitch + i * ps + boffset) != b)
+ return 0;
+ if (aoffset >= 0 &&
+ getVal(buf, row * pitch + i * ps + aoffset) != maxSample)
+ return 0;
+ }
+ }
+ }
+ return 1;
}
-void doTest(int w, int h, const int *formats, int nformats, int subsamp,
- char *basename)
+static int doBmpTest(const char *ext, int width, int align, int height, int pf,
+ int bottomUp)
{
- tjhandle chandle=NULL, dhandle=NULL;
- unsigned char *dstBuf=NULL;
- unsigned long size=0; int pfi, pf, i;
-
- if(!alloc)
- size=tjBufSize(w, h, subsamp);
- if(size!=0)
- if((dstBuf=(unsigned char *)tjAlloc(size))==NULL)
- _throw("Memory allocation failure.");
-
- if((chandle=tjInitCompress())==NULL || (dhandle=tjInitDecompress())==NULL)
- _throwtj();
-
- for(pfi=0; pfi<nformats; pfi++)
- {
- for(i=0; i<2; i++)
- {
- int flags=0;
- if(subsamp==TJSAMP_422 || subsamp==TJSAMP_420 || subsamp==TJSAMP_440 ||
- subsamp==TJSAMP_411)
- flags|=TJFLAG_FASTUPSAMPLE;
- if(i==1) flags|=TJFLAG_BOTTOMUP;
- pf=formats[pfi];
- compTest(chandle, &dstBuf, &size, w, h, pf, basename, subsamp, 100,
- flags);
- decompTest(dhandle, dstBuf, size, w, h, pf, basename, subsamp,
- flags);
- if(pf>=TJPF_RGBX && pf<=TJPF_XRGB)
- {
- printf("\n");
- decompTest(dhandle, dstBuf, size, w, h, pf+(TJPF_RGBA-TJPF_RGBX),
- basename, subsamp, flags);
- }
- printf("\n");
- }
- }
- printf("--------------------\n\n");
-
- bailout:
- if(chandle) tjDestroy(chandle);
- if(dhandle) tjDestroy(dhandle);
-
- if(dstBuf) tjFree(dstBuf);
+ tjhandle handle = NULL;
+ char filename[80], *md5sum, md5buf[65];
+ int ps = tjPixelSize[pf], pitch = PAD(width * ps, align), loadWidth = 0,
+ loadHeight = 0, retval = 0, pixelFormat = pf;
+ void *buf = NULL;
+ char *md5ref;
+
+ if ((handle = tj3Init(TJINIT_TRANSFORM)) == NULL)
+ THROW_TJ(NULL);
+ TRY_TJ(handle, tj3Set(handle, TJPARAM_BOTTOMUP, bottomUp));
+
+ if (pf == TJPF_GRAY) {
+ if (precision == 8)
+ md5ref = !strcasecmp(ext, "ppm") ? "112c682e82ce5de1cca089e20d60000b" :
+ "51976530acf75f02beddf5d21149101d";
+ else if (precision == 12)
+ md5ref = "0d1895c7e6f2b2c9af6e821a655c239c";
+ else
+ md5ref = "64f3320b226ea37fb58080713b4df1b2";
+ } else {
+ if (precision == 8)
+ md5ref = !strcasecmp(ext, "ppm") ? "c0c9f772b464d1896326883a5c79c545" :
+ "6d659071b9bfcdee2def22cb58ddadca";
+ else if (precision == 12)
+ md5ref = "2ff5299287017502832c99718450c90a";
+ else
+ md5ref = "623f54661b928d170bd2324bc3620565";
+ }
+
+ if ((buf = tj3Alloc(pitch * height * sampleSize)) == NULL)
+ THROW("Could not allocate memory");
+ initBitmap(buf, width, pitch, height, pf, bottomUp);
+
+ SNPRINTF(filename, 80, "test_bmp%d_%s_%d_%s_%d.%s", precision, pixFormatStr[pf],
+ align, bottomUp ? "bu" : "td", getpid(), ext);
+ if (precision == 8) {
+ TRY_TJ(handle, tj3SaveImage8(handle, filename, (unsigned char *)buf, width,
+ pitch, height, pf));
+ } else if (precision == 12) {
+ TRY_TJ(handle, tj3SaveImage12(handle, filename, (short *)buf, width, pitch,
+ height, pf));
+ } else {
+ TRY_TJ(handle, tj3SaveImage16(handle, filename, (unsigned short *)buf,
+ width, pitch, height, pf));
+ }
+ md5sum = MD5File(filename, md5buf);
+ if (!md5sum) {
+ printf("\n Could not determine MD5 sum of %s\n", filename);
+ retval = -1; goto bailout;
+ }
+ if (strcasecmp(md5sum, md5ref))
+ THROW_MD5(filename, md5sum, md5ref);
+
+ tj3Free(buf); buf = NULL;
+ if (precision == 8) {
+ if ((buf = tj3LoadImage8(handle, filename, &loadWidth, align, &loadHeight,
+ &pf)) == NULL)
+ THROW_TJ(handle);
+ } else if (precision == 12) {
+ if ((buf = tj3LoadImage12(handle, filename, &loadWidth, align, &loadHeight,
+ &pf)) == NULL)
+ THROW_TJ(handle);
+ } else {
+ if ((buf = tj3LoadImage16(handle, filename, &loadWidth, align, &loadHeight,
+ &pf)) == NULL)
+ THROW_TJ(handle);
+ }
+ if (width != loadWidth || height != loadHeight) {
+ printf("\n Image dimensions of %s are bogus\n", filename);
+ retval = -1; goto bailout;
+ }
+ if (!cmpBitmap(buf, width, pitch, height, pf, bottomUp, 0)) {
+ printf("\n Pixel data in %s is bogus\n", filename);
+ retval = -1; goto bailout;
+ }
+ if (pf == TJPF_GRAY) {
+ tj3Free(buf); buf = NULL;
+ pf = TJPF_XBGR;
+ if (precision == 8) {
+ if ((buf = tj3LoadImage8(handle, filename, &loadWidth, align,
+ &loadHeight, &pf)) == NULL)
+ THROW_TJ(handle);
+ } else if (precision == 12) {
+ if ((buf = tj3LoadImage12(handle, filename, &loadWidth, align,
+ &loadHeight, &pf)) == NULL)
+ THROW_TJ(handle);
+ } else {
+ if ((buf = tj3LoadImage16(handle, filename, &loadWidth, align,
+ &loadHeight, &pf)) == NULL)
+ THROW_TJ(handle);
+ }
+ pitch = PAD(width * tjPixelSize[pf], align);
+ if (!cmpBitmap(buf, width, pitch, height, pf, bottomUp, 1)) {
+ printf("\n Converting %s to RGB failed\n", filename);
+ retval = -1; goto bailout;
+ }
+
+ tj3Free(buf); buf = NULL;
+ pf = TJPF_CMYK;
+ if (precision == 8) {
+ if ((buf = tj3LoadImage8(handle, filename, &loadWidth, align,
+ &loadHeight, &pf)) == NULL)
+ THROW_TJ(handle);
+ } else if (precision == 12) {
+ if ((buf = tj3LoadImage12(handle, filename, &loadWidth, align,
+ &loadHeight, &pf)) == NULL)
+ THROW_TJ(handle);
+ } else {
+ if ((buf = tj3LoadImage16(handle, filename, &loadWidth, align,
+ &loadHeight, &pf)) == NULL)
+ THROW_TJ(handle);
+ }
+ pitch = PAD(width * tjPixelSize[pf], align);
+ if (!cmpBitmap(buf, width, pitch, height, pf, bottomUp, 1)) {
+ printf("\n Converting %s to CMYK failed\n", filename);
+ retval = -1; goto bailout;
+ }
+ }
+ /* Verify that tj3LoadImage*() returns the proper "preferred" pixel format
+ for the file type. */
+ tj3Free(buf); buf = NULL;
+ pf = pixelFormat;
+ pixelFormat = TJPF_UNKNOWN;
+ if (precision == 8) {
+ if ((buf = tj3LoadImage8(handle, filename, &loadWidth, align, &loadHeight,
+ &pixelFormat)) == NULL)
+ THROW_TJ(handle);
+ } else if (precision == 12) {
+ if ((buf = tj3LoadImage12(handle, filename, &loadWidth, align, &loadHeight,
+ &pixelFormat)) == NULL)
+ THROW_TJ(handle);
+ } else {
+ if ((buf = tj3LoadImage16(handle, filename, &loadWidth, align, &loadHeight,
+ &pixelFormat)) == NULL)
+ THROW_TJ(handle);
+ }
+ if ((pf == TJPF_GRAY && pixelFormat != TJPF_GRAY) ||
+ (pf != TJPF_GRAY && !strcasecmp(ext, "bmp") &&
+ pixelFormat != TJPF_BGR) ||
+ (pf != TJPF_GRAY && !strcasecmp(ext, "ppm") &&
+ pixelFormat != TJPF_RGB)) {
+ printf("\n tj3LoadImage8() returned unexpected pixel format: %s\n",
+ pixFormatStr[pixelFormat]);
+ retval = -1;
+ }
+ unlink(filename);
+
+bailout:
+ tj3Destroy(handle);
+ tj3Free(buf);
+ if (exitStatus < 0) return exitStatus;
+ return retval;
}
-void bufSizeTest(void)
+static int bmpTest(void)
{
- int w, h, i, subsamp;
- unsigned char *srcBuf=NULL, *dstBuf=NULL;
- tjhandle handle=NULL;
- unsigned long dstSize=0;
-
- if((handle=tjInitCompress())==NULL) _throwtj();
-
- printf("Buffer size regression test\n");
- for(subsamp=0; subsamp<TJ_NUMSAMP; subsamp++)
- {
- for(w=1; w<48; w++)
- {
- int maxh=(w==1)? 2048:48;
- for(h=1; h<maxh; h++)
- {
- if(h%100==0) printf("%.4d x %.4d\b\b\b\b\b\b\b\b\b\b\b", w, h);
- if((srcBuf=(unsigned char *)malloc(w*h*4))==NULL)
- _throw("Memory allocation failure");
- if(!alloc || doyuv)
- {
- if(doyuv) dstSize=tjBufSizeYUV2(w, pad, h, subsamp);
- else dstSize=tjBufSize(w, h, subsamp);
- if((dstBuf=(unsigned char *)tjAlloc(dstSize))==NULL)
- _throw("Memory allocation failure");
- }
-
- for(i=0; i<w*h*4; i++)
- {
- if(random()<RAND_MAX/2) srcBuf[i]=0;
- else srcBuf[i]=255;
- }
-
- if(doyuv)
- {
- _tj(tjEncodeYUV3(handle, srcBuf, w, 0, h, TJPF_BGRX, dstBuf, pad,
- subsamp, 0));
- }
- else
- {
- _tj(tjCompress2(handle, srcBuf, w, 0, h, TJPF_BGRX, &dstBuf,
- &dstSize, subsamp, 100, alloc? 0:TJFLAG_NOREALLOC));
- }
- free(srcBuf); srcBuf=NULL;
- if(!alloc)
- {
- tjFree(dstBuf); dstBuf=NULL;
- }
-
- if((srcBuf=(unsigned char *)malloc(h*w*4))==NULL)
- _throw("Memory allocation failure");
- if(!alloc || doyuv)
- {
- if(doyuv) dstSize=tjBufSizeYUV2(h, pad, w, subsamp);
- else dstSize=tjBufSize(h, w, subsamp);
- if((dstBuf=(unsigned char *)tjAlloc(dstSize))==NULL)
- _throw("Memory allocation failure");
- }
-
- for(i=0; i<h*w*4; i++)
- {
- if(random()<RAND_MAX/2) srcBuf[i]=0;
- else srcBuf[i]=255;
- }
-
- if(doyuv)
- {
- _tj(tjEncodeYUV3(handle, srcBuf, h, 0, w, TJPF_BGRX, dstBuf, pad,
- subsamp, 0));
- }
- else
- {
- _tj(tjCompress2(handle, srcBuf, h, 0, w, TJPF_BGRX, &dstBuf,
- &dstSize, subsamp, 100, alloc? 0:TJFLAG_NOREALLOC));
- }
- free(srcBuf); srcBuf=NULL;
- if(!alloc)
- {
- tjFree(dstBuf); dstBuf=NULL;
- }
- }
- }
- }
- printf("Done. \n");
-
- bailout:
- if(srcBuf) free(srcBuf);
- if(dstBuf) tjFree(dstBuf);
- if(handle) tjDestroy(handle);
+ int align, width = 35, height = 39, format;
+
+ for (align = 1; align <= 8; align *= 2) {
+ for (format = 0; format < TJ_NUMPF; format++) {
+ if (precision == 8) {
+ printf("%s Top-Down BMP (row alignment = %d samples) ... ",
+ pixFormatStr[format], align);
+ if (doBmpTest("bmp", width, align, height, format, 0) == -1)
+ return -1;
+ printf("OK.\n");
+ }
+
+ printf("%s Top-Down PPM (row alignment = %d samples) ... ",
+ pixFormatStr[format], align);
+ if (doBmpTest("ppm", width, align, height, format, 1) == -1)
+ return -1;
+ printf("OK.\n");
+
+ if (precision == 8) {
+ printf("%s Bottom-Up BMP (row alignment = %d samples) ... ",
+ pixFormatStr[format], align);
+ if (doBmpTest("bmp", width, align, height, format, 0) == -1)
+ return -1;
+ printf("OK.\n");
+ }
+
+ printf("%s Bottom-Up PPM (row alignment = %d samples) ... ",
+ pixFormatStr[format], align);
+ if (doBmpTest("ppm", width, align, height, format, 1) == -1)
+ return -1;
+ printf("OK.\n");
+ }
+ }
+
+ return 0;
}
int main(int argc, char *argv[])
{
- int i, num4bf=5;
- #ifdef _WIN32
- srand((unsigned int)time(NULL));
- #endif
- if(argc>1)
- {
- for(i=1; i<argc; i++)
- {
- if(!strcasecmp(argv[i], "-yuv")) doyuv=1;
- if(!strcasecmp(argv[i], "-noyuvpad")) pad=1;
- if(!strcasecmp(argv[i], "-alloc")) alloc=1;
- if(!strncasecmp(argv[i], "-h", 2) || !strcasecmp(argv[i], "-?"))
- usage(argv[0]);
- }
- }
- if(alloc) printf("Testing automatic buffer allocation\n");
- if(doyuv) num4bf=4;
- doTest(35, 39, _3byteFormats, 2, TJSAMP_444, "test");
- doTest(39, 41, _4byteFormats, num4bf, TJSAMP_444, "test");
- doTest(41, 35, _3byteFormats, 2, TJSAMP_422, "test");
- doTest(35, 39, _4byteFormats, num4bf, TJSAMP_422, "test");
- doTest(39, 41, _3byteFormats, 2, TJSAMP_420, "test");
- doTest(41, 35, _4byteFormats, num4bf, TJSAMP_420, "test");
- doTest(35, 39, _3byteFormats, 2, TJSAMP_440, "test");
- doTest(39, 41, _4byteFormats, num4bf, TJSAMP_440, "test");
- doTest(41, 35, _3byteFormats, 2, TJSAMP_411, "test");
- doTest(35, 39, _4byteFormats, num4bf, TJSAMP_411, "test");
- doTest(39, 41, _onlyGray, 1, TJSAMP_GRAY, "test");
- doTest(41, 35, _3byteFormats, 2, TJSAMP_GRAY, "test");
- doTest(35, 39, _4byteFormats, 4, TJSAMP_GRAY, "test");
- bufSizeTest();
- if(doyuv)
- {
- printf("\n--------------------\n\n");
- doTest(48, 48, _onlyRGB, 1, TJSAMP_444, "test_yuv0");
- doTest(48, 48, _onlyRGB, 1, TJSAMP_422, "test_yuv0");
- doTest(48, 48, _onlyRGB, 1, TJSAMP_420, "test_yuv0");
- doTest(48, 48, _onlyRGB, 1, TJSAMP_440, "test_yuv0");
- doTest(48, 48, _onlyRGB, 1, TJSAMP_411, "test_yuv0");
- doTest(48, 48, _onlyRGB, 1, TJSAMP_GRAY, "test_yuv0");
- doTest(48, 48, _onlyGray, 1, TJSAMP_GRAY, "test_yuv0");
- }
-
- return exitStatus;
+ int i, bmp = 0, num4bf = 5;
+
+#ifdef _WIN32
+ srand((unsigned int)time(NULL));
+#endif
+ if (argc > 1) {
+ for (i = 1; i < argc; i++) {
+ if (!strcasecmp(argv[i], "-yuv")) doYUV = 1;
+ else if (!strcasecmp(argv[i], "-noyuvpad")) yuvAlign = 1;
+ else if (!strcasecmp(argv[i], "-lossless")) lossless = 1;
+ else if (!strcasecmp(argv[i], "-alloc")) alloc = 1;
+ else if (!strcasecmp(argv[i], "-bmp")) bmp = 1;
+ else if (!strcasecmp(argv[i], "-precision") && i < argc - 1) {
+ int tempi = atoi(argv[++i]);
+
+ if (tempi != 8 && tempi != 12 && tempi != 16)
+ usage(argv[0]);
+ precision = tempi;
+ if (precision == 16) lossless = 1;
+ } else
+ usage(argv[0]);
+ }
+ }
+ if (lossless && doYUV)
+ THROW("Lossless JPEG and YUV encoding/decoding are incompatible.");
+ if (precision != 8 && doYUV)
+ THROW("YUV encoding/decoding requires 8-bit data precision.");
+
+ printf("Testing %d-bit precision\n", precision);
+ sampleSize = (precision == 8 ? sizeof(unsigned char) : sizeof(short));
+ maxSample = (1 << precision) - 1;
+ tolerance = (lossless ? 0 : (precision > 8 ? 2 : 1));
+ redToY = (19595U * maxSample) >> 16;
+ yellowToY = (58065U * maxSample) >> 16;
+
+ if (bmp) return bmpTest();
+ if (alloc) printf("Testing automatic buffer allocation\n");
+ if (doYUV) num4bf = 4;
+ overflowTest();
+ doTest(35, 39, _3sampleFormats, 2, TJSAMP_444, "test");
+ doTest(39, 41, _4sampleFormats, num4bf, TJSAMP_444, "test");
+ doTest(41, 35, _3sampleFormats, 2, TJSAMP_422, "test");
+ if (!lossless) {
+ doTest(35, 39, _4sampleFormats, num4bf, TJSAMP_422, "test");
+ doTest(39, 41, _3sampleFormats, 2, TJSAMP_420, "test");
+ doTest(41, 35, _4sampleFormats, num4bf, TJSAMP_420, "test");
+ doTest(35, 39, _3sampleFormats, 2, TJSAMP_440, "test");
+ doTest(39, 41, _4sampleFormats, num4bf, TJSAMP_440, "test");
+ doTest(41, 35, _3sampleFormats, 2, TJSAMP_411, "test");
+ doTest(35, 39, _4sampleFormats, num4bf, TJSAMP_411, "test");
+ doTest(39, 41, _3sampleFormats, 2, TJSAMP_441, "test");
+ doTest(41, 35, _4sampleFormats, num4bf, TJSAMP_441, "test");
+ }
+ doTest(39, 41, _onlyGray, 1, TJSAMP_GRAY, "test");
+ if (!lossless) {
+ doTest(41, 35, _3sampleFormats, 2, TJSAMP_GRAY, "test");
+ doTest(35, 39, _4sampleFormats, 4, TJSAMP_GRAY, "test");
+ }
+ bufSizeTest();
+ if (doYUV) {
+ printf("\n--------------------\n\n");
+ doTest(48, 48, _onlyRGB, 1, TJSAMP_444, "test_yuv0");
+ doTest(48, 48, _onlyRGB, 1, TJSAMP_422, "test_yuv0");
+ doTest(48, 48, _onlyRGB, 1, TJSAMP_420, "test_yuv0");
+ doTest(48, 48, _onlyRGB, 1, TJSAMP_440, "test_yuv0");
+ doTest(48, 48, _onlyRGB, 1, TJSAMP_411, "test_yuv0");
+ doTest(48, 48, _onlyRGB, 1, TJSAMP_441, "test_yuv0");
+ doTest(48, 48, _onlyRGB, 1, TJSAMP_GRAY, "test_yuv0");
+ doTest(48, 48, _onlyGray, 1, TJSAMP_GRAY, "test_yuv0");
+ }
+
+ bailout:
+ return exitStatus;
}
projects / platform / upstream / libjpeg-turbo.git / blobdiff