zlib/examples/fitblk.c - third_party/binutils-gdb - Git at Google

 /* fitblk.c: example of fitting compressed output to a specified size
    Not copyrighted -- provided to the public domain
    Version 1.1  25 November 2004  Mark Adler */

 /* Version history:
    1.0  24 Nov 2004  First version
    1.1  25 Nov 2004  Change deflateInit2() to deflateInit()
                      Use fixed-size, stack-allocated raw buffers
                      Simplify code moving compression to subroutines
                      Use assert() for internal errors
                      Add detailed description of approach
  */

 /* Approach to just fitting a requested compressed size:

    fitblk performs three compression passes on a portion of the input
    data in order to determine how much of that input will compress to
    nearly the requested output block size.  The first pass generates
    enough deflate blocks to produce output to fill the requested
    output size plus a specfied excess amount (see the EXCESS define
    below).  The last deflate block may go quite a bit past that, but
    is discarded.  The second pass decompresses and recompresses just
    the compressed data that fit in the requested plus excess sized
    buffer.  The deflate process is terminated after that amount of
    input, which is less than the amount consumed on the first pass.
    The last deflate block of the result will be of a comparable size
    to the final product, so that the header for that deflate block and
    the compression ratio for that block will be about the same as in
    the final product.  The third compression pass decompresses the
    result of the second step, but only the compressed data up to the
    requested size minus an amount to allow the compressed stream to
    complete (see the MARGIN define below).  That will result in a
    final compressed stream whose length is less than or equal to the
    requested size.  Assuming sufficient input and a requested size
    greater than a few hundred bytes, the shortfall will typically be
    less than ten bytes.

    If the input is short enough that the first compression completes
    before filling the requested output size, then that compressed
    stream is return with no recompression.

    EXCESS is chosen to be just greater than the shortfall seen in a
    two pass approach similar to the above.  That shortfall is due to
    the last deflate block compressing more efficiently with a smaller
    header on the second pass.  EXCESS is set to be large enough so
    that there is enough uncompressed data for the second pass to fill
    out the requested size, and small enough so that the final deflate
    block of the second pass will be close in size to the final deflate
    block of the third and final pass.  MARGIN is chosen to be just
    large enough to assure that the final compression has enough room
    to complete in all cases.
  */

 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
 #include "zlib.h"

 #define local static

 /* print nastygram and leave */
 local void quit(char *why)
 {
     fprintf(stderr, "fitblk abort: %s\n", why);
     exit(1);
 }

 #define RAWLEN 4096    /* intermediate uncompressed buffer size */

 /* compress from file to def until provided buffer is full or end of
    input reached; return last deflate() return value, or Z_ERRNO if
    there was read error on the file */
 local int partcompress(FILE *in, z_streamp def)
 {
     int ret, flush;
     unsigned char raw[RAWLEN];

     flush = Z_NO_FLUSH;
     do {
         def->avail_in = fread(raw, 1, RAWLEN, in);
         if (ferror(in))
             return Z_ERRNO;
         def->next_in = raw;
         if (feof(in))
             flush = Z_FINISH;
         ret = deflate(def, flush);
         assert(ret != Z_STREAM_ERROR);
     } while (def->avail_out != 0 && flush == Z_NO_FLUSH);
     return ret;
 }

 /* recompress from inf's input to def's output; the input for inf and
    the output for def are set in those structures before calling;
    return last deflate() return value, or Z_MEM_ERROR if inflate()
    was not able to allocate enough memory when it needed to */
 local int recompress(z_streamp inf, z_streamp def)
 {
     int ret, flush;
     unsigned char raw[RAWLEN];

     flush = Z_NO_FLUSH;
     do {
         /* decompress */
         inf->avail_out = RAWLEN;
         inf->next_out = raw;
         ret = inflate(inf, Z_NO_FLUSH);
         assert(ret != Z_STREAM_ERROR && ret != Z_DATA_ERROR &&
                ret != Z_NEED_DICT);
         if (ret == Z_MEM_ERROR)
             return ret;

         /* compress what was decompresed until done or no room */
         def->avail_in = RAWLEN - inf->avail_out;
         def->next_in = raw;
         if (inf->avail_out != 0)
             flush = Z_FINISH;
         ret = deflate(def, flush);
         assert(ret != Z_STREAM_ERROR);
     } while (ret != Z_STREAM_END && def->avail_out != 0);
     return ret;
 }

 #define EXCESS 256      /* empirically determined stream overage */
 #define MARGIN 8        /* amount to back off for completion */

 /* compress from stdin to fixed-size block on stdout */
 int main(int argc, char **argv)
 {
     int ret;                /* return code */
     unsigned size;          /* requested fixed output block size */
     unsigned have;          /* bytes written by deflate() call */
     unsigned char *blk;     /* intermediate and final stream */
     unsigned char *tmp;     /* close to desired size stream */
     z_stream def, inf;      /* zlib deflate and inflate states */

     /* get requested output size */
     if (argc != 2)
         quit("need one argument: size of output block");
     ret = strtol(argv[1], argv + 1, 10);
     if (argv[1][0] != 0)
         quit("argument must be a number");
     if (ret < 8)            /* 8 is minimum zlib stream size */
         quit("need positive size of 8 or greater");
     size = (unsigned)ret;

     /* allocate memory for buffers and compression engine */
     blk = malloc(size + EXCESS);
     def.zalloc = Z_NULL;
     def.zfree = Z_NULL;
     def.opaque = Z_NULL;
     ret = deflateInit(&def, Z_DEFAULT_COMPRESSION);
     if (ret != Z_OK || blk == NULL)
         quit("out of memory");

     /* compress from stdin until output full, or no more input */
     def.avail_out = size + EXCESS;
     def.next_out = blk;
     ret = partcompress(stdin, &def);
     if (ret == Z_ERRNO)
         quit("error reading input");

     /* if it all fit, then size was undersubscribed -- done! */
     if (ret == Z_STREAM_END && def.avail_out >= EXCESS) {
         /* write block to stdout */
         have = size + EXCESS - def.avail_out;
         if (fwrite(blk, 1, have, stdout) != have || ferror(stdout))
             quit("error writing output");

         /* clean up and print results to stderr */
         ret = deflateEnd(&def);
         assert(ret != Z_STREAM_ERROR);
         free(blk);
         fprintf(stderr,
                 "%u bytes unused out of %u requested (all input)\n",
                 size - have, size);
         return 0;
     }

     /* it didn't all fit -- set up for recompression */
     inf.zalloc = Z_NULL;
     inf.zfree = Z_NULL;
     inf.opaque = Z_NULL;
     inf.avail_in = 0;
     inf.next_in = Z_NULL;
     ret = inflateInit(&inf);
     tmp = malloc(size + EXCESS);
     if (ret != Z_OK || tmp == NULL)
         quit("out of memory");
     ret = deflateReset(&def);
     assert(ret != Z_STREAM_ERROR);

     /* do first recompression close to the right amount */
     inf.avail_in = size + EXCESS;
     inf.next_in = blk;
     def.avail_out = size + EXCESS;
     def.next_out = tmp;
     ret = recompress(&inf, &def);
     if (ret == Z_MEM_ERROR)
         quit("out of memory");

     /* set up for next reocmpression */
     ret = inflateReset(&inf);
     assert(ret != Z_STREAM_ERROR);
     ret = deflateReset(&def);
     assert(ret != Z_STREAM_ERROR);

     /* do second and final recompression (third compression) */
     inf.avail_in = size - MARGIN;   /* assure stream will complete */
     inf.next_in = tmp;
     def.avail_out = size;
     def.next_out = blk;
     ret = recompress(&inf, &def);
     if (ret == Z_MEM_ERROR)
         quit("out of memory");
     assert(ret == Z_STREAM_END);    /* otherwise MARGIN too small */

     /* done -- write block to stdout */
     have = size - def.avail_out;
     if (fwrite(blk, 1, have, stdout) != have || ferror(stdout))
         quit("error writing output");

     /* clean up and print results to stderr */
     free(tmp);
     ret = inflateEnd(&inf);
     assert(ret != Z_STREAM_ERROR);
     ret = deflateEnd(&def);
     assert(ret != Z_STREAM_ERROR);
     free(blk);
     fprintf(stderr,
             "%u bytes unused out of %u requested (%lu input)\n",
             size - have, size, def.total_in);
     return 0;
 }
	/* fitblk.c: example of fitting compressed output to a specified size
	Not copyrighted -- provided to the public domain
	Version 1.1 25 November 2004 Mark Adler */

	/* Version history:
	1.0 24 Nov 2004 First version
	1.1 25 Nov 2004 Change deflateInit2() to deflateInit()
	Use fixed-size, stack-allocated raw buffers
	Simplify code moving compression to subroutines
	Use assert() for internal errors
	Add detailed description of approach
	*/

	/* Approach to just fitting a requested compressed size:

	fitblk performs three compression passes on a portion of the input
	data in order to determine how much of that input will compress to
	nearly the requested output block size. The first pass generates
	enough deflate blocks to produce output to fill the requested
	output size plus a specfied excess amount (see the EXCESS define
	below). The last deflate block may go quite a bit past that, but
	is discarded. The second pass decompresses and recompresses just
	the compressed data that fit in the requested plus excess sized
	buffer. The deflate process is terminated after that amount of
	input, which is less than the amount consumed on the first pass.
	The last deflate block of the result will be of a comparable size
	to the final product, so that the header for that deflate block and
	the compression ratio for that block will be about the same as in
	the final product. The third compression pass decompresses the
	result of the second step, but only the compressed data up to the
	requested size minus an amount to allow the compressed stream to
	complete (see the MARGIN define below). That will result in a
	final compressed stream whose length is less than or equal to the
	requested size. Assuming sufficient input and a requested size
	greater than a few hundred bytes, the shortfall will typically be
	less than ten bytes.

	If the input is short enough that the first compression completes
	before filling the requested output size, then that compressed
	stream is return with no recompression.

	EXCESS is chosen to be just greater than the shortfall seen in a
	two pass approach similar to the above. That shortfall is due to
	the last deflate block compressing more efficiently with a smaller
	header on the second pass. EXCESS is set to be large enough so
	that there is enough uncompressed data for the second pass to fill
	out the requested size, and small enough so that the final deflate
	block of the second pass will be close in size to the final deflate
	block of the third and final pass. MARGIN is chosen to be just
	large enough to assure that the final compression has enough room
	to complete in all cases.
	*/

	#include <stdio.h>
	#include <stdlib.h>
	#include <assert.h>
	#include "zlib.h"

	#define local static

	/* print nastygram and leave */
	local void quit(char *why)
	{
	fprintf(stderr, "fitblk abort: %s\n", why);
	exit(1);
	}

	#define RAWLEN 4096 /* intermediate uncompressed buffer size */

	/* compress from file to def until provided buffer is full or end of
	input reached; return last deflate() return value, or Z_ERRNO if
	there was read error on the file */
	local int partcompress(FILE *in, z_streamp def)
	{
	int ret, flush;
	unsigned char raw[RAWLEN];

	flush = Z_NO_FLUSH;
	do {
	def->avail_in = fread(raw, 1, RAWLEN, in);
	if (ferror(in))
	return Z_ERRNO;
	def->next_in = raw;
	if (feof(in))
	flush = Z_FINISH;
	ret = deflate(def, flush);
	assert(ret != Z_STREAM_ERROR);
	} while (def->avail_out != 0 && flush == Z_NO_FLUSH);
	return ret;
	}

	/* recompress from inf's input to def's output; the input for inf and
	the output for def are set in those structures before calling;
	return last deflate() return value, or Z_MEM_ERROR if inflate()
	was not able to allocate enough memory when it needed to */
	local int recompress(z_streamp inf, z_streamp def)
	{
	int ret, flush;
	unsigned char raw[RAWLEN];

	flush = Z_NO_FLUSH;
	do {
	/* decompress */
	inf->avail_out = RAWLEN;
	inf->next_out = raw;
	ret = inflate(inf, Z_NO_FLUSH);
	assert(ret != Z_STREAM_ERROR && ret != Z_DATA_ERROR &&
	ret != Z_NEED_DICT);
	if (ret == Z_MEM_ERROR)
	return ret;

	/* compress what was decompresed until done or no room */
	def->avail_in = RAWLEN - inf->avail_out;
	def->next_in = raw;
	if (inf->avail_out != 0)
	flush = Z_FINISH;
	ret = deflate(def, flush);
	assert(ret != Z_STREAM_ERROR);
	} while (ret != Z_STREAM_END && def->avail_out != 0);
	return ret;
	}

	#define EXCESS 256 /* empirically determined stream overage */
	#define MARGIN 8 /* amount to back off for completion */

	/* compress from stdin to fixed-size block on stdout */
	int main(int argc, char **argv)
	{
	int ret; /* return code */
	unsigned size; /* requested fixed output block size */
	unsigned have; /* bytes written by deflate() call */
	unsigned char blk; / intermediate and final stream */
	unsigned char tmp; / close to desired size stream */
	z_stream def, inf; /* zlib deflate and inflate states */

	/* get requested output size */
	if (argc != 2)
	quit("need one argument: size of output block");
	ret = strtol(argv[1], argv + 1, 10);
	if (argv[1][0] != 0)
	quit("argument must be a number");
	if (ret < 8) /* 8 is minimum zlib stream size */
	quit("need positive size of 8 or greater");
	size = (unsigned)ret;

	/* allocate memory for buffers and compression engine */
	blk = malloc(size + EXCESS);
	def.zalloc = Z_NULL;
	def.zfree = Z_NULL;
	def.opaque = Z_NULL;
	ret = deflateInit(&def, Z_DEFAULT_COMPRESSION);
	if (ret != Z_OK \|\| blk == NULL)
	quit("out of memory");

	/* compress from stdin until output full, or no more input */
	def.avail_out = size + EXCESS;
	def.next_out = blk;
	ret = partcompress(stdin, &def);
	if (ret == Z_ERRNO)
	quit("error reading input");

	/* if it all fit, then size was undersubscribed -- done! */
	if (ret == Z_STREAM_END && def.avail_out >= EXCESS) {
	/* write block to stdout */
	have = size + EXCESS - def.avail_out;
	if (fwrite(blk, 1, have, stdout) != have \|\| ferror(stdout))
	quit("error writing output");

	/* clean up and print results to stderr */
	ret = deflateEnd(&def);
	assert(ret != Z_STREAM_ERROR);
	free(blk);
	fprintf(stderr,
	"%u bytes unused out of %u requested (all input)\n",
	size - have, size);
	return 0;
	}

	/* it didn't all fit -- set up for recompression */
	inf.zalloc = Z_NULL;
	inf.zfree = Z_NULL;
	inf.opaque = Z_NULL;
	inf.avail_in = 0;
	inf.next_in = Z_NULL;
	ret = inflateInit(&inf);
	tmp = malloc(size + EXCESS);
	if (ret != Z_OK \|\| tmp == NULL)
	quit("out of memory");
	ret = deflateReset(&def);
	assert(ret != Z_STREAM_ERROR);

	/* do first recompression close to the right amount */
	inf.avail_in = size + EXCESS;
	inf.next_in = blk;
	def.avail_out = size + EXCESS;
	def.next_out = tmp;
	ret = recompress(&inf, &def);
	if (ret == Z_MEM_ERROR)
	quit("out of memory");

	/* set up for next reocmpression */
	ret = inflateReset(&inf);
	assert(ret != Z_STREAM_ERROR);
	ret = deflateReset(&def);
	assert(ret != Z_STREAM_ERROR);

	/* do second and final recompression (third compression) */
	inf.avail_in = size - MARGIN; /* assure stream will complete */
	inf.next_in = tmp;
	def.avail_out = size;
	def.next_out = blk;
	ret = recompress(&inf, &def);
	if (ret == Z_MEM_ERROR)
	quit("out of memory");
	assert(ret == Z_STREAM_END); /* otherwise MARGIN too small */

	/* done -- write block to stdout */
	have = size - def.avail_out;
	if (fwrite(blk, 1, have, stdout) != have \|\| ferror(stdout))
	quit("error writing output");

	/* clean up and print results to stderr */
	free(tmp);
	ret = inflateEnd(&inf);
	assert(ret != Z_STREAM_ERROR);
	ret = deflateEnd(&def);
	assert(ret != Z_STREAM_ERROR);
	free(blk);
	fprintf(stderr,
	"%u bytes unused out of %u requested (%lu input)\n",
	size - have, size, def.total_in);
	return 0;
	}