las-laz-js 0.3.1 → 0.4.0

package/src/laz/v3/layered.js

@@ -6,20 +6,27 @@
 // Point14 passes on, with the version-3 quirk preserved: a context
 // first used is seeded from the last one, and in version 3 later
 // values are predicted from whichever context it was entered from.
+// Each compressor shares its decompressor's setup and context switch,
+// so the two stay in step point for point.
 //
 // Ported from laz-rs src/las/rgb.rs, nir.rs and extra_bytes.rs, modules
 // v3_v4 (https://github.com/laz-rs/laz-rs), itself a port of LASzip by
 // rapidlasso. (c) 2007-2015 martin isenburg, rapidlasso; (c) 2019-2023
 // Thomas Montaigu.
 // Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE and
-// NOTICE). Changes: translated from Rust to JavaScript, Brent Buffham 2026.
+// NOTICE). Changes: translated from Rust to JavaScript, Brent Buffham 2026;
+// the compressors (Rgb14Compressor, Nir14Compressor, Byte14Compressor)
+// added beside the decompressors, writing a layer once a value changes
+// as LAZperf (hobuinc/laz-perf, field_rgb14/nir14/byte14.cpp) does.
 //==========================================================
 
 import { ArithmeticDecoder } from "../ArithmeticDecoder.js";
+import { ArithmeticEncoder } from "../ArithmeticEncoder.js";
 import { ArithmeticModel } from "../models.js";
-import { RgbModels, decodeRgb } from "../v2/rgb12.js";
+import { RgbModels, decodeRgb, encodeRgb, readRgb } from "../v2/rgb12.js";
 
 var LE = true;
+var EMPTY = new Uint8Array(0);
 
 // laz-rs's context switch, shared by the three items: returns the index whose
 // last value predicts this point (`last_idx`), after switching to `ctx`.
@@ -38,6 +45,13 @@ function enterContext(item, ctx) {
 	return lastIdx;
 }
 
