| 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); |
| } |
| }; |
