zlib-streams 1.0.0

package/src/inflate9.h

@@ -0,0 +1,16 @@
+#ifndef ZLIB_INFLATE9_H_COMPAT
+#define ZLIB_INFLATE9_H_COMPAT
+
+#include "zutil.h"
+#include "inftree9.h"
+#include "inflate.h"
+
+int ZEXPORT inflate9Init(z_streamp strm);
+int ZEXPORT inflate9(z_streamp strm, int flush);
+int ZEXPORT inflate9End(z_streamp strm);
+int ZEXPORT inflate9Init_(z_streamp strm, const char *version, int stream_size);
+int ZEXPORT inflate9Init2_(z_streamp strm, int windowBits, const char *version,
+                           int stream_size);
+int ZEXPORT inflate9Reset2(z_streamp strm, int windowBits);
+
+#endif /* ZLIB_INFLATE9_H_COMPAT */

package/src/wasm/api/zlib-streams.js

@@ -0,0 +1,157 @@
+/* eslint-disable no-unused-vars */
+/* global Buffer, process, TransformStream */
+
+let wasm, malloc, free, memory;
+
+export function setWasmExports(wasmAPI) {
+	wasm = wasmAPI;
+	({ malloc, free, memory } = wasm);
+}
+
+function _make(isCompress, type, options = {}) {
+	const level = (typeof options.level === "number") ? options.level : -1;
+	const outBufferSize = (typeof options.outBuffer === "number") ? options.outBuffer : 64 * 1024;
+	const inBufferSize = (typeof options.inBufferSize === "number") ? options.inBufferSize : 64 * 1024;
+
+	return new TransformStream({
+		start() {
+			let result;
+			this.out = malloc(outBufferSize);
+			this.in = malloc(inBufferSize);
+			this.inBufferSize = inBufferSize;
+			this._scratch = new Uint8Array(outBufferSize);
+			if (isCompress) {
+				this._process = wasm.deflate_process;
+				this._last_consumed = wasm.deflate_last_consumed;
+				this._end = wasm.deflate_end;
+				this.streamHandle = wasm.deflate_new();
+				if (type === "gzip") {
+					result = wasm.deflate_init_gzip(this.streamHandle, level);
+				} else if (type === "deflate-raw") {
+					result = wasm.deflate_init_raw(this.streamHandle, level);
+				} else {
+					result = wasm.deflate_init(this.streamHandle, level);
+				}
+			} else {
+				if (type === "deflate64-raw") {
+					this._process = wasm.inflate9_process;
+					this._last_consumed = wasm.inflate9_last_consumed;
+					this._end = wasm.inflate9_end;
+					this.streamHandle = wasm.inflate9_new();
+					result = wasm.inflate9_init_raw(this.streamHandle);
+				} else {
+					this._process = wasm.inflate_process;
+					this._last_consumed = wasm.inflate_last_consumed;
+					this._end = wasm.inflate_end;
+					this.streamHandle = wasm.inflate_new();
+					if (type === "deflate-raw") {
+						result = wasm.inflate_init_raw(this.streamHandle);
+					} else if (type === "gzip") {
+						result = wasm.inflate_init_gzip(this.streamHandle);
+					} else {
+						result = wasm.inflate_init(this.streamHandle);
+					}
+				}
+			}
+			if (result !== 0) {
+				throw new Error("init failed:" + result);
+			}
+		},
+		transform(chunk, controller) {
+			try {
+				const buffer = chunk;
+				const heap = new Uint8Array(memory.buffer);
+				const process = this._process;
+				const last_consumed = this._last_consumed;
+				const out = this.out;
+				const scratch = this._scratch;
+				let offset = 0;
+				while (offset < buffer.length) {
+					const toRead = Math.min(buffer.length - offset, 32 * 1024);
+					if (!this.in || this.inBufferSize < toRead) {
+						if (this.in && free) {
+							free(this.in);
+						}
+						this.in = malloc(toRead);
+						this.inBufferSize = toRead;
+					}
+					heap.set(buffer.subarray(offset, offset + toRead), this.in);
+					const result = process(this.streamHandle, this.in, toRead, out, outBufferSize, 0);
+					if (!isCompress && result < 0) {
+						throw new Error("process error:" + result);
+					}
+					const prod = result & 0x00ffffff;
+					if (prod) {
+						scratch.set(heap.subarray(out, out + prod), 0);
+						controller.enqueue(scratch.slice(0, prod));
+					}
+					const consumed = last_consumed(this.streamHandle);
+					if (consumed === 0) {
+						break;
+					}
+					offset += consumed;
+				}
+			} catch (error) {
+				if (this._end && this.streamHandle) {
+					this._end(this.streamHandle);
+				}
+				if (this.in && free) {
+					free(this.in);
+				}
+				if (this.out && free) {
+					free(this.out);
+				}
+				controller.error(error);
+			}
+		},
+		flush(controller) {
+			try {
+				const heap = new Uint8Array(memory.buffer);
+				const process = this._process;
+				const out = this.out;
+				const scratch = this._scratch;
+				while (true) {
+					const result = process(this.streamHandle, 0, 0, out, outBufferSize, 4);
+					if (!isCompress && result < 0) {
+						throw new Error("process error:" + result);
+					}
+					const produced = result & 0x00ffffff;
+					const code = (result >> 24) & 0xff;
+					if (produced) {
+						scratch.set(heap.subarray(out, out + produced), 0);
+						controller.enqueue(scratch.slice(0, produced));
+					}
+					if (code === 1 || produced === 0) {
+						break;
+					}
+				}
+			} catch (error) {
+				controller.error(error);
+			} finally {
+				if (this._end && this.streamHandle) {
+					const result = this._end(this.streamHandle);
+					if (result !== 0) {
+						controller.error(new Error("end error:" + result));
+					}
+				}
+				if (this.in && free) {
+					free(this.in);
+				}
+				if (this.out && free) {
+					free(this.out);
+				}
+			}
+		}
+	});
+}
+
+export class CompressionStreamZlib {
+	constructor(type = "deflate", options) {
+		return _make(true, type, options);
+	}
+}
+export class DecompressionStreamZlib {
+	constructor(type = "deflate", options) {
+		return _make(false, type, options);
+	}
+}