+// The first point of a chunk: only its channel's context is in use
+function firstContext(item, ctx) {
+	item.unused = [true, true, true, true];
+	item.unused[ctx] = false;
+	item.lastContext = ctx;
+}
+
 function layer(item, bytes, q, n, fail, e, base) {
 	if (q + n > e) fail(q);
 	if (n === 0) return null;
@@ -46,27 +60,30 @@ function layer(item, bytes, q, n, fail, e, base) {
 	return d;
 }
 
+// The state and models both halves of RGB14 start a chunk with
+function initRgb14(self, version) {
+	self.size = 6;
+	self.version = version;
+	self.models = [new RgbModels(), new RgbModels(), new RgbModels(), new RgbModels()];
+	self.last = [new Uint16Array(3), new Uint16Array(3), new Uint16Array(3), new Uint16Array(3)];
+	self.unused = [true, true, true, true];
+	self.lastContext = 0;
+}
+function seedRgb(from, to) { this.last[to].set(this.last[from]); }
+
 /** RGB14 (version 3 or 4). */
 export function Rgb14Decompressor(version) {
-	this.size = 6;
-	this.version = version;
-	this.models = [new RgbModels(), new RgbModels(), new RgbModels(), new RgbModels()];
-	this.last = [new Uint16Array(3), new Uint16Array(3), new Uint16Array(3), new Uint16Array(3)];
-	this.unused = [true, true, true, true];
-	this.lastContext = 0;
+	initRgb14(this, version);
 	this.dec = null;
 }
 Rgb14Decompressor.prototype.first = function (src, s, view, o, ctx) {
 	for (var i = 0; i < 6; i++) view.setUint8(o + i, src[s + i]);
-	var c = ctx.v;
-	this.last[c][0] = view.getUint16(o, LE); this.last[c][1] = view.getUint16(o + 2, LE); this.last[c][2] = view.getUint16(o + 4, LE);
-	this.unused = [true, true, true, true];
-	this.unused[c] = false;
-	this.lastContext = c;
+	readRgb(this.last[ctx.v], src, s);
+	firstContext(this, ctx.v);
 };
 Rgb14Decompressor.prototype.readLayerSizes = function (dv, q) { this.layerSize = dv.getUint32(q, LE); return q + 4; };
 Rgb14Decompressor.prototype.readLayers = function (bytes, q, e, fail, base) { this.dec = layer(this, bytes, q, this.layerSize, fail, e, base); return q + this.layerSize; };
-Rgb14Decompressor.prototype.seed = function (from, to) { this.last[to].set(this.last[from]); };
+Rgb14Decompressor.prototype.seed = seedRgb;
 Rgb14Decompressor.prototype.next = function (view, o, ctx) {
 	var idx = enterContext(this, ctx.v);
 	var rgb = this.last[idx];
@@ -74,32 +91,57 @@ Rgb14Decompressor.prototype.next = function (view, o, ctx) {
 	view.setUint16(o, rgb[0], LE); view.setUint16(o + 2, rgb[1], LE); view.setUint16(o + 4, rgb[2], LE);
 };
 
+/** RGB14 compressor (version 3 or 4): one layer, written once a colour differs or is not grey. */
+export function Rgb14Compressor(version) {
+	initRgb14(this, version);
+	this.enc = new ArithmeticEncoder();
+	this.used = false;
+	this.cur = new Uint16Array(3);
+}
+Rgb14Compressor.prototype.first = function (src, s, ctx) {
+	readRgb(this.last[ctx.v], src, s);
+	firstContext(this, ctx.v);
+};
+Rgb14Compressor.prototype.seed = seedRgb;
+Rgb14Compressor.prototype.next = function (src, s, ctx) {
+	var idx = enterContext(this, ctx.v);
+	readRgb(this.cur, src, s);
+	if (encodeRgb(this.enc, this.models[this.lastContext], this.last[idx], this.cur)) this.used = true;
+	this.last[idx].set(this.cur);
+};
+/** @returns {Array<Uint8Array>} the one layer (empty when nothing was coded) */
+Rgb14Compressor.prototype.finish = function () { return [this.used ? this.enc.done() : EMPTY]; };
+
+// The state and models both halves of NIR14 start a chunk with
+function initNir14(self, version) {
+	self.size = 2;
+	self.version = version;
+	self.usedModel = []; self.low = []; self.high = [];
+	for (var i = 0; i < 4; i++) { self.usedModel.push(new ArithmeticModel(4)); self.low.push(new ArithmeticModel(256)); self.high.push(new ArithmeticModel(256)); }
+	self.last = new Uint16Array(4);
+	self.unused = [true, true, true, true];
+	self.lastContext = 0;
+}
+function seedNir(from, to) { this.last[to] = this.last[from]; }
+
 /** NIR14 (version 3 or 4): the near-infrared word of RGBNIR14. */
 export function Nir14Decompressor(version) {
-	this.size = 2;
-	this.version = version;
-	this.used = []; this.low = []; this.high = [];
-	for (var i = 0; i < 4; i++) { this.used.push(new ArithmeticModel(4)); this.low.push(new ArithmeticModel(256)); this.high.push(new ArithmeticModel(256)); }
-	this.last = new Uint16Array(4);
-	this.unused = [true, true, true, true];
-	this.lastContext = 0;
+	initNir14(this, version);
 	this.dec = null;
 }
 Nir14Decompressor.prototype.first = function (src, s, view, o, ctx) {
 	view.setUint8(o, src[s]); view.setUint8(o + 1, src[s + 1]);
-	this.last[ctx.v] = view.getUint16(o, LE);
-	this.unused = [true, true, true, true];
-	this.unused[ctx.v] = false;
-	this.lastContext = ctx.v;
+	this.last[ctx.v] = src[s] + src[s + 1] * 256;
+	firstContext(this, ctx.v);
 };
 Nir14Decompressor.prototype.readLayerSizes = Rgb14Decompressor.prototype.readLayerSizes;
 Nir14Decompressor.prototype.readLayers = Rgb14Decompressor.prototype.readLayers;
-Nir14Decompressor.prototype.seed = function (from, to) { this.last[to] = this.last[from]; };
+Nir14Decompressor.prototype.seed = seedNir;
 Nir14Decompressor.prototype.next = function (view, o, ctx) {
 	var idx = enterContext(this, ctx.v);
 	if (this.dec) {
 		var c = this.lastContext, last = this.last[idx];
-		var sym = this.dec.decodeSymbol(this.used[c]);
+		var sym = this.dec.decodeSymbol(this.usedModel[c]);
 		var v = sym & 1 ? (this.dec.decodeSymbol(this.low[c]) + (last & 255)) & 255 : last & 255;
 		v += sym & 2 ? ((this.dec.decodeSymbol(this.high[c]) + (last >>> 8)) & 255) * 256 : last & 0xFF00;
 		this.last[idx] = v;
@@ -107,25 +149,56 @@ Nir14Decompressor.prototype.next = function (view, o, ctx) {
 	view.setUint16(o, this.last[idx], LE);
 };
 
+/** NIR14 compressor (version 3 or 4): one layer, written once the value changes. */
+export function Nir14Compressor(version) {
+	initNir14(this, version);
+	this.enc = new ArithmeticEncoder();
+	this.used = false;
+}
+Nir14Compressor.prototype.first = function (src, s, ctx) {
+	this.last[ctx.v] = src[s] + src[s + 1] * 256;
+	firstContext(this, ctx.v);
+};
+Nir14Compressor.prototype.seed = seedNir;
+Nir14Compressor.prototype.next = function (src, s, ctx) {
+	var idx = enterContext(this, ctx.v), c = this.lastContext;
+	var last = this.last[idx], v = src[s] + src[s + 1] * 256;
+	var sym = ((last ^ v) & 255 ? 1 : 0) + ((last ^ v) & 0xFF00 ? 2 : 0);
+	this.enc.encodeSymbol(this.usedModel[c], sym);
+	if (sym & 1) this.enc.encodeSymbol(this.low[c], ((v & 255) - (last & 255)) & 255);
+	if (sym & 2) this.enc.encodeSymbol(this.high[c], ((v >>> 8) - (last >>> 8)) & 255);
+	if (sym) this.used = true;
+	this.last[idx] = v;
+};
+/** @returns {Array<Uint8Array>} the one layer (empty when the value never changed) */
+Nir14Compressor.prototype.finish = Rgb14Compressor.prototype.finish;
+
+// The state both halves of Byte14 start a chunk with; a context's models are made when it is first used
+function initByte14(self, count, version) {
+	self.size = count;
+	self.version = version;
+	self.models = [null, null, null, null];
+	self.last = [new Uint8Array(count), new Uint8Array(count), new Uint8Array(count), new Uint8Array(count)];
+	self.unused = [true, true, true, true];
+	self.lastContext = 0;
+}
+function byteModels(count) { var m = []; for (var i = 0; i < count; i++) m.push(new ArithmeticModel(256)); return m; }
+function firstBytes(item, src, s, ctx) {
+	item.last[ctx.v].set(src.subarray(s, s + item.size));
+	firstContext(item, ctx.v);
+	item.models[ctx.v] = byteModels(item.size);
+}
+function seedBytes(from, to) { this.models[to] = byteModels(this.size); this.last[to].set(this.last[from]); }
+
 /** Byte14 (version 3 or 4): `count` extra bytes, one layer each. */
 export function Byte14Decompressor(count, version) {
-	this.size = count;
-	this.version = version;
-	this.models = [null, null, null, null];
-	this.last = [new Uint8Array(count), new Uint8Array(count), new Uint8Array(count), new Uint8Array(count)];
-	this.unused = [true, true, true, true];
-	this.lastContext = 0;
+	initByte14(this, count, version);
 	this.sizes = new Array(count);
 	this.dec = new Array(count);
 }
-function byteModels(count) { var m = []; for (var i = 0; i < count; i++) m.push(new ArithmeticModel(256)); return m; }
 Byte14Decompressor.prototype.first = function (src, s, view, o, ctx) {
 	for (var i = 0; i < this.size; i++) view.setUint8(o + i, src[s + i]);
-	this.last[ctx.v].set(src.subarray(s, s + this.size));
-	this.unused = [true, true, true, true];
-	this.unused[ctx.v] = false;
-	this.models[ctx.v] = byteModels(this.size);
-	this.lastContext = ctx.v;
+	firstBytes(this, src, s, ctx);
 };
 Byte14Decompressor.prototype.readLayerSizes = function (dv, q) {
 	for (var i = 0; i < this.size; i++) { this.sizes[i] = dv.getUint32(q, LE); q += 4; }
@@ -135,7 +208,7 @@ Byte14Decompressor.prototype.readLayers = function (bytes, q, e, fail, base) {
 	for (var i = 0; i < this.size; i++) { this.dec[i] = layer(this, bytes, q, this.sizes[i], fail, e, base); q += this.sizes[i]; }
 	return q;
 };
-Byte14Decompressor.prototype.seed = function (from, to) { this.models[to] = byteModels(this.size); this.last[to].set(this.last[from]); };
+Byte14Decompressor.prototype.seed = seedBytes;
 Byte14Decompressor.prototype.next = function (view, o, ctx) {
 	var idx = enterContext(this, ctx.v);
 	var last = this.last[idx], models = this.models[ctx.v];
@@ -144,3 +217,28 @@ Byte14Decompressor.prototype.next = function (view, o, ctx) {
 		view.setUint8(o + i, last[i]);
 	}
 };
+
+/** Byte14 compressor (version 3 or 4): `count` extra bytes, a layer each, written once that byte changes. */
+export function Byte14Compressor(count, version) {
+	initByte14(this, count, version);
+	this.enc = [];
+	this.used = [];
+	for (var i = 0; i < count; i++) { this.enc.push(new ArithmeticEncoder()); this.used.push(false); }
+}
+Byte14Compressor.prototype.first = function (src, s, ctx) { firstBytes(this, src, s, ctx); };
+Byte14Compressor.prototype.seed = seedBytes;
+Byte14Compressor.prototype.next = function (src, s, ctx) {
+	var idx = enterContext(this, ctx.v);
+	var last = this.last[idx], models = this.models[ctx.v];
+	for (var i = 0; i < this.size; i++) {
+		var d = (src[s + i] - last[i]) & 255;   // u8 wrapping_sub
+		this.enc[i].encodeSymbol(models[i], d);
+		if (d) { this.used[i] = true; last[i] = src[s + i]; }
+	}
+};
+/** @returns {Array<Uint8Array>} one layer per byte (empty when that byte never changed) */
+Byte14Compressor.prototype.finish = function () {
+	var out = [];
+	for (var i = 0; i < this.size; i++) out.push(this.used[i] ? this.enc[i].done() : EMPTY);
+	return out;
+};

package/src/laz/v3/point14.js

@@ -5,7 +5,9 @@
 // XY, Z, classification, flags, intensity, scan angle, user data,
 // point source, GPS time — each its own arithmetic stream, so a layer
 // that never changes in a chunk costs nothing (size 0: the value stays
-// the last one). Up to four contexts follow the scanner channel.
+// the last one). Up to four contexts follow the scanner channel. The
+// compressor and decompressor below share each context's models,
+// medians and coders (Context), so they stay in step point for point.
 //
 // Ported from laz-rs src/las/point6.rs, module v3_v4, and the 16x16
 // return tables of src/las/utils.rs (https://github.com/laz-rs/laz-rs),
@@ -13,13 +15,21 @@
 // rapidlasso; (c) 2019-2023 Thomas Montaigu.
 // Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE and
 // NOTICE). Changes: translated from Rust to JavaScript, working on raw
-// record bytes, GPS time as two u32 halves, Brent Buffham 2026.
+// record bytes, GPS time as two u32 halves, Brent Buffham 2026; the
+// compressor (Point14Compressor) added beside the decompressor, sharing
+// its contexts, deciding which layers to write as LAZperf
+// (hobuinc/laz-perf, field_point14.cpp) does, with one change: a GPS
+// time is "changed" when its bits differ (or it is NaN), so -0 after +0
+// survives, where LAZperf's double compare would drop the sign.
 //==========================================================
 
 import { ArithmeticDecoder } from "../ArithmeticDecoder.js";
+import { ArithmeticEncoder } from "../ArithmeticEncoder.js";
 import { ArithmeticModel } from "../models.js";
 import { IntegerDecompressor } from "../IntegerDecompressor.js";
-import { StreamingMedian } from "../v2/point10.js";
+import { IntegerCompressor } from "../IntegerCompressor.js";
+import { StreamingMedian, yContext, zContext } from "../v2/point10.js";
+import { quantizeMulti, diff32 } from "../v2/gpstime11.js";
 
 var LE = true;
 var MULTI = 500, MULTI_MINUS = -10;
@@ -43,8 +53,20 @@ for (var ln = 0; ln < 16; ln++) { LEVEL_8CT.push([]); for (var lr = 0; lr < 16;
 
 function medians(n) { var out = []; for (var i = 0; i < n; i++) out.push(new StreamingMedian()); return out; }
 
-// One context's state, started from the last point of another (laz-rs from_last_point)
-function Context(p) {
+// One record's fields from a view (into q, or a new object)
+function readPoint14(v, o, q) {
+	q = q || {};
+	q.x = v.getInt32(o, LE); q.y = v.getInt32(o + 4, LE); q.z = v.getInt32(o + 8, LE);
+	q.intensity = v.getUint16(o + 12, LE); q.bits = v.getUint8(o + 14); q.flags = v.getUint8(o + 15);
+	q.cls = v.getUint8(o + 16); q.user = v.getUint8(o + 17); q.angle = v.getInt16(o + 18, LE);
+	q.psid = v.getUint16(o + 20, LE); q.gpsLo = v.getUint32(o + 22, LE); q.gpsHi = v.getInt32(o + 26, LE);
+	return q;
+}
+
+// One context's state, started from the last point of another (laz-rs from_last_point);
+// IC is the integer coder (IntegerCompressor or IntegerDecompressor), so both halves get
+// the same widths and contexts
+function Context(p, IC) {
 	this.unused = false;
 	this.p = { x: p.x, y: p.y, z: p.z, intensity: p.intensity, bits: p.bits, flags: p.flags, cls: p.cls, angle: p.angle, user: p.user, psid: p.psid, gpsHi: p.gpsHi, gpsLo: p.gpsLo, gpsChange: false };
 	this.lastIntensity = new Uint16Array(8).fill(p.intensity);
@@ -61,13 +83,13 @@ function Context(p) {
 	this.userM = new Array(64);
 	this.gpsMulti = new ArithmeticModel(MULTI_TOTAL);
 	this.gpsNoDiff = new ArithmeticModel(5);
-	this.icDx = new IntegerDecompressor(32, 2);
-	this.icDy = new IntegerDecompressor(32, 22);
-	this.icZ = new IntegerDecompressor(32, 20);
-	this.icIntensity = new IntegerDecompressor(16, 4);
-	this.icAngle = new IntegerDecompressor(16, 2);
-	this.icPsid = new IntegerDecompressor(16, 1);
-	this.icGps = new IntegerDecompressor(32, 9);
+	this.icDx = new IC(32, 2);
+	this.icDy = new IC(32, 22);
+	this.icZ = new IC(32, 20);
+	this.icIntensity = new IC(16, 4);
+	this.icAngle = new IC(16, 2);
+	this.icPsid = new IC(16, 1);
+	this.icGps = new IC(32, 9);
 	this.gLast = 0; this.gNext = 0;
 	this.gHi = new Int32Array(4); this.gLo = new Float64Array(4);
 	this.gHi[0] = p.gpsHi; this.gLo[0] = p.gpsLo;
@@ -77,20 +99,37 @@ function Context(p) {
 
 function lazy(arr, i, symbols) { return arr[i] || (arr[i] = new ArithmeticModel(symbols)); }
 
+// The changed-values model context from the last point: single / first / last / intermediate,
+// and whether its GPS time changed
+function lastReturnContext(p) {
+	var r = p.bits & 15, n = p.bits >>> 4;
+	return (r === 1 ? 1 : 0) + (r >= n ? 2 : 0) + (p.gpsChange ? 4 : 0);
+}
+
+// The flags symbol: classification flags (bits 0-3), scan direction (4), edge of flight line (5)
+// — the flags byte without the scanner channel, which layer 0 codes
+function flagsSymbol(flags) { return ((flags >>> 7) & 1) * 32 + ((flags >>> 6) & 1) * 16 + (flags & 15); }
+
 Context.prototype.addGps = function (i, d) {
 	var lo = this.gLo[i] + d;
 	if (lo >= 4294967296) { lo -= 4294967296; this.gHi[i] = (this.gHi[i] + 1) | 0; }
 	else if (lo < 0) { lo += 4294967296; this.gHi[i] = (this.gHi[i] - 1) | 0; }
 	this.gLo[i] = lo;
 };
-Context.prototype.fullGps = function (dec) {
+// A full time (hi, lo) starts the next of the four sequences, with no difference yet
+Context.prototype.startGps = function (hi, lo) {
 	this.gNext = (this.gNext + 1) & 3;
-	this.gHi[this.gNext] = this.icGps.decompress(dec, this.gHi[this.gLast], 8);
-	this.gLo[this.gNext] = dec.readInt();
+	this.gHi[this.gNext] = hi;
+	this.gLo[this.gNext] = lo;
 	this.gLast = this.gNext;
 	this.gDiff[this.gLast] = 0;
 	this.gExtreme[this.gLast] = 0;
 };
+Context.prototype.fullGps = function (dec) {
+	var hi = this.icGps.decompress(dec, this.gHi[this.gLast], 8);
+	this.startGps(hi, dec.readInt());
+};
+// After three extreme differences in a row, the latest becomes the new reference
 Context.prototype.extremeGps = function (d) {
 	if (++this.gExtreme[this.gLast] > 3) { this.gDiff[this.gLast] = d; this.gExtreme[this.gLast] = 0; }
 };
@@ -145,6 +184,70 @@ Context.prototype.readGps = function (dec) {
 	}
 };
 
+// The first other sequence (1-3 on from the last) the time (hi, lo) is within i32 of, or 0
+Context.prototype.otherGps = function (hi, lo) {
+	for (var i = 1; i < 4; i++) { var j = (this.gLast + i) & 3; if (diff32(hi, lo, this.gHi[j], this.gLo[j]) !== null) return i; }
+	return 0;
+};
+Context.prototype.writeFullGps = function (enc, hi, lo) {
+	this.icGps.compress(enc, this.gHi[this.gLast], hi, 8);
+	enc.writeInt(lo);
+	this.startGps(hi, lo);
+};
+// The mirror of readGps (LAZperf encodeGpsTime): the time (hi, lo), known to have changed
+Context.prototype.writeGps = function (enc, hi, lo) {
+	for (;;) {
+		var L = this.gLast, d = diff32(hi, lo, this.gHi[L], this.gLo[L]), j, multi;
+		if (this.gDiff[L] === 0) {
+			if (d !== null) {
+				enc.encodeSymbol(this.gpsNoDiff, 0);
+				this.icGps.compress(enc, 0, d, 0);
+				this.gDiff[L] = d;
+				this.gExtreme[L] = 0;
+			} else if ((j = this.otherGps(hi, lo))) {
+				enc.encodeSymbol(this.gpsNoDiff, j + 1);
+				this.gLast = (L + j) & 3;
+				continue;                            // code again against the other sequence
+			} else {
+				enc.encodeSymbol(this.gpsNoDiff, 1);
+				this.writeFullGps(enc, hi, lo);
+			}
+		} else if (d !== null) {
+			multi = quantizeMulti(d, this.gDiff[L]);
+			if (multi > 0 && multi < MULTI) {
+				enc.encodeSymbol(this.gpsMulti, multi);
+				this.icGps.compress(enc, Math.imul(multi, this.gDiff[L]), d, multi === 1 ? 1 : multi < 10 ? 2 : 3);
+				if (multi === 1) this.gExtreme[L] = 0;
+			} else if (multi >= MULTI) {
+				enc.encodeSymbol(this.gpsMulti, MULTI);
+				this.icGps.compress(enc, Math.imul(MULTI, this.gDiff[L]), d, 4);
+				this.extremeGps(d);
+			} else if (multi < 0 && multi > MULTI_MINUS) {
+				enc.encodeSymbol(this.gpsMulti, MULTI - multi);
+				this.icGps.compress(enc, Math.imul(multi, this.gDiff[L]), d, 5);
+			} else if (multi < 0) {
+				enc.encodeSymbol(this.gpsMulti, MULTI - MULTI_MINUS);
+				this.icGps.compress(enc, Math.imul(MULTI_MINUS, this.gDiff[L]), d, 6);
+				this.extremeGps(d);
+			} else {
+				enc.encodeSymbol(this.gpsMulti, 0);
+				this.icGps.compress(enc, 0, d, 7);
+				this.extremeGps(d);
+			}
+		} else if ((j = this.otherGps(hi, lo))) {
+			enc.encodeSymbol(this.gpsMulti, CODE_FULL + j);
+			this.gLast = (L + j) & 3;
+			continue;
+		} else {
+			enc.encodeSymbol(this.gpsMulti, CODE_FULL);
+			this.writeFullGps(enc, hi, lo);
+		}
+		this.gHi[this.gLast] = hi;
+		this.gLo[this.gLast] = lo;
+		return;
+	}
+};
+
 var LAYERS = 9;   // channel/returns/xy, z, classification, flags, intensity, scan angle, user data, point source, gps time
 
 /**
@@ -163,15 +266,10 @@ export function Point14Decompressor(version) {
 
 Point14Decompressor.prototype.first = function (src, s, view, o, ctx) {
 	for (var i = 0; i < 30; i++) view.setUint8(o + i, src[s + i]);
-	var p = {
-		x: view.getInt32(o, LE), y: view.getInt32(o + 4, LE), z: view.getInt32(o + 8, LE),
-		intensity: view.getUint16(o + 12, LE), bits: view.getUint8(o + 14), flags: view.getUint8(o + 15),
-		cls: view.getUint8(o + 16), user: view.getUint8(o + 17), angle: view.getInt16(o + 18, LE),
-		psid: view.getUint16(o + 20, LE), gpsLo: view.getUint32(o + 22, LE), gpsHi: view.getInt32(o + 26, LE)
-	};
+	var p = readPoint14(view, o);
 	this.current = (p.flags >>> 4) & 3;
 	this.contexts = [null, null, null, null];
-	this.contexts[this.current] = new Context(p);
+	this.contexts[this.current] = new Context(p, IntegerDecompressor);
 	ctx.v = this.current;
 };
 
@@ -195,12 +293,10 @@ Point14Decompressor.prototype.readLayers = function (bytes, q, e, fail, base) {
 Point14Decompressor.prototype.next = function (view, o, ctx) {
 	var c = this.contexts[this.current];
 	var p = c.p, d0 = this.dec[0];
-	var r = p.bits & 15, n = p.bits >>> 4;
-	var lpr = (r === 1 ? 1 : 0) + (r >= n ? 2 : 0) + (p.gpsChange ? 4 : 0);
-	var changed = d0.decodeSymbol(c.changed[lpr]);
+	var changed = d0.decodeSymbol(c.changed[lastReturnContext(p)]);
 	if (changed & 64) {
 		var channel = (this.current + d0.decodeSymbol(c.channel) + 1) % 4;
-		if (!this.contexts[channel]) this.contexts[channel] = new Context(p);
+		if (!this.contexts[channel]) this.contexts[channel] = new Context(p, IntegerDecompressor);
 		this.current = channel;
 		if (this.version === 3) ctx.v = channel;
 		c = this.contexts[channel];
@@ -209,7 +305,7 @@ Point14Decompressor.prototype.next = function (view, o, ctx) {
 	}
 	if (this.version !== 3) ctx.v = this.current;
 	var psidChanged = changed & 32, gpsChanged = changed & 16 ? 1 : 0, angleChanged = changed & 8;
-	var lastN = p.bits >>> 4, lastR = p.bits & 15;
+	var lastN = p.bits >>> 4, lastR = p.bits & 15, n, r;
 	n = changed & 4 ? d0.decodeSymbol(lazy(c.nret, lastN, 16)) : lastN;
 	var low = changed & 3;
 	if (low === 0) r = lastR;
@@ -225,19 +321,16 @@ Point14Decompressor.prototype.next = function (view, o, ctx) {
 	var diff = c.icDx.decompress(d0, c.xMedian[idx].get(), single);
 	p.x = (p.x + diff) | 0;
 	c.xMedian[idx].add(diff);
-	var kx = c.icDx.k;
-	diff = c.icDy.decompress(d0, c.yMedian[idx].get(), single + (kx < 20 ? kx & 0xFFFFFFFE : 20));
+	diff = c.icDy.decompress(d0, c.yMedian[idx].get(), yContext(single, c.icDx));
 	p.y = (p.y + diff) | 0;
 	c.yMedian[idx].add(diff);
 	if (this.on[1]) {
-		var kz = Math.floor((c.icDx.k + c.icDy.k) / 2);
-		p.z = c.icZ.decompress(this.dec[1], c.lastZ[l], single + (kz < 18 ? kz & 0xFFFFFFFE : 18));
+		p.z = c.icZ.decompress(this.dec[1], c.lastZ[l], zContext(single, c.icDx, c.icDy));
 		c.lastZ[l] = p.z;
 	}
 	if (this.on[2]) p.cls = this.dec[2].decodeSymbol(lazy(c.clsM, (p.cls & 31) * 2 + (cpr === 3 ? 1 : 0), 256));
 	if (this.on[3]) {
-		var lastFlags = ((p.flags >>> 7) & 1) * 32 + ((p.flags >>> 6) & 1) * 16 + (p.flags & 15);
-		var f = this.dec[3].decodeSymbol(lazy(c.flagsM, lastFlags, 64));
+		var f = this.dec[3].decodeSymbol(lazy(c.flagsM, flagsSymbol(p.flags), 64));
 		p.flags = ((f >>> 5) & 1) * 128 + ((f >>> 4) & 1) * 64 + (p.flags & 0x30) + (f & 15);
 	}
 	if (this.on[4]) {
@@ -264,3 +357,108 @@ Point14Decompressor.prototype.next = function (view, o, ctx) {
 	view.setUint32(o + 22, p.gpsLo, LE);
 	view.setInt32(o + 26, p.gpsHi, LE);
 };
+
+// A DataView over the caller's records, made once per buffer
+function viewOf(item, src) {
+	if (item._src !== src) { item._src = src; item._view = new DataView(src.buffer, src.byteOffset, src.byteLength); }
+	return item._view;
+}
+
+// Whether a point's GPS time changed from the last: its bits differ, or it is NaN (a NaN never
+// equals itself, as LAZperf's double compare has it). Unlike that compare, -0 and +0 differ.
+function gpsChangedFrom(p, q) {
+	if (q.gpsHi !== p.gpsHi || q.gpsLo !== p.gpsLo) return true;
+	return (q.gpsHi & 0x7FF00000) === 0x7FF00000 && ((q.gpsHi & 0xFFFFF) !== 0 || q.gpsLo !== 0);
+}
+
+/**
+ * Point14 compressor: one per chunk, the mirror of Point14Decompressor. Each layer has its own
+ * encoder; channel/returns/XY and Z are always written, the others once a value changes (LAZperf).
+ * @param {number} version - LASzip item version, 3 or 4
+ */
+export function Point14Compressor(version) {
+	this.size = 30;
+	this.version = version;
+	this.contexts = [null, null, null, null];
+	this.current = 0;
+	this.enc = [];
+	this.used = [];
+	for (var i = 0; i < LAYERS; i++) { this.enc.push(new ArithmeticEncoder()); this.used.push(i < 2); }
+	this.q = {};
+	this._src = null;
+	this._view = null;
+}
+
+/** The first point of a chunk is stored raw; it starts its channel's context. */
+Point14Compressor.prototype.first = function (src, s, ctx) {
+	var p = readPoint14(viewOf(this, src), s);
+	this.current = (p.flags >>> 4) & 3;
+	this.contexts[this.current] = new Context(p, IntegerCompressor);
+	ctx.v = this.current;
+};
+
+Point14Compressor.prototype.next = function (src, s, ctx) {
+	var q = readPoint14(viewOf(this, src), s, this.q);
+	var prev = this.contexts[this.current], sc = (q.flags >>> 4) & 3;
+	var c = this.contexts[sc];
+	// the last point of this channel, or (a channel not seen yet) of the last one
+	var p = c ? c.p : prev.p, e0 = this.enc[0];
+	var gpsChanged = gpsChangedFrom(p, q) ? 1 : 0;
+	var psidChanged = q.psid !== p.psid, angleChanged = q.angle !== p.angle;
+	var lastN = p.bits >>> 4, lastR = p.bits & 15, n = q.bits >>> 4, r = q.bits & 15;
+	var low = r === lastR ? 0 : r === (lastR + 1) % 16 ? 1 : r === (lastR + 15) % 16 ? 2 : 3;
+	var changed = (sc !== this.current ? 64 : 0) + (psidChanged ? 32 : 0) + gpsChanged * 16 + (angleChanged ? 8 : 0) + (n !== lastN ? 4 : 0) + low;
+	e0.encodeSymbol(prev.changed[lastReturnContext(prev.p)], changed);
+	if (changed & 64) {
+		e0.encodeSymbol(prev.channel, (sc - this.current + 3) % 4);
+		if (!c) { c = this.contexts[sc] = new Context(prev.p, IntegerCompressor); p = c.p; }
+		this.current = sc;
+		if (this.version === 3) ctx.v = sc;
+	}
+	if (this.version !== 3) ctx.v = this.current;
+	if (changed & 4) e0.encodeSymbol(lazy(c.nret, lastN, 16), n);
+	if (low === 3) {
+		if (gpsChanged) e0.encodeSymbol(lazy(c.rnum, lastR, 16), r);
+		else e0.encodeSymbol(c.rnumGpsSame, (r - lastR + 14) % 16);   // r - lastR - 2, mod 16
+	}
+	var m = MAP_6CTX[n][r], l = LEVEL_8CT[n][r];
+	var cpr = (r === 1 ? 2 : 0) + (r >= n ? 1 : 0);
+	var single = n === 1 ? 1 : 0;
+	var idx = m * 2 + gpsChanged;
+	var diff = (q.x - p.x) | 0;              // i32 wrapping_sub
+	c.icDx.compress(e0, c.xMedian[idx].get(), diff, single);
+	c.xMedian[idx].add(diff);
+	diff = (q.y - p.y) | 0;
+	c.icDy.compress(e0, c.yMedian[idx].get(), diff, yContext(single, c.icDx));
+	c.yMedian[idx].add(diff);
+	c.icZ.compress(this.enc[1], c.lastZ[l], q.z, zContext(single, c.icDx, c.icDy));
+	c.lastZ[l] = q.z;
+	var used = this.used;
+	if (q.cls !== p.cls) used[2] = true;
+	this.enc[2].encodeSymbol(lazy(c.clsM, (p.cls & 31) * 2 + (cpr === 3 ? 1 : 0), 256), q.cls);
+	var lastF = flagsSymbol(p.flags), f = flagsSymbol(q.flags);
+	if (f !== lastF) used[3] = true;
+	this.enc[3].encodeSymbol(lazy(c.flagsM, lastF, 64), f);
+	var ii = cpr * 2 + gpsChanged;
+	if (q.intensity !== p.intensity) used[4] = true;
+	c.icIntensity.compress(this.enc[4], c.lastIntensity[ii], q.intensity, cpr);
+	c.lastIntensity[ii] = q.intensity;
+	if (angleChanged) { used[5] = true; c.icAngle.compress(this.enc[5], p.angle, q.angle, gpsChanged); }
+	if (q.user !== p.user) used[6] = true;
+	this.enc[6].encodeSymbol(lazy(c.userM, Math.floor(p.user / 4), 256), q.user);
+	if (psidChanged) { used[7] = true; c.icPsid.compress(this.enc[7], p.psid, q.psid, 0); }
+	if (gpsChanged) { used[8] = true; c.writeGps(this.enc[8], q.gpsHi, q.gpsLo); }
+	p.x = q.x; p.y = q.y; p.z = q.z; p.intensity = q.intensity; p.bits = q.bits; p.flags = q.flags;
+	p.cls = q.cls; p.angle = q.angle; p.user = q.user; p.psid = q.psid; p.gpsHi = q.gpsHi; p.gpsLo = q.gpsLo;
+	p.gpsChange = gpsChanged === 1;
+};
+
+/**
+ * Finish the chunk's layers.
+ * @returns {Array<Uint8Array>} the nine layers in readLayerSizes order; an unchanged layer is empty
+ */
+Point14Compressor.prototype.finish = function () {
+	var out = [];
+	for (var i = 0; i < LAYERS; i++) out.push(this.used[i] ? this.enc[i].done() : new Uint8Array(0));
+	return out;
+};

package/src/write/encodeRecords.js

@@ -25,8 +25,9 @@ function col(cols, name) { var c = cols[name]; return c ? function (i) { return
  * @param {DataView} out
  * @param {number} at
  * @param {object} totals - updated: bounds (quantised world values) and byReturn counts
+ * @param {number} [first=0] - the index of cols' first point in the caller's points (named in errors)
  */
-export function encodeRecords(cols, pointFormat, recordLength, so, origin, out, at, totals) {
+export function encodeRecords(cols, pointFormat, recordLength, so, origin, out, at, totals, first) {
 	var fmt = POINT_FORMATS[pointFormat];
 	var F = fmt.fields;
 	var ox = origin && isFinite(origin.x) ? origin.x : 0;
@@ -41,7 +42,7 @@ export function encodeRecords(cols, pointFormat, recordLength, so, origin, out,
 		var Y = Math.round((cols.y[i] + oy - so.offset.y) / so.scale.y);
 		var Z = Math.round(((cols.z ? cols.z[i] : 0) + oz - so.offset.z) / so.scale.z);
 		if (X > INT32_MAX || X < INT32_MIN || Y > INT32_MAX || Y < INT32_MIN || Z > INT32_MAX || Z < INT32_MIN) {
-			throw new LasError(ERROR_CODES.INVALID_ARGUMENT, "point " + i + " does not fit the scale and offset (int32 overflow); use a coarser scale");
+			throw new LasError(ERROR_CODES.INVALID_ARGUMENT, "point " + ((first || 0) + i) + " does not fit the scale and offset (int32 overflow); use a coarser scale");
 		}
 		out.setInt32(p, X, LE); out.setInt32(p + 4, Y, LE); out.setInt32(p + 8, Z, LE);
 		var wx = X * so.scale.x + so.offset.x, wy = Y * so.scale.y + so.offset.y, wz = Z * so.scale.z + so.offset.z;