Initial import

third_party/zlib/compress.c

@@ -0,0 +1,88 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-│
+│vi: set net ft=c ts=4 sts=4 sw=4 fenc=utf-8                                :vi│
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler                 │
+│ Use of this source code is governed by the BSD-style licenses that can       │
+│ be found in the third_party/zlib/LICENSE file.                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "third_party/zlib/zlib.h"
+
+asm(".ident\t\"\\n\\n\
+zlib (zlib License)\\n\
+Copyright 1995-2017 Jean-loup Gailly and Mark Adler\"");
+asm(".include \"libc/disclaimer.inc\"");
+
+int compress(Bytef *dest, uLongf *destLen, const Bytef *source,
+             uLong sourceLen) {
+  return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
+}
+
+/**
+ * Compresses the source buffer into the destination buffer. The level
+ * parameter has the same meaning as in deflateInit. sourceLen is the
+ * byte length of the source buffer. Upon entry, destLen is the total
+ * size of the destination buffer, which must be at least 0.1% larger
+ * than sourceLen plus 12 bytes. Upon exit, destLen is the actual size
+ * of the compressed buffer.
+ *
+ * @return Z_OK if success, Z_MEM_ERROR if there was not enough memory,
+ *     Z_BUF_ERROR if there was not enough room in the output buffer,
+ *     Z_STREAM_ERROR if the level parameter is invalid.
+ */
+int compress2(Bytef *dest, uLongf *destLen, const Bytef *source,
+              uLong sourceLen, int level) {
+  z_stream stream;
+  int err;
+  const uInt max = (uInt)-1;
+  uLong left;
+
+  left = *destLen;
+  *destLen = 0;
+
+  stream.zalloc = (alloc_func)0;
+  stream.zfree = (free_func)0;
+  stream.opaque = (voidpf)0;
+
+  err = deflateInit(&stream, level);
+  if (err != Z_OK) return err;
+
+  stream.next_out = dest;
+  stream.avail_out = 0;
+  stream.next_in = (const Bytef *)source;
+  stream.avail_in = 0;
+
+  do {
+    if (stream.avail_out == 0) {
+      stream.avail_out = left > (uLong)max ? max : (uInt)left;
+      left -= stream.avail_out;
+    }
+    if (stream.avail_in == 0) {
+      stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen;
+      sourceLen -= stream.avail_in;
+    }
+    err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH);
+  } while (err == Z_OK);
+
+  *destLen = stream.total_out;
+  deflateEnd(&stream);
+  return err == Z_STREAM_END ? Z_OK : err;
+}
+
+/**
+ * If the default memLevel or windowBits for deflateInit() is changed,
+ * then this function needs to be updated.
+ */
+uLong compressBound(uLong sourceLen) {
+  sourceLen = sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
+              (sourceLen >> 25) + 13;
+  /* FIXME(cavalcantii): usage of CRC32 Castagnoli as a hash function
+   * for the hash table of symbols used for compression has a side effect
+   * where for compression level [4, 5] it will increase the output buffer
+   * size by 0.1% (i.e. less than 1%) for a high entropy input (i.e. random
+   * data). To avoid a scenario where client code would fail, for safety we
+   * increase the expected output size by 0.8% (i.e. 8x more than the worst
+   * scenario). See: http://crbug.com/990489
+   */
+  sourceLen += sourceLen >> 7;  // Equivalent to 1.0078125
+  return sourceLen;
+}