package/src/wasm/deflate_stream_wasm.c

@@ -0,0 +1,103 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include "zlib.h"
+
+#ifndef RAW_WBITS
+#if defined(MAX_WBITS)
+#define RAW_WBITS MAX_WBITS
+#else
+#define RAW_WBITS 15
+#endif
+#endif
+
+struct wasm_deflate_ctx {
+  z_stream strm;
+  unsigned char *inbuf;
+  unsigned inbuf_sz;
+  unsigned last_consumed;
+};
+
+unsigned deflate_new(void) {
+  struct wasm_deflate_ctx *c = (struct wasm_deflate_ctx *)malloc(sizeof(*c));
+  if (!c)
+    return 0;
+  memset(c, 0, sizeof(*c));
+  c->strm.zalloc = Z_NULL;
+  c->strm.zfree = Z_NULL;
+  c->strm.opaque = Z_NULL;
+  c->inbuf = NULL;
+  c->inbuf_sz = 0;
+  return (unsigned)(uintptr_t)c;
+}
+
+int deflate_init(unsigned zptr, int level) {
+  struct wasm_deflate_ctx *c = (struct wasm_deflate_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+  if (level < 0)
+    level = Z_DEFAULT_COMPRESSION;
+  return deflateInit(&c->strm, level);
+}
+
+int deflate_init_raw(unsigned zptr, int level) {
+  struct wasm_deflate_ctx *c = (struct wasm_deflate_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+  if (level < 0)
+    level = Z_DEFAULT_COMPRESSION;
+  return deflateInit2(&c->strm, level, Z_DEFLATED, -RAW_WBITS, 8,
+                      Z_DEFAULT_STRATEGY);
+}
+
+int deflate_init_gzip(unsigned zptr, int level) {
+  struct wasm_deflate_ctx *c = (struct wasm_deflate_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+  if (level < 0)
+    level = Z_DEFAULT_COMPRESSION;
+  return deflateInit2(&c->strm, level, Z_DEFLATED, MAX_WBITS + 16, 8,
+                      Z_DEFAULT_STRATEGY);
+}
+
+int deflate_process(unsigned zptr, unsigned in_ptr, unsigned in_len,
+                    unsigned out_ptr, unsigned out_len, int flush) {
+  struct wasm_deflate_ctx *c = (struct wasm_deflate_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+  if (in_len > c->inbuf_sz) {
+    unsigned char *nb = (unsigned char *)realloc(c->inbuf, in_len);
+    if (!nb)
+      return Z_MEM_ERROR;
+    c->inbuf = nb;
+    c->inbuf_sz = in_len;
+  }
+  memcpy(c->inbuf, (unsigned char *)(uintptr_t)in_ptr, in_len);
+  c->strm.next_in = c->inbuf;
+  c->strm.avail_in = in_len;
+  c->strm.next_out = (unsigned char *)(uintptr_t)out_ptr;
+  c->strm.avail_out = out_len;
+
+  int ret = deflate(&c->strm, flush);
+  int produced = (int)(out_len - c->strm.avail_out);
+  c->last_consumed = (unsigned)(in_len - c->strm.avail_in);
+  int code = ret & 0xff;
+  return (produced & 0x00ffffff) | ((code & 0xff) << 24);
+}
+
+int deflate_end(unsigned zptr) {
+  struct wasm_deflate_ctx *c = (struct wasm_deflate_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+  int r = deflateEnd(&c->strm);
+  free(c->inbuf);
+  free(c);
+  return r;
+}
+
+unsigned deflate_last_consumed(unsigned zptr) {
+  struct wasm_deflate_ctx *c = (struct wasm_deflate_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return 0;
+  return c->last_consumed;
+}

package/src/wasm/inflate9_stream_wasm.c

@@ -0,0 +1,89 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include "zlib.h"
+#include "inflate9.h"
+#ifndef DEFLATE64_WBITS
+#if defined(MAX_WBITS) && (MAX_WBITS >= 16)
+#define DEFLATE64_WBITS MAX_WBITS
+#else
+#define DEFLATE64_WBITS 16
+#endif
+#endif
+
+struct wasm_inflate9_ctx {
+  z_stream strm;
+  unsigned char *inbuf;
+  unsigned inbuf_sz;
+  unsigned last_consumed;
+};
+
+unsigned inflate9_new(void) {
+  struct wasm_inflate9_ctx *c = (struct wasm_inflate9_ctx *)malloc(sizeof(*c));
+  if (!c)
+    return 0;
+  memset(c, 0, sizeof(*c));
+  c->strm.zalloc = Z_NULL;
+  c->strm.zfree = Z_NULL;
+  c->strm.opaque = Z_NULL;
+  c->inbuf = NULL;
+  c->inbuf_sz = 0;
+  return (unsigned)(uintptr_t)c;
+}
+
+int inflate9_init(unsigned zptr) {
+  struct wasm_inflate9_ctx *c = (struct wasm_inflate9_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+  return inflate9Init(&c->strm);
+}
+
+int inflate9_init_raw(unsigned zptr) {
+  struct wasm_inflate9_ctx *c = (struct wasm_inflate9_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+  return inflate9Init2_(&c->strm, -DEFLATE64_WBITS, ZLIB_VERSION,
+                        (int)sizeof(z_stream));
+}
+
+int inflate9_process(unsigned zptr, unsigned in_ptr, unsigned in_len,
+                     unsigned out_ptr, unsigned out_len, int flush) {
+  struct wasm_inflate9_ctx *c = (struct wasm_inflate9_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+  if (in_len > c->inbuf_sz) {
+    unsigned char *nb = (unsigned char *)realloc(c->inbuf, in_len);
+    if (!nb)
+      return Z_MEM_ERROR;
+    c->inbuf = nb;
+    c->inbuf_sz = in_len;
+  }
+  memcpy(c->inbuf, (unsigned char *)(uintptr_t)in_ptr, in_len);
+  c->strm.next_in = c->inbuf;
+  c->strm.avail_in = in_len;
+  c->strm.next_out = (unsigned char *)(uintptr_t)out_ptr;
+  c->strm.avail_out = out_len;
+
+  int ret = inflate9(&c->strm, flush);
+  int produced = (int)(out_len - c->strm.avail_out);
+  c->last_consumed = (unsigned)(in_len - c->strm.avail_in);
+  int code = ret & 0xff;
+  return (produced & 0x00ffffff) | ((code & 0xff) << 24);
+}
+
+int inflate9_end(unsigned zptr) {
+  struct wasm_inflate9_ctx *c = (struct wasm_inflate9_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+  int r = inflate9End(&c->strm);
+  free(c->inbuf);
+  free(c);
+  return r;
+}
+
+unsigned inflate9_last_consumed(unsigned zptr) {
+  struct wasm_inflate9_ctx *c = (struct wasm_inflate9_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return 0;
+  return c->last_consumed;
+}

package/src/wasm/inflate_stream_wasm.c

@@ -0,0 +1,99 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include "zlib.h"
+
+#ifndef RAW_WBITS
+#if defined(MAX_WBITS)
+#define RAW_WBITS MAX_WBITS
+#else
+#define RAW_WBITS 15
+#endif
+#endif
+
+struct wasm_inflate_ctx {
+  z_stream strm;
+  unsigned char *inbuf;
+  unsigned inbuf_sz;
+  unsigned last_consumed;
+};
+
+unsigned inflate_new(void) {
+  struct wasm_inflate_ctx *c = (struct wasm_inflate_ctx *)malloc(sizeof(*c));
+  if (!c)
+    return 0;
+  memset(c, 0, sizeof(*c));
+  c->strm.zalloc = Z_NULL;
+  c->strm.zfree = Z_NULL;
+  c->strm.opaque = Z_NULL;
+  c->inbuf = NULL;
+  c->inbuf_sz = 0;
+  return (unsigned)(uintptr_t)c;
+}
+
+int inflate_init(unsigned zptr) {
+  struct wasm_inflate_ctx *c = (struct wasm_inflate_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+  return inflateInit(&c->strm);
+}
+
+int inflate_init_raw(unsigned zptr) {
+  struct wasm_inflate_ctx *c = (struct wasm_inflate_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+  return inflateInit2(&c->strm, -RAW_WBITS);
+}
+
+int inflate_init_gzip(unsigned zptr) {
+  struct wasm_inflate_ctx *c = (struct wasm_inflate_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+#if defined(MAX_WBITS)
+  return inflateInit2(&c->strm, MAX_WBITS + 16);
+#else
+  return inflateInit2(&c->strm, RAW_WBITS + 16);
+#endif
+}
+
+int inflate_process(unsigned zptr, unsigned in_ptr, unsigned in_len,
+                    unsigned out_ptr, unsigned out_len, int flush) {
+  struct wasm_inflate_ctx *c = (struct wasm_inflate_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+  if (in_len > c->inbuf_sz) {
+    unsigned char *nb = (unsigned char *)realloc(c->inbuf, in_len);
+    if (!nb)
+      return Z_MEM_ERROR;
+    c->inbuf = nb;
+    c->inbuf_sz = in_len;
+  }
+  memcpy(c->inbuf, (unsigned char *)(uintptr_t)in_ptr, in_len);
+  c->strm.next_in = c->inbuf;
+  c->strm.avail_in = in_len;
+  c->strm.next_out = (unsigned char *)(uintptr_t)out_ptr;
+  c->strm.avail_out = out_len;
+
+  int ret = inflate(&c->strm, flush);
+  int produced = (int)(out_len - c->strm.avail_out);
+  c->last_consumed = (unsigned)(in_len - c->strm.avail_in);
+  int code = ret & 0xff;
+  return (produced & 0x00ffffff) | ((code & 0xff) << 24);
+}
+
+int inflate_end(unsigned zptr) {
+  struct wasm_inflate_ctx *c = (struct wasm_inflate_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return Z_STREAM_ERROR;
+  int r = inflateEnd(&c->strm);
+  free(c->inbuf);
+  free(c);
+  return r;
+}
+
+unsigned inflate_last_consumed(unsigned zptr) {
+  struct wasm_inflate_ctx *c = (struct wasm_inflate_ctx *)(uintptr_t)zptr;
+  if (!c)
+    return 0;
+  return c->last_consumed;
+}