/*
* A sequence of test procedures for this JBIG implementation
*
* Run this test sequence after each modification on the JBIG library.
*
* Markus Kuhn -- http://www.cl.cam.ac.uk/~mgk25/
*/
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <assert.h>
#include "jbig85.h"
#define TESTBUF_SIZE 400000L
#define TESTPIC_SIZE 477995L
#define FAILED "F\bFA\bAI\bIL\bLE\bED\bD"
#define PASSED "PASSED"
unsigned char *testbuf;
unsigned char *testpic;
long testbuf_len;
static void *checkedmalloc(size_t n)
{
void *p;
if ((p = calloc(1, n)) == NULL) {
fprintf(stderr, "Sorry, not enough memory available!\n");
exit(1);
}
return p;
}
static void testbuf_write(int v, void *dummy)
{
if (testbuf_len < TESTBUF_SIZE)
testbuf[testbuf_len++] = v;
(void) dummy;
return;
}
static void testbuf_writel(unsigned char *start, size_t len, void *dummy)
{
if (testbuf_len < TESTBUF_SIZE) {
if (testbuf_len + len < TESTBUF_SIZE)
memcpy(testbuf + testbuf_len, start, len);
else
memcpy(testbuf + testbuf_len, start, TESTBUF_SIZE - testbuf_len);
}
testbuf_len += len;
#ifdef DEBUG
{
unsigned char *p;
unsigned sum = 0;
for (p = start; p - start < (ptrdiff_t) len; sum = (sum ^ *p++) << 1);
printf(" testbuf_writel: %4lu bytes, checksum %04x\n",
(unsigned long) len, sum & 0xffff);
}
#endif
(void) dummy;
return;
}
static int line_out(const struct jbg85_dec_state *s,
unsigned char *start, size_t len,
unsigned long y, void *bitmap)
{
assert(jbg85_dec_validwidth(s));
assert(len == (jbg85_dec_getwidth(s) >> 3) + !!(jbg85_dec_getwidth(s) & 7));
assert(y < jbg85_dec_getheight(s));
memcpy((unsigned char *) bitmap + len * y, start, len);
return 0;
}
/*
* Store the artificial test image defined in T.82, clause 7.2.1 at
* pic. The image requires 477995 bytes of memory, is 1960 x 1951 pixels
* large and has one plane.
*/
static void testimage(unsigned char *pic)
{
unsigned long i, j, sum;
unsigned int prsg, repeat[8];
unsigned char *p;
memset(pic, 0, TESTPIC_SIZE);
p = pic;
prsg = 1;
for (j = 0; j < 1951; j++)
for (i = 0; i < 1960; i++) {
if (j >= 192) {
if (j < 1023 || ((i >> 3) & 3) == 0) {
sum = (prsg & 1) + ((prsg >> 2) & 1) + ((prsg >> 11) & 1) +
((prsg >> 15) & 1);
prsg = (prsg << 1) + (sum & 1);
if ((prsg & 3) == 0) {
*p |= 1 << (7 - (i & 7));
repeat[i & 7] = 1;
} else {
repeat[i & 7] = 0;
}
} else {
if (repeat[i & 7])
*p |= 1 << (7 - (i & 7));
}
}
if ((i & 7) == 7) ++p;
}
/* verify test image */
sum = 0;
for (i = 0; i < TESTPIC_SIZE; i++)
for (j = 0; j < 8; j++)
sum += (pic[i] >> j) & 1;
if (sum != 861965L)
printf("WARNING: Artificial test image has %lu (not 861965) "
"foreground pixels!\n", sum);
return;
}
/*
* Perform a full test cycle with one set of parameters. Encode an image
* and compare the length of the result with correct_length. Then decode
* the image again both in one single chunk or byte by byte and compare
* the results with the original input image.
*/
static int test_cycle(unsigned char *orig_image, int width, int height,
int options, unsigned long l0, int mx,
long correct_length, const char *test_id)
{
struct jbg85_enc_state sje;
struct jbg85_dec_state sjd;
int trouble = 0;
long l;
size_t plane_size, buffer_len;
int i, result;
unsigned char *image, *buffer;
size_t bpl;
size_t cnt;
bpl = (width + 7) / 8;
plane_size = bpl * height;
image = (unsigned char *) checkedmalloc(plane_size);
memcpy(image, orig_image, plane_size);
printf("\nTest-85 %s.1: Encoding ...\n", test_id);
testbuf_len = 0;
jbg85_enc_init(&sje, width, height, testbuf_writel, NULL);
jbg85_enc_options(&sje, options, l0, mx);
for (i = 0; i < height; i++)
jbg85_enc_lineout(&sje,
image + i * bpl,
image + (i-1) * bpl,
image + (i-2) * bpl);
free(image);
printf("Encoded BIE has %6ld bytes: ", testbuf_len);
if (correct_length >= 0)
if (testbuf_len == correct_length)
puts(PASSED);
else {
trouble++;
printf(FAILED ", correct would have been %ld\n", correct_length);
}
else
puts("");
#if 1
buffer_len = ((width >> 3) + !!(width & 7)) * 3;
buffer = (unsigned char *) checkedmalloc(buffer_len);
image = (unsigned char *) checkedmalloc(plane_size);
printf("Test-85 %s.2: Decoding whole chunk ...\n", test_id);
jbg85_dec_init(&sjd, buffer, buffer_len, line_out, image);
result = jbg85_dec_in(&sjd, testbuf, testbuf_len, &cnt);
if (result != JBG_EOK) {
printf("Decoder complained with return value 0x%02x: "
FAILED "\nCause: '%s'\n", result, jbg85_strerror(result));
printf("%ld bytes of BIE read, %lu lines decoded.\n",
(long) cnt, sjd.y);
trouble++;
} else {
printf("Image comparison: ");
result = 1;
if (memcmp(orig_image, image, plane_size)) {
result = 0;
trouble++;
printf(FAILED);
}
if (result)
puts(PASSED);
}
free(image);
image = (unsigned char *) checkedmalloc(plane_size);
printf("Test-85 %s.3: Decoding with single-byte feed ...\n", test_id);
jbg85_dec_init(&sjd, buffer, buffer_len, line_out, image);
result = JBG_EAGAIN;
for (l = 0; l < testbuf_len; l++) {
result = jbg85_dec_in(&sjd, testbuf + l, 1, NULL);
if (l < testbuf_len - 1 && result != JBG_EAGAIN) {
printf("Decoder complained with return value 0x%02x at byte %ld: "
FAILED "\nCause: '%s'\n", result, l, jbg85_strerror(result));
trouble++;
break;
}
}
if (l == testbuf_len) {
if (result != JBG_EOK) {
printf("Decoder complained with return value 0x%02x at final byte: "
FAILED "\nCause: '%s'\n", result, jbg85_strerror(result));
trouble++;
} else {
printf("Image comparison: ");
result = 1;
if (memcmp(orig_image, image, plane_size)) {
result = 0;
trouble++;
printf(FAILED);
}
if (result)
puts(PASSED);
}
}
free(image);
#endif
puts("");
return trouble != 0;
}
int main(int argc, char **argv)
{
int trouble, problems = 0;
struct jbg_arenc_state *se;
struct jbg_ardec_state *sd;
long i;
int pix;
unsigned char *pp;
int t82pix[16] = {
0x05e0, 0x0000, 0x8b00, 0x01c4, 0x1700, 0x0034, 0x7fff, 0x1a3f,
0x951b, 0x05d8, 0x1d17, 0xe770, 0x0000, 0x0000, 0x0656, 0x0e6a
};
int t82cx[16] = {
0x0fe0, 0x0000, 0x0f00, 0x00f0, 0xff00, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
};
unsigned char t82sde[32] = {
0x69, 0x89, 0x99, 0x5c, 0x32, 0xea, 0xfa, 0xa0,
0xd5, 0xff, 0x00, 0x52, 0x7f, 0xff, 0x00, 0xff,
0x00, 0xff, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x3f,
0xff, 0x00, 0x2d, 0x20, 0x82, 0x91, 0xff, 0x02
};
printf("\nAutomatic JBIG Compatibility Test Suite\n"
"---------------------------------------\n\n"
"JBIG-KIT Version " JBG85_VERSION " (T.85 version)"
" -- This test may take a few minutes.\n\n\n");
/* allocate test buffer memory */
testbuf = (unsigned char *) checkedmalloc(TESTBUF_SIZE);
testpic = (unsigned char *) checkedmalloc(TESTPIC_SIZE);
se = (struct jbg_arenc_state *) checkedmalloc(sizeof(struct jbg_arenc_state));
sd = (struct jbg_ardec_state *) checkedmalloc(sizeof(struct jbg_ardec_state));
/* only supported command line option:
* output file name for exporting test image */
if (argc > 1) {
FILE *f;
puts("Generating test image ...");
testimage(testpic);
printf("Storing in '%s' ...\n", argv[1]);
/* write out test image as PBM file */
f = fopen(argv[1], "wb");
if (!f) abort();
fprintf(f, "P4\n");
#if 0
fprintf(f, "# Test image as defined in ITU-T T.82, clause 7.2.1\n");
#endif
fprintf(f, "1960 1951\n");
fwrite(testpic, 1, TESTPIC_SIZE, f);
fclose(f);
exit(0);
}
#if 1
puts("1) Arithmetic encoder test sequence from ITU-T T.82, clause 7.1\n"
"---------------------------------------------------------------\n");
arith_encode_init(se, 0);
testbuf_len = 0;
se->byte_out = testbuf_write;
for (i = 0; i < 16 * 16; i++)
arith_encode(se, (t82cx[i >> 4] >> ((15 - i) & 15)) & 1,
(t82pix[i >> 4] >> ((15 - i) & 15)) & 1);
arith_encode_flush(se);
printf("result of encoder:\n ");
for (i = 0; i < testbuf_len && i < TESTBUF_SIZE; i++)
printf("%02x", testbuf[i]);
printf("\nexpected result:\n ");
for (i = 0; i < 30; i++)
printf("%02x", t82sde[i]);
printf("\n\nTest 1: ");
if (testbuf_len != 30 || memcmp(testbuf, t82sde, 30)) {
problems++;
printf(FAILED);
} else
printf(PASSED);
printf("\n\n");
puts("2) Arithmetic decoder test sequence from ITU-T T.82, clause 7.1\n"
"---------------------------------------------------------------\n");
printf("Test 2.1: Decoding whole chunk ...\n");
arith_decode_init(sd, 0);
sd->pscd_ptr = t82sde;
sd->pscd_end = t82sde + 32;
trouble = 0;
for (i = 0; i < 16 * 16 && !trouble; i++) {
pix = arith_decode(sd, (t82cx[i >> 4] >> ((15 - i) & 15)) & 1);
if (pix < 0) {
printf("Problem at pixel %ld, byte %ld.\n\n",
i+1, (long) (sd->pscd_ptr - sd->pscd_end));
trouble++;
break;
}
if (pix != ((t82pix[i >> 4] >> ((15 - i) & 15)) & 1)) {
printf("Wrong PIX answer (%d) at pixel %ld.\n\n", pix, i+1);
trouble++;
break;
}
}
if (!trouble && sd->pscd_ptr != sd->pscd_end - 2) {
printf("%ld bytes left after decoder finished.\n\n",
(long) (sd->pscd_end - sd->pscd_ptr - 2));
trouble++;
}
printf("Test result: ");
if (trouble) {
problems++;
puts(FAILED);
} else
puts(PASSED);
printf("\n");
printf("Test 2.2: Decoding with single byte feed ...\n");
arith_decode_init(sd, 0);
pp = t82sde;
sd->pscd_ptr = pp;
sd->pscd_end = pp + 1;
trouble = 0;
for (i = 0; i < 16 * 16 && !trouble; i++) {
pix = arith_decode(sd, (t82cx[i >> 4] >> ((15 - i) & 15)) & 1);
while (pix < 0 && sd->pscd_end < t82sde + 32) {
pp++;
if (sd->pscd_ptr != pp - 1)
sd->pscd_ptr = pp;
sd->pscd_end = pp + 1;
pix = arith_decode(sd, (t82cx[i >> 4] >> ((15 - i) & 15)) & 1);
}
if (pix < 0) {
printf("Problem at pixel %ld, byte %ld.\n\n",
i+1, (long) (sd->pscd_ptr - sd->pscd_end));
trouble++;
break;
}
if (pix != ((t82pix[i >> 4] >> ((15 - i) & 15)) & 1)) {
printf("Wrong PIX answer (%d) at pixel %ld.\n\n", pix, i+1);
trouble++;
break;
}
}
if (!trouble && sd->pscd_ptr != sd->pscd_end - 2) {
printf("%ld bytes left after decoder finished.\n\n",
(long) (sd->pscd_end - sd->pscd_ptr - 2));
trouble++;
}
printf("Test result: ");
if (trouble) {
problems++;
puts(FAILED);
} else
puts(PASSED);
printf("\n");
puts("3) Parametric algorithm test sequence from ITU-T T.82, clause 7.2\n"
"-----------------------------------------------------------------\n");
puts("Generating test image ...");
testimage(testpic);
putchar('\n');
puts("Test-85 3.1: TPBON=0, Mx=0, LRLTWO=0, L0=1951, 0 layers");
problems += test_cycle(testpic, 1960, 1951, 0,
1951, 0, 317384L, "3.1");
puts("Test-85 3.2: TPBON=0, Mx=0, LRLTWO=1, L0=1951, 0 layers");
problems += test_cycle(testpic, 1960, 1951, JBG_LRLTWO,
1951, 0, 317132L, "3.2");
puts("Test-85 3.3: TPBON=1, Mx=8, LRLTWO=0, L0=128, 0 layers");
problems += test_cycle(testpic, 1960, 1951, JBG_TPBON,
128, 8, 253653L, "3.3");
#endif
#if 0
puts("4) Same T.82 tests with SDRST instead of SDNORM\n"
"-----------------------------------------------\n");
puts("Test-85 4.0: TPBON=1, Mx=8, LRLTWO=0, L0=128, 0 layers");
problems += test_cycle(&pp, 1960, 1951, JBG_SDRST | JBG_TPBON,
128, 8, -1, "4.0");
puts("Test-85 4.1: TPBON=0, Mx=0, LRLTWO=0, L0=1951, 0 layers");
problems += test_cycle(&pp, 1960, 1951, JBG_SDRST,
1951, 0, -1, "4.1");
puts("Test-85 4.2: TPBON=0, Mx=0, LRLTWO=1, L0=1951, 0 layers");
problems += test_cycle(&pp, 1960, 1951, JBG_LRLTWO | JBG_SDRST,
1951, 0, -1, "4.2");
puts("Test-85 4.3: TPBON=1, Mx=8, LRLTWO=0, L0=128, 0 layers");
problems += test_cycle(&pp, 1960, 1951, JBG_TPBON | JBG_SDRST,
128, 8, -1, "4.3");
#endif
printf("\nTest result summary: the T.85 library has %s the test suite.\n\n",
problems ? FAILED : PASSED);
if (problems)
puts("This is bad. If you cannot identify the problem yourself, please "
"send\nthis output plus a detailed description of your "
"compile environment\n(OS, compiler, version, options, etc.) to "
"Markus Kuhn\n<http://www.cl.cam.ac.uk/~mgk25/>.");
else
puts("Congratulations, everything is fine.\n");
return problems != 0;
}