You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
425 lines
9.0 KiB
425 lines
9.0 KiB
var assert = require('minimalistic-assert');
|
|
var Buffer = require('buffer').Buffer;
|
|
|
|
function WBuf() {
|
|
this.buffers = [];
|
|
this.toReserve = 0;
|
|
this.size = 0;
|
|
this.maxSize = 0;
|
|
this.avail = 0;
|
|
|
|
this.last = null;
|
|
this.offset = 0;
|
|
|
|
// Used in slicing
|
|
this.sliceQueue = null;
|
|
|
|
this.forceReserve = false;
|
|
|
|
// Mostly a constant
|
|
this.reserveRate = 64;
|
|
}
|
|
module.exports = WBuf;
|
|
|
|
WBuf.prototype.reserve = function reserve(n) {
|
|
this.toReserve += n;
|
|
|
|
// Force reservation of extra bytes
|
|
if (this.forceReserve)
|
|
this.toReserve = Math.max(this.toReserve, this.reserveRate);
|
|
};
|
|
|
|
WBuf.prototype._ensure = function _ensure(n) {
|
|
if (this.avail >= n)
|
|
return;
|
|
|
|
if (this.toReserve === 0)
|
|
this.toReserve = this.reserveRate;
|
|
|
|
this.toReserve = Math.max(n - this.avail, this.toReserve);
|
|
|
|
if (this.avail === 0)
|
|
this._next();
|
|
};
|
|
|
|
WBuf.prototype._next = function _next() {
|
|
var buf;
|
|
if (this.sliceQueue === null) {
|
|
// Most common case
|
|
buf = new Buffer(this.toReserve);
|
|
} else {
|
|
// Only for `.slice()` results
|
|
buf = this.sliceQueue.shift();
|
|
if (this.sliceQueue.length === 0)
|
|
this.sliceQueue = null;
|
|
}
|
|
|
|
this.toReserve = 0;
|
|
|
|
this.buffers.push(buf);
|
|
this.avail = buf.length;
|
|
this.offset = 0;
|
|
this.last = buf;
|
|
};
|
|
|
|
WBuf.prototype._rangeCheck = function _rangeCheck() {
|
|
if (this.maxSize !== 0 && this.size > this.maxSize)
|
|
throw new RangeError('WBuf overflow');
|
|
};
|
|
|
|
WBuf.prototype._move = function _move(n) {
|
|
this.size += n;
|
|
if (this.avail === 0)
|
|
this.last = null;
|
|
|
|
this._rangeCheck();
|
|
};
|
|
|
|
WBuf.prototype.slice = function slice(start, end) {
|
|
assert(0 <= start && start <= this.size);
|
|
assert(0 <= end && end <= this.size);
|
|
|
|
if (this.last === null)
|
|
this._next();
|
|
|
|
var res = new WBuf();
|
|
|
|
// Only last chunk is requested
|
|
if (start >= this.size - this.offset) {
|
|
res.buffers.push(this.last);
|
|
res.last = this.last;
|
|
res.offset = start - this.size + this.offset;
|
|
res.maxSize = end - start;
|
|
res.avail = res.maxSize;
|
|
|
|
return res;
|
|
}
|
|
|
|
var startIndex = -1;
|
|
var startOffset = 0;
|
|
var endIndex = -1;
|
|
|
|
// Find buffer indices
|
|
var offset = 0;
|
|
for (var i = 0; i < this.buffers.length; i++) {
|
|
var buf = this.buffers[i];
|
|
var next = offset + buf.length;
|
|
|
|
// Found the start
|
|
if (start >= offset && start <= next) {
|
|
startIndex = i;
|
|
startOffset = start - offset;
|
|
if (endIndex !== -1)
|
|
break;
|
|
}
|
|
if (end >= offset && end <= next) {
|
|
endIndex = i;
|
|
if (startIndex !== -1)
|
|
break;
|
|
}
|
|
|
|
offset = next;
|
|
}
|
|
|
|
res.last = this.buffers[startIndex];
|
|
res.offset = startOffset;
|
|
res.maxSize = end - start;
|
|
|
|
// Multi-buffer slice
|
|
if (startIndex < endIndex) {
|
|
res.sliceQueue = this.buffers.slice(startIndex + 1, endIndex + 1);
|
|
|
|
res.last = res.last.slice(res.offset);
|
|
res.offset = 0;
|
|
}
|
|
|
|
res.avail = res.last.length - res.offset;
|
|
res.buffers.push(res.last);
|
|
|
|
return res;
|
|
};
|
|
|
|
WBuf.prototype.skip = function skip(n) {
|
|
if (n === 0)
|
|
return this.slice(this.size, this.size);
|
|
|
|
this._ensure(n);
|
|
|
|
var left = n;
|
|
while (left > 0) {
|
|
var toSkip = Math.min(left, this.avail);
|
|
left -= toSkip;
|
|
this.size += toSkip;
|
|
if (toSkip === this.avail) {
|
|
if (left !== 0) {
|
|
this._next();
|
|
} else {
|
|
this.avail -= toSkip;
|
|
this.offset += toSkip;
|
|
}
|
|
} else {
|
|
this.offset += toSkip;
|
|
this.avail -= toSkip;
|
|
}
|
|
}
|
|
|
|
this._rangeCheck();
|
|
|
|
return this.slice(this.size - n, this.size);
|
|
};
|
|
|
|
WBuf.prototype.write = function write(str) {
|
|
var len = 0;
|
|
for (var i = 0; i < str.length; i++) {
|
|
var c = str.charCodeAt(i);
|
|
if (c > 255)
|
|
len += 2;
|
|
else
|
|
len += 1;
|
|
}
|
|
this.reserve(len);
|
|
for (var i = 0; i < str.length; i++) {
|
|
var c = str.charCodeAt(i);
|
|
var hi = c >>> 8;
|
|
var lo = c & 0xff;
|
|
|
|
if (hi)
|
|
this.writeUInt8(hi);
|
|
this.writeUInt8(lo);
|
|
}
|
|
};
|
|
|
|
WBuf.prototype.copyFrom = function copyFrom(buf, start, end) {
|
|
var off = start === undefined ? 0 : start;
|
|
var len = end === undefined ? buf.length : end;
|
|
if (off === len)
|
|
return;
|
|
|
|
this._ensure(len - off);
|
|
while (off < len) {
|
|
var toCopy = Math.min(len - off, this.avail);
|
|
buf.copy(this.last, this.offset, off, off + toCopy);
|
|
off += toCopy;
|
|
this.size += toCopy;
|
|
if (toCopy === this.avail) {
|
|
if (off !== len) {
|
|
this._next();
|
|
} else {
|
|
this.avail = 0;
|
|
this.offset += toCopy;
|
|
}
|
|
} else {
|
|
this.offset += toCopy;
|
|
this.avail -= toCopy;
|
|
}
|
|
}
|
|
|
|
this._rangeCheck();
|
|
};
|
|
|
|
WBuf.prototype.writeUInt8 = function writeUInt8(v) {
|
|
this._ensure(1);
|
|
|
|
this.last[this.offset++] = v;
|
|
this.avail--;
|
|
this._move(1);
|
|
};
|
|
|
|
WBuf.prototype.writeUInt16BE = function writeUInt16BE(v) {
|
|
this._ensure(2);
|
|
|
|
// Fast case - everything fits into the last buffer
|
|
if (this.avail >= 2) {
|
|
this.last.writeUInt16BE(v, this.offset);
|
|
this.offset += 2;
|
|
this.avail -= 2;
|
|
|
|
// One byte here, one byte there
|
|
} else {
|
|
this.last[this.offset] = (v >>> 8);
|
|
this._next();
|
|
this.last[this.offset++] = v & 0xff;
|
|
this.avail--;
|
|
}
|
|
|
|
this._move(2);
|
|
};
|
|
|
|
WBuf.prototype.writeUInt24BE = function writeUInt24BE(v) {
|
|
this._ensure(3);
|
|
|
|
// Fast case - everything fits into the last buffer
|
|
if (this.avail >= 3) {
|
|
this.last.writeUInt16BE(v >>> 8, this.offset);
|
|
this.last[this.offset + 2] = v & 0xff;
|
|
this.offset += 3;
|
|
this.avail -= 3;
|
|
this._move(3);
|
|
|
|
// Two bytes here
|
|
} else if (this.avail >= 2) {
|
|
this.last.writeUInt16BE(v >>> 8, this.offset);
|
|
this._next();
|
|
this.last[this.offset++] = v & 0xff;
|
|
this.avail--;
|
|
this._move(3);
|
|
|
|
// Just one byte here
|
|
} else {
|
|
this.last[this.offset] = v >>> 16;
|
|
this._move(1);
|
|
this._next();
|
|
this.writeUInt16BE(v & 0xffff);
|
|
}
|
|
};
|
|
|
|
WBuf.prototype.writeUInt32BE = function writeUInt32BE(v) {
|
|
this._ensure(4);
|
|
|
|
// Fast case - everything fits into the last buffer
|
|
if (this.avail >= 4) {
|
|
this.last.writeUInt32BE(v, this.offset);
|
|
this.offset += 4;
|
|
this.avail -= 4;
|
|
this._move(4);
|
|
|
|
// Three bytes here
|
|
} else if (this.avail >= 3) {
|
|
this.writeUInt24BE(v >>> 8);
|
|
this._next();
|
|
this.last[this.offset++] = v & 0xff;
|
|
this.avail--;
|
|
this._move(1);
|
|
|
|
// Slow case, who cares
|
|
} else {
|
|
this.writeUInt16BE(v >>> 16);
|
|
this.writeUInt16BE(v & 0xffff);
|
|
}
|
|
};
|
|
|
|
WBuf.prototype.writeUInt16LE = function writeUInt16LE(num) {
|
|
var r = ((num & 0xff) << 8) | (num >>> 8);
|
|
this.writeUInt16BE(r);
|
|
};
|
|
|
|
WBuf.prototype.writeUInt24LE = function writeUInt24LE(num) {
|
|
var r = ((num & 0xff) << 16) | (((num >>> 8) & 0xff) << 8) | (num >>> 16);
|
|
this.writeUInt24BE(r);
|
|
};
|
|
|
|
WBuf.prototype.writeUInt32LE = function writeUInt32LE(num) {
|
|
this._ensure(4);
|
|
|
|
// Fast case - everything fits into the last buffer
|
|
if (this.avail >= 4) {
|
|
this.last.writeUInt32LE(num, this.offset);
|
|
this.offset += 4;
|
|
this.avail -= 4;
|
|
this._move(4);
|
|
|
|
// Three bytes here
|
|
} else if (this.avail >= 3) {
|
|
this.writeUInt24LE(num & 0xffffff);
|
|
this._next();
|
|
this.last[this.offset++] = num >>> 24;
|
|
this.avail--;
|
|
this._move(1);
|
|
|
|
// Slow case, who cares
|
|
} else {
|
|
this.writeUInt16LE(num & 0xffff);
|
|
this.writeUInt16LE(num >>> 16);
|
|
}
|
|
};
|
|
|
|
WBuf.prototype.render = function render() {
|
|
var left = this.size;
|
|
var out = [];
|
|
|
|
for (var i = 0; i < this.buffers.length && left >= 0; i++) {
|
|
var buf = this.buffers[i];
|
|
left -= buf.length;
|
|
if (left >= 0) {
|
|
out.push(buf);
|
|
} else {
|
|
out.push(buf.slice(0, buf.length + left));
|
|
}
|
|
}
|
|
|
|
return out;
|
|
};
|
|
|
|
// Signed APIs
|
|
WBuf.prototype.writeInt8 = function writeInt8(num) {
|
|
if (num < 0)
|
|
return this.writeUInt8(0x100 + num);
|
|
else
|
|
return this.writeUInt8(num);
|
|
};
|
|
|
|
function toUnsigned16(num) {
|
|
if (num < 0)
|
|
return 0x10000 + num;
|
|
else
|
|
return num;
|
|
}
|
|
|
|
WBuf.prototype.writeInt16LE = function writeInt16LE(num) {
|
|
this.writeUInt16LE(toUnsigned16(num));
|
|
};
|
|
|
|
WBuf.prototype.writeInt16BE = function writeInt16BE(num) {
|
|
this.writeUInt16BE(toUnsigned16(num));
|
|
};
|
|
|
|
function toUnsigned24(num) {
|
|
if (num < 0)
|
|
return 0x1000000 + num;
|
|
else
|
|
return num;
|
|
}
|
|
|
|
WBuf.prototype.writeInt24LE = function writeInt24LE(num) {
|
|
this.writeUInt24LE(toUnsigned24(num));
|
|
};
|
|
|
|
WBuf.prototype.writeInt24BE = function writeInt24BE(num) {
|
|
this.writeUInt24BE(toUnsigned24(num));
|
|
};
|
|
|
|
function toUnsigned32(num) {
|
|
if (num < 0)
|
|
return (0xffffffff + num) + 1;
|
|
else
|
|
return num;
|
|
}
|
|
|
|
WBuf.prototype.writeInt32LE = function writeInt32LE(num) {
|
|
this.writeUInt32LE(toUnsigned32(num));
|
|
};
|
|
|
|
WBuf.prototype.writeInt32BE = function writeInt32BE(num) {
|
|
this.writeUInt32BE(toUnsigned32(num));
|
|
};
|
|
|
|
WBuf.prototype.writeComb = function writeComb(size, endian, value) {
|
|
if (size === 1)
|
|
return this.writeUInt8(value);
|
|
|
|
if (endian === 'le') {
|
|
if (size === 2)
|
|
this.writeUInt16LE(value);
|
|
else if (size === 3)
|
|
this.writeUInt24LE(value);
|
|
else if (size === 4)
|
|
this.writeUInt32LE(value);
|
|
} else {
|
|
if (size === 2)
|
|
this.writeUInt16BE(value);
|
|
else if (size === 3)
|
|
this.writeUInt24BE(value);
|
|
else if (size === 4)
|
|
this.writeUInt32BE(value);
|
|
}
|
|
};
|