Merge pull request #18 from Malvineous/big-endian

Add read and write support for big-endian byte order

Author: icewind1991

README.md

@@ -12,6 +12,10 @@ BitBuffer provides two objects, `BitView` and `BitStream`. `BitView` is a wrappe
 bb.buffer  // Underlying ArrayBuffer.
 ```
 
+```javascript
+bb.bigEndian = true; // Switch to big endian (default is little)
+```
+
 ### Methods
 
 #### BitView(buffer, optional byteOffset, optional byteLength)
@@ -77,6 +81,10 @@ bb.index; // Get the current index in bits
 bb.index = 0// Set the current index in bits
 ```
 
+```javascript
+bb.bigEndian = true; // Switch to big endian (default is little)
+```
+
 ### Methods
 
 #### BitStream(view)

bit-buffer.js

@@ -20,6 +20,8 @@ var BitView = function (source, byteOffset, byteLength) {
 	byteLength = byteLength || source.byteLength /* ArrayBuffer */ || source.length /* Buffer */;
 
 	this._view = new Uint8Array(source, byteOffset, byteLength);
+
+	this.bigEndian = false;
 };
 
 // Used to massage fp values so we can operate on them
@@ -62,11 +64,23 @@ BitView.prototype.getBits = function (offset, bits, signed) {
 		// the max number of bits we can read from the current byte
 		var read = Math.min(remaining, 8 - bitOffset);
 
-		// create a mask with the correct bit width
-		var mask = (1 << read) - 1;
-		// shift the bits we want to the start of the byte and mask of the rest
-		var readBits = (currentByte >> bitOffset) & mask;
-		value |= readBits << i;
+		var mask, readBits;
+		if (this.bigEndian) {
+			// create a mask with the correct bit width
+			mask = ~(0xFF << read);
+			// shift the bits we want to the start of the byte and mask of the rest
+			readBits = (currentByte >> (8 - read - bitOffset)) & mask;
+
+			value <<= read;
+			value |= readBits;
+		} else {
+			// create a mask with the correct bit width
+			mask = ~(0xFF << read);
+			// shift the bits we want to the start of the byte and mask off the rest
+			readBits = (currentByte >> bitOffset) & mask;
+
+			value |= readBits << i;
+		}
 
 		offset += read;
 		i += read;
@@ -94,19 +108,41 @@ BitView.prototype.setBits = function (offset, value, bits) {
 	}
 
 	for (var i = 0; i < bits;) {
-		var wrote;
+		var remaining = bits - i;
+		var bitOffset = offset & 7;
+		var byteOffset = offset >> 3;
+		var wrote = Math.min(remaining, 8 - bitOffset);
+
+		var mask, writeBits, destMask;
+		if (this.bigEndian) {
+			// create a mask with the correct bit width
+			mask = ~(~0 << wrote);
+			// shift the bits we want to the start of the byte and mask of the rest
+			writeBits = (value >> (bits - i - wrote)) & mask;
+
+			var destShift = 8 - bitOffset - wrote;
+			// destination mask to zero all the bits we're changing first
+			destMask = ~(mask << destShift);
+
+			this._view[byteOffset] =
+				(this._view[byteOffset] & destMask)
+				| (writeBits << destShift);
 
-		// Write an entire byte if we can.
-		if ((bits - i) >= 8 && ((offset & 7) === 0)) {
-			this._view[offset >> 3] = value & 0xFF;
-			wrote = 8;
 		} else {
-			this._setBit(offset, value & 0x1);
-			wrote = 1;
+			// create a mask with the correct bit width
+			mask = ~(0xFF << wrote);
+			// shift the bits we want to the start of the byte and mask of the rest
+			writeBits = value & mask;
+			value >>= wrote;
+
+			// destination mask to zero all the bits we're changing first
+			destMask = ~(mask << bitOffset);
+
+			this._view[byteOffset] =
+				(this._view[byteOffset] & destMask)
+				| (writeBits << bitOffset);
 		}
 
-		value = (value >> wrote);
-
 		offset += wrote;
 		i += wrote;
 	}
@@ -361,6 +397,13 @@ Object.defineProperty(BitStream.prototype, 'view', {
 	configurable: false
 });
 
+Object.defineProperty(BitStream.prototype, 'bigEndian', {
+	get: function () { return this._view.bigEndian; },
+	set: function (val) { this._view.bigEndian = val; },
+	enumerable: true,
+	configurable: false
+});
+
 BitStream.prototype.readBits = function (bits, signed) {
 	var val = this._view.getBits(this._index, bits, signed);
 	this._index += bits;

test.js

@@ -371,3 +371,234 @@ suite('BitBuffer', function () {
 		assert.equal(0xFFFF, buffer.readUInt16LE(0));
 	});
 });
+
+suite('Reading big/little endian', function () {
+	var array, u8, bv, bsw, bsr;
+
+	setup(function () {
+		array = new ArrayBuffer(64);
+		u8 = new Uint8Array(array);
+		u8[0] = 0x01;
+		u8[1] = 0x02;
+		// Test initializing straight from the array.
+		bsr = new BitStream(array);
+	});
+
+	test('4b, little-endian', function () {
+		assert.equal(bsr.index, 0, 'BitStream didn\'t init at offset 0');
+
+		var result = [];
+		result.push(bsr.readBits(4));
+		result.push(bsr.readBits(4));
+		result.push(bsr.readBits(4));
+		result.push(bsr.readBits(4));
+
+		// 0000 0001  0000 0010  [01 02]
+		// [#2] [#1]  [#4] [#3]
+		assert.deepEqual(result, [1, 0, 2, 0]);
+	});
+
+	test('8b, little-endian', function () {
+		assert.equal(bsr.index, 0, 'BitStream didn\'t init at offset 0');
+
+		var result = [];
+		result.push(bsr.readBits(8));
+		result.push(bsr.readBits(8));
+
+		// 0000 0001  0000 0010  [01 02]
+		// [     #1]  [     #2]
+		assert.deepEqual(result, [1, 2]);
+	});
+
+	test('10b, little-endian', function () {
+		assert.equal(bsr.index, 0, 'BitStream didn\'t init at offset 0');
+
+		var result = [];
+		result.push(bsr.readBits(10));
+
+		// 0000 0001  0000 0010  [01 02]
+		// ...   #1]  [   #2][#1...
+		assert.deepEqual(result, [513]);
+	});
+
+	test('16b, little-endian', function () {
+		assert.equal(bsr.index, 0, 'BitStream didn\'t init at offset 0');
+
+		var result = [];
+		result.push(bsr.readBits(16));
+
+		// 0000 0001  0000 0010  [01 02]
+		// [                #1]
+		assert.deepEqual(result, [0x201]);
+	});
+
+	test('24b, little-endian', function () {
+		u8[2] = 0x03;
+		assert.equal(bsr.index, 0, 'BitStream didn\'t init at offset 0');
+
+		var result = [];
+		result.push(bsr.readBits(24));
+
+		// 0000 0001  0000 0010  0000 0011  [01 02 03]
+		// [                           #1]
+		assert.deepEqual(result, [0x30201]);
+	});
+
+	test('4b, big-endian', function () {
+		bsr.bigEndian = true;
+		assert.equal(bsr.index, 0, 'BitStream didn\'t init at offset 0');
+
+		var result = [];
+		result.push(bsr.readBits(4));
+		result.push(bsr.readBits(4));
+		result.push(bsr.readBits(4));
+		result.push(bsr.readBits(4));
+
+		// 0000 0001  0000 0010  [01 02]
+		// [#1] [#2]  [#3] [#4]
+		assert.deepEqual(result, [0, 1, 0, 2]);
+	});
+
+	test('8b, big-endian', function () {
+		bsr.bigEndian = true;
+		assert.equal(bsr.index, 0, 'BitStream didn\'t init at offset 0');
+
+		var result = [];
+		result.push(bsr.readBits(8));
+		result.push(bsr.readBits(8));
+
+		// 0000 0001  0000 0010  [01 02]
+		// [     #1]  [     #2]
+		assert.deepEqual(result, [1, 2]);
+	});
+
+	test('10b, big-endian', function () {
+		bsr.bigEndian = true;
+		assert.equal(bsr.index, 0, 'BitStream didn\'t init at offset 0');
+
+		var result = [];
+		result.push(bsr.readBits(10));
+		result.push(bsr.readBits(6));
+
+		// 0000 0001  0000 0010  [01 02]
+		// [         #1][   #2]
+		assert.deepEqual(result, [4, 2]);
+	});
+
+	test('16b, big-endian', function () {
+		bsr.bigEndian = true;
+		assert.equal(bsr.index, 0, 'BitStream didn\'t init at offset 0');
+
+		var result = [];
+		result.push(bsr.readBits(16));
+
+		// 0000 0001  0000 0010  [01 02]
+		// [                #1]
+		assert.deepEqual(result, [0x102]);
+	});
+
+	test('24b, big-endian', function () {
+		u8[2] = 0x03;
+		bsr.bigEndian = true;
+		assert.equal(bsr.index, 0, 'BitStream didn\'t init at offset 0');
+
+		var result = [];
+		result.push(bsr.readBits(24));
+
+		// 0000 0001  0000 0010  0000 0011  [01 02 03]
+		// [                           #1]
+		assert.deepEqual(result, [0x10203]);
+	});
+});
+
+suite('Writing big/little endian', function () {
+	var array, u8, bv, bsw, bsr;
+
+	setup(function () {
+		array = new ArrayBuffer(2);
+		u8 = new Uint8Array(array);
+		bv = new BitView(array);
+		bsw = new BitStream(bv);
+	});
+
+	test('4b, little-endian', function () {
+		// 0000 0001  0000 0010  [01 02]
+		// [#2] [#1]  [#4] [#3]
+		bsw.writeBits(1, 4);
+		bsw.writeBits(0, 4);
+		bsw.writeBits(2, 4);
+		bsw.writeBits(0, 4);
+
+		assert.deepEqual(u8, [0x01, 0x02]);
+	});
+
+	test('8b, little-endian', function () {
+		// 0000 0001  0000 0010  [01 02]
+		// [     #1]  [     #2]
+		bsw.writeBits(1, 8);
+		bsw.writeBits(2, 8);
+
+		assert.deepEqual(u8, [0x01, 0x02]);
+	});
+
+	test('10b, little-endian', function () {
+		// 0000 0001  0000 0010  [01 02]
+		// ...   #1]  [   #2][#1...
+		bsw.writeBits(513, 10);
+
+		assert.deepEqual(u8, [0x01, 0x02]);
+	});
+
+	test('16b, little-endian', function () {
+		// 0000 0001  0000 0010  [01 02]
+		// [                #1]
+		bsw.writeBits(0x201, 16);
+
+		assert.deepEqual(u8, [0x01, 0x02]);
+	});
+
+	test('4b, big-endian', function () {
+		bsw.bigEndian = true;
+
+		// 0000 0001  0000 0010  [01 02]
+		// [#1] [#2]  [#3] [#4]
+		bsw.writeBits(0, 4);
+		bsw.writeBits(1, 4);
+		bsw.writeBits(0, 4);
+		bsw.writeBits(2, 4);
+
+		assert.deepEqual(u8, [0x01, 0x02]);
+	});
+
+	test('8b, big-endian', function () {
+		bsw.bigEndian = true;
+
+		// 0000 0001  0000 0010  [01 02]
+		// [     #1]  [     #2]
+		bsw.writeBits(1, 8);
+		bsw.writeBits(2, 8);
+
+		assert.deepEqual(u8, [0x01, 0x02]);
+	});
+
+	test('10b, big-endian', function () {
+		bsw.bigEndian = true;
+
+		// 0000 0001  0000 0010  [01 02]
+		// [         #1][   #2]
+		bsw.writeBits(4, 10);
+		bsw.writeBits(2, 6);
+
+		assert.deepEqual(u8, [0x01, 0x02]);
+	});
+
+	test('16b, big-endian', function () {
+		bsw.bigEndian = true;
+
+		// 0000 0001  0000 0010  [01 02]
+		// [                #1]
+		bsw.writeBits(0x102, 16);
+
+		assert.deepEqual(u8, [0x01, 0x02]);
+	});
+});