Diffusion Open Access Compliance Check Tool (OACCT) (paginated-inlines) Browse

rOACCT/node_modules/hpack.js/lib/hpack/encoder.js
f646e1f695a7paginated-inlines

encoder.js
View Options

			var hpack = require('../hpack');
			var utils = hpack.utils;
			var huffman = hpack.huffman.encode;
			var assert = utils.assert;

			var WBuf = require('wbuf');

			function Encoder() {
			this.buffer = new WBuf();
			this.word = 0;
			this.bitOffset = 0;
			}
			module.exports = Encoder;

			Encoder.create = function create() {
			return new Encoder();
			};

			Encoder.prototype.render = function render() {
			return this.buffer.render();
			};

			Encoder.prototype.encodeBit = function encodeBit(bit) {
			var octet;

			this.word <<= 1;
			this.word \|= bit;
			this.bitOffset++;

			if (this.bitOffset === 8) {
			this.buffer.writeUInt8(this.word);
			this.word = 0;
			this.bitOffset = 0;
			}
			};

			Encoder.prototype.encodeBits = function encodeBits(bits, len) {
			var left = bits;
			var leftLen = len;

			while (leftLen > 0) {
			var avail = Math.min(leftLen, 8 - this.bitOffset);
			var toWrite = left >>> (leftLen - avail);

			if (avail === 8) {
			this.buffer.writeUInt8(toWrite);
			} else {
			this.word <<= avail;
			this.word \|= toWrite;
			this.bitOffset += avail;
			if (this.bitOffset === 8) {
			this.buffer.writeUInt8(this.word);
			this.word = 0;
			this.bitOffset = 0;
			}
			}

			leftLen -= avail;
			left &= (1 << leftLen) - 1;
			}
			};

			// Just for testing
			Encoder.prototype.skipBits = function skipBits(num) {
			this.bitOffset += num;
			this.buffer.skip(this.bitOffset >> 3);
			this.bitOffset &= 0x7;
			};

			Encoder.prototype.encodeInt = function encodeInt(num) {
			var prefix = 8 - this.bitOffset;

			// We are going to end up octet-aligned
			this.bitOffset = 0;

			var max = (1 << prefix) - 1;

			// Fast case - int fits into the prefix
			if (num < max) {
			this.buffer.writeUInt8((this.word << prefix) \| num);
			return octet;
			}

			var left = num - max;
			this.buffer.writeUInt8((this.word << prefix) \| max);
			do {
			var octet = left & 0x7f;
			left >>= 7;
			if (left !== 0)
			octet \|= 0x80;

			this.buffer.writeUInt8(octet);
			} while (left !== 0);
			};

			Encoder.prototype.encodeStr = function encodeStr(value, isHuffman) {
			this.encodeBit(isHuffman ? 1 : 0);

			if (!isHuffman) {
			this.buffer.reserve(value.length + 1);
			this.encodeInt(value.length);
			for (var i = 0; i < value.length; i++)
			this.buffer.writeUInt8(value[i]);
			return;
			}

			var codes = [];
			var len = 0;
			var pad = 0;

			for (var i = 0; i < value.length; i++) {
			var code = huffman[value[i]];
			codes.push(code);
			len += code[0];
			}
			if (len % 8 !== 0)
			pad = 8 - (len % 8);
			len += pad;

			this.buffer.reserve((len / 8) + 1);
			this.encodeInt(len / 8);
			for (var i = 0; i < codes.length; i++) {
			var code = codes[i];
			this.encodeBits(code[1], code[0]);
			}

			// Append padding
			this.encodeBits(0xff >>> (8 - pad), pad);
			};