tbool
jpeg_decompress(uint8 * input, uint8 * output, int width, int height, int size, int bpp)
{
int lwidth = 0;
int lheight = 0;
int format;
switch (bpp)
{
case 24:
format = TJPF_RGB;
break;
case 32:
format = TJPF_BGRX;
break;
default:
return 0;
}
if (do_decompress((unsigned char *)input, size,
&lwidth, &lheight, bpp,
(unsigned char *) output, format) < 0)
{
return 0;
}
if (lwidth != width || lheight != height)
{
return 0;
}
return 1;
}
int main(int argc, char **argv)
{
const char *in_filename;
const char *out_filename;
int in_fd;
int out_fd;
uint32_t ctype;
uint32_t chunk_size;
int ret;
struct wimlib_decompressor *decompressor;
if (argc != 3) {
fprintf(stderr, "Usage: %s INFILE OUTFILE\n", argv[0]);
return 2;
}
in_filename = argv[1];
out_filename = argv[2];
/* Open input file and output file. */
in_fd = open(in_filename, O_RDONLY);
if (in_fd < 0)
error(1, errno, "Failed to open \"%s\"", in_filename);
out_fd = open(out_filename, O_WRONLY | O_TRUNC | O_CREAT, 0644);
if (out_fd < 0)
error(1, errno, "Failed to open \"%s\"", out_filename);
/* Get compression type and chunk size. */
if (read(in_fd, &ctype, sizeof(uint32_t)) != sizeof(uint32_t) ||
read(in_fd, &chunk_size, sizeof(uint32_t)) != sizeof(uint32_t))
error(1, errno, "Error reading from \"%s\"", in_filename);
/* Create a decompressor for the compression type and chunk size with
* the default parameters. */
ret = wimlib_create_decompressor(ctype, chunk_size, &decompressor);
if (ret != 0)
error(1, 0, "Failed to create decompressor: %s",
wimlib_get_error_string(ret));
/* Decompress and write the data. */
do_decompress(in_fd, in_filename,
out_fd, out_filename,
chunk_size, decompressor);
/* Cleanup and return. */
if (close(out_fd))
error(1, errno, "Error closing \"%s\"", out_filename);
wimlib_free_decompressor(decompressor);
return 0;
}
/* jpeg decompress */
tbool
jpeg_decompress(uint8 * input, uint8 * output, int width, int height, int size, int bpp)
{
int lwidth;
int lheight;
int lbpp;
int ldecomp_data_bytes;
if (bpp != 24)
{
return 0;
}
if (do_decompress((char*)input, size,
&lwidth, &lheight, &lbpp,
(char*)output, &ldecomp_data_bytes) != 0)
{
return 0;
}
if (lwidth != width || lheight != height || lbpp != bpp)
{
return 0;
}
return 1;
}
static
int process_file ( const compress_t *c, lzo_decompress_t decompress,
const char *method_name,
const char *file_name, lzo_uint l,
int t_loops, int c_loops, int d_loops )
{
int i;
unsigned blocks = 0;
unsigned long compressed_len = 0;
my_clock_t t_time = 0, c_time = 0, d_time = 0;
my_clock_t t_start, c_start, d_start;
#ifdef USE_DUMP
FILE *dump = NULL;
if (opt_dump_compressed_data)
dump = fopen(opt_dump_compressed_data,"wb");
#endif
/* process the file */
t_start = my_clock();
for (i = 0; i < t_loops; i++)
{
lzo_uint len, c_len, c_len_max, d_len = 0;
lzo_byte *d = data;
len = l;
c_len = 0;
blocks = 0;
/* process blocks */
if (len > 0 || opt_try_to_compress_0_bytes) do
{
int j;
int r;
const lzo_uint bl = len > opt_block_size ? opt_block_size : len;
lzo_uint bl_overwrite = bl;
#if defined(__LZO_CHECKER)
lzo_byte *dd = NULL;
lzo_byte *b1 = NULL;
lzo_byte *b2 = NULL;
const lzo_uint b1_len = bl + bl / 64 + 16 + 3;
#else
lzo_byte * const dd = d;
lzo_byte * const b1 = block1;
lzo_byte * const b2 = block2;
const lzo_uint b1_len = sizeof(_block1) - 256;
unsigned char random_byte;
random_byte = (unsigned char) my_clock();
#endif
blocks++;
/* may overwrite 3 bytes past the end of the decompressed block */
if (opt_use_asm_fast_decompressor)
bl_overwrite += (lzo_uint) sizeof(int) - 1;
#if defined(__LZO_CHECKER)
/* malloc a block of the exact size to detect any overrun */
dd = malloc(bl_overwrite > 0 ? bl_overwrite : 1);
b1 = malloc(b1_len);
b2 = dd;
if (dd == NULL || b1 == NULL)
{
perror("malloc");
return EXIT_MEM;
}
if (bl > 0)
memcpy(dd,d,bl);
#endif
/* compress the block */
c_len = c_len_max = 0;
c_start = my_clock();
for (j = r = 0; r == 0 && j < c_loops; j++)
{
c_len = b1_len;
r = do_compress(c,dd,bl,b1,&c_len);
if (r == 0 && c_len > c_len_max)
c_len_max = c_len;
}
c_time += my_clock() - c_start;
if (r != 0)
{
printf(" compression failed in block %d (%d) (%lu %lu)\n",
blocks, r, (long)c_len, (long)bl);
return EXIT_LZO_ERROR;
}
/* optimize the block */
if (opt_optimize_compressed_data)
{
d_len = bl;
r = do_optimize(c,b1,c_len,b2,&d_len);
if (r != 0 || d_len != bl)
{
printf(" optimization failed in block %d (%d) "
"(%lu %lu %lu)\n", blocks, r,
(long)c_len, (long)d_len, (long)bl);
return EXIT_LZO_ERROR;
}
}
#ifdef USE_DUMP
/* dump compressed data to disk */
if (dump)
{
lzo_fwrite(dump,b1,c_len);
fflush(dump);
}
#endif
/* decompress the block and verify */
#if defined(__LZO_CHECKER)
lzo_memset(b2,0,bl_overwrite);
#else
init_mem_checker(b2,_block2,bl_overwrite,random_byte);
#endif
d_start = my_clock();
for (j = r = 0; r == 0 && j < d_loops; j++)
{
d_len = bl;
r = do_decompress(c,decompress,b1,c_len,b2,&d_len);
if (d_len != bl)
break;
}
d_time += my_clock() - d_start;
if (r != 0)
{
printf(" decompression failed in block %d (%d) "
"(%lu %lu %lu)\n", blocks, r,
(long)c_len, (long)d_len, (long)bl);
return EXIT_LZO_ERROR;
}
if (d_len != bl)
{
printf(" decompression size error in block %d (%lu %lu %lu)\n",
blocks, (long)c_len, (long)d_len, (long)bl);
return EXIT_LZO_ERROR;
}
if (is_compressor(c))
{
if (lzo_memcmp(d,b2,bl) != 0)
{
lzo_uint x = 0;
while (x < bl && b2[x] == d[x])
x++;
printf(" decompression data error in block %d at offset "
"%lu (%lu %lu)\n", blocks, (long)x,
(long)c_len, (long)d_len);
if (opt_compute_adler32)
printf(" checksum: 0x%08lx 0x%08lx\n",
(long)adler_in, (long)adler_out);
#if 0
printf("Orig: ");
r = (x >= 10) ? -10 : 0 - (int) x;
for (j = r; j <= 10 && x + j < bl; j++)
printf(" %02x", (int)d[x+j]);
printf("\nDecomp:");
for (j = r; j <= 10 && x + j < bl; j++)
printf(" %02x", (int)b2[x+j]);
printf("\n");
#endif
return EXIT_LZO_ERROR;
}
if ((opt_compute_adler32 && adler_in != adler_out) ||
(opt_compute_crc32 && crc_in != crc_out))
{
printf(" checksum error in block %d (%lu %lu)\n",
blocks, (long)c_len, (long)d_len);
printf(" adler32: 0x%08lx 0x%08lx\n",
(long)adler_in, (long)adler_out);
printf(" crc32: 0x%08lx 0x%08lx\n",
(long)crc_in, (long)crc_out);
return EXIT_LZO_ERROR;
}
}
#if defined(__LZO_CHECKER)
/* free in reverse order of allocations */
free(b1);
free(dd);
#else
if (check_mem(b2,_block2,bl_overwrite,random_byte) != 0)
{
printf(" decompression overwrite error in block %d "
"(%lu %lu %lu)\n",
blocks, (long)c_len, (long)d_len, (long)bl);
return EXIT_LZO_ERROR;
}
#endif
d += bl;
len -= bl;
compressed_len += c_len_max;
}
while (len > 0);
}
t_time += my_clock() - t_start;
#ifdef USE_DUMP
if (dump)
fclose(dump);
opt_dump_compressed_data = NULL; /* only dump the first file */
#endif
print_stats(method_name, file_name,
t_loops, c_loops, d_loops,
t_time, c_time, d_time,
compressed_len, l, blocks);
return EXIT_OK;
}
int main(int argc, char * const argv[])
{
int c;
int decompress = 0, files = 1;
int selftest_compression = 0, selftest_decompression = 0;
const char *ifile_name, *ofile_name;
FILE *ifile, *ofile;
while((c = getopt(argc, argv, "S:dc")) != -1) {
switch (c) {
case 'S':
switch (optarg[0]) {
case 'c':
selftest_compression = 1;
break;
case 'd':
selftest_decompression = 1;
break;
default:
goto usage;
}
break;
case 'd':
decompress = 1;
break;
case 'c':
files = 0;
break;
default:
goto usage;
}
}
if (selftest_compression)
return do_selftest_compression();
if (selftest_decompression)
return do_selftest_decompression();
ifile = stdin;
ofile = stdout;
if (files) {
if (optind > argc - 2)
goto usage;
ifile_name = argv[optind];
ofile_name = argv[optind + 1];
if (!(ifile = fopen(ifile_name, "rb"))) {
perror("fopen of ifile_name");
return 2;
}
if (!(ofile = fopen(ofile_name, "wb"))) {
perror("fopen of ofile_name");
return 3;
}
}
if (decompress)
return do_decompress(ifile, ofile);
else
return do_compress(ifile, ofile);
usage:
fprintf(stderr,
"Usage:\n"
"cl_tester [-d] infile outfile\t-\t[de]compress infile to outfile.\n"
"cl_tester [-d] -c\t\t-\t[de]compress stdin to stdout.\n"
"cl_tester -S c\t\t\t-\tSelf-test compression.\n"
"cl_tester -S d\t\t\t-\tSelf-test decompression.\n");
return 1;
}
static int
decompress_file(struct deflate_decompressor *decompressor, const tchar *path,
const struct options *options)
{
tchar *newpath = NULL;
struct file_stream in;
struct file_stream out;
struct stat stbuf;
int ret;
int ret2;
if (path != NULL && !options->to_stdout) {
const tchar *suffix = get_suffix(path, options->suffix);
if (suffix == NULL) {
msg("\"%"TS"\" does not end with the .%"TS" suffix -- "
"skipping", path, options->suffix);
ret = -2;
goto out;
}
newpath = xmalloc((suffix - path + 1) * sizeof(tchar));
tmemcpy(newpath, path, suffix - path);
newpath[suffix - path] = '\0';
}
ret = xopen_for_read(path, &in);
if (ret != 0)
goto out_free_newpath;
if (!options->force && isatty(in.fd)) {
msg("Refusing to read compressed data from terminal. "
"Use -f to override.\nFor help, use -h.");
ret = -1;
goto out_close_in;
}
ret = stat_file(&in, &stbuf, options->force || newpath == NULL);
if (ret != 0)
goto out_close_in;
ret = xopen_for_write(newpath, options->force, &out);
if (ret != 0)
goto out_close_in;
ret = map_file_contents(&in, stbuf.st_size);
if (ret != 0)
goto out_close_out;
ret = do_decompress(decompressor, &in, &out);
if (ret != 0)
goto out_close_out;
if (path != NULL && newpath != NULL)
restore_metadata(&out, newpath, &stbuf);
ret = 0;
out_close_out:
ret2 = xclose(&out);
if (ret == 0)
ret = ret2;
if (ret != 0 && newpath != NULL)
tunlink(newpath);
out_close_in:
xclose(&in);
if (ret == 0 && path != NULL && newpath != NULL && !options->keep)
tunlink(path);
out_free_newpath:
free(newpath);
out:
return ret;
}
