450 lines
12 KiB
C
450 lines
12 KiB
C
/*
|
|
* 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;
|
|
}
|