Add writing capabilities and rename package to binary-io

Author: devongovett

README.md

@@ -1,18 +1,26 @@
-# stream-reader
+# binary-io
 
-Streaming binary data and bitstream reader. Extracted from [aurora.js](https://github.com/audiocogs/aurora.js).
+Streaming byte and bit stream reader and writer. Extracted from [aurora.js](https://github.com/audiocogs/aurora.js).
 
 ## BufferList
 
 A `BufferList` is represents a linked list of byte buffers. It manages the current total length of the list and is used by the `Stream` class internally.
 
-## Stream
+## StreamReader
 
-The `Stream` class represents a stream of binary data backed by a `BufferList`. Streams handle the complexity of reading various types of values from a binary data stream for you, including issues regarding the native endianness of the platform.
+The `StreamReader` class reads a stream of binary data backed by a `BufferList`. `StreamReader` handles the complexity of reading various types of values from a binary data stream for you, including issues regarding the native endianness of the platform.
 
-## Bitstream
+## BitstreamReader
 
-The `Bitstream` class wraps a `Stream` and adds methods to read data on an individual bit level.
+The `BitstreamReader` class wraps a `StreamReader` and adds methods to read data on an individual bit level.
+
+## StreamWriter
+
+The `StreamWriter` class writes various binary data types to a writable stream.
+
+## BitstreamWriter
+
+The `BitstreamWriter` class wraps a `StreamWriter`, and adds methods to write data on an individual bit level.
 
 ## License
 

index.js

@@ -1,4 +1,6 @@
-export {default as BufferList} from './src/bufferlist';
-export {default as Stream} from './src/stream';
-export {default as Bitstream} from './src/bitstream';
-export {default as UnderflowError} from './src/underflow';
+export {default as BufferList} from './src/BufferList';
+export {default as StreamReader} from './src/StreamReader';
+export {default as StreamWriter} from './src/StreamWriter';
+export {default as BitstreamReader} from './src/BitstreamReader';
+export {default as BitstreamWriter} from './src/BitstreamWriter';
+export {default as UnderflowError} from './src/UnderflowError';

package.json

@@ -1,7 +1,7 @@
 {
-  "name": "stream-reader",
+  "name": "binary-io",
   "version": "1.0.0",
-  "description": "Streaming binary data and bitstream reader",
+  "description": "Streaming byte and bit stream reader and writer",
   "keywords": ["stream", "binary", "byte", "bit", "bitstream"],
   "main": "index.js",
   "scripts": {

src/bitstream.js renamed to src/BitstreamReader.js

@@ -1,17 +1,17 @@
-import Stream from './stream';
+import StreamReader from './StreamReader';
 
-export default class Bitstream {
+export default class BitstreamReader {
   constructor(stream) {
     this.stream = stream;
     this.bitPosition = 0;
   }
 
   static fromBuffer(buffer) {
-    return new Bitstream(Stream.fromBuffer(buffer));
+    return new BitstreamReader(StreamReader.fromBuffer(buffer));
   }
 
   copy() {
-    let result = new Bitstream(this.stream.copy());
+    let result = new BitstreamReader(this.stream.copy());
     result.bitPosition = this.bitPosition;
     return result;
   }

src/BitstreamWriter.js

@@ -0,0 +1,2 @@
+// TODO
+export default class BitstreamWriter {}

src/bufferlist.js renamed to src/BufferList.js

@@ -15,7 +15,7 @@ const float64 = new Float64Array(buf);
 // 0x3412 is little endian, 0x1234 is big endian
 const nativeEndian = new Uint16Array(new Uint8Array([0x12, 0x34]).buffer)[0] === 0x3412;
 
-export default class Stream {
+export default class StreamReader {
   constructor(list) {
     this.list = list;
     this.localOffset = 0;
@@ -25,11 +25,11 @@ export default class Stream {
   static fromBuffer(buffer) {
     let list = new BufferList;
     list.append(buffer);
-    return new Stream(list);
+    return new StreamReader(list);
   }
 
   copy() {
-    let result = new Stream(this.list.copy());
+    let result = new StreamReader(this.list.copy());
     result.localOffset = this.localOffset;
     result.offset = this.offset;
     return result;

src/stream.js renamed to src/StreamReader.js

@@ -0,0 +1,138 @@
+import {Writable} from 'stream';
+
+const BUFFER_SIZE = 65536;
+
+export default class StreamWriter extends Writable {
+  constructor(stream) {
+    super();
+    this.stream = stream || this;
+    this.buffer = new Uint8Array(BUFFER_SIZE);
+    this.view = new DataView(this.buffer.buffer);
+    this.queue = [];
+    this.bufferOffset = 0;
+    this.offset = 0;
+  }
+  
+  flush() {
+    if (this.bufferOffset > 0) {
+      this.stream.write(new Buffer(this.buffer.subarray(0, this.bufferOffset)));
+      this.bufferOffset = 0;
+    }
+  }
+  
+  end() {
+    this.flush();
+    this.stream.end();
+  }
+  
+  ensure(bytes) {
+    if (this.bufferOffset + bytes > this.buffer.length) {
+      this.flush();
+    }
+  }
+  
+  advance(bytes) {
+    // ??? fill with 0?
+  }
+  
+  seek(offset) {
+    if (typeof this.stream.seek === 'function') {
+      this.flush();
+      this.stream.seek(offset);
+    } else {
+      throw new Error('Stream is not seekable');
+    }
+  }
+  
+  writeUInt8(val) {
+    this.ensure(1);
+    this.buffer[this.bufferOffset++] = val;
+    this.offset++;
+  }
+  
+  writeInt8(val) {
+    this.ensure(1);
+    this.view.setInt8(this.bufferOffset++, val);
+    this.offset++;
+  }
+  
+  writeUInt16(val, littleEndian) {
+    this.ensure(2);
+    this.view.setUint16(this.bufferOffset, val, littleEndian);
+    this.bufferOffset += 2;
+    this.offset += 2;
+  }
+  
+  writeInt16(val, littleEndian) {
+    this.ensure(2);
+    this.view.setInt16(this.bufferOffset, val, littleEndian);
+    this.bufferOffset += 2;
+    this.offset += 2;
+  }
+  
+  writeUInt24(val, littleEndian) {
+    if (littleEndian) {
+      this.writeUInt8(val & 0xff);
+      this.writeUInt8(val >>> 8 & 0xff);
+      this.writeUInt8(val >>> 16 & 0xff);
+    } else {
+      this.writeUInt8(val >>> 16 & 0xff);
+      this.writeUInt8(val >>> 8 & 0xff);
+      this.writeUInt8(val & 0xff);
+    }
+  }
+  
+  writeInt24(val, littleEndian) {
+    this.writeUInt24(val >= 0 ? val : val + 0xffffff + 1, littleEndian);
+  }
+  
+  writeUInt32(val, littleEndian) {
+    this.ensure(4);
+    this.view.setUint32(this.bufferOffset, val, littleEndian);
+    this.bufferOffset += 4;
+    this.offset += 4;
+  }
+  
+  writeInt32(val, littleEndian) {
+    this.ensure(4);
+    this.view.setInt32(this.bufferOffset, val, littleEndian);
+    this.bufferOffset += 4;
+    this.offset += 4;
+  }
+  
+  writeFloat32(val, littleEndian) {
+    this.ensure(4);
+    this.view.setFloat32(this.bufferOffset, val, littleEndian);
+    this.bufferOffset += 4;
+    this.offset += 4;
+  }
+  
+  writeFloat64(val, littleEndian) {
+    this.ensure(8);
+    this.view.setFloat64(this.bufferOffset, val, littleEndian);
+    this.bufferOffset += 8;
+    this.offset += 8;
+  }
+  
+  writeFloat80(val, littleEndian) {
+    // TODO
+  }
+  
+  writeBuffer(buffer) {
+    this.flush();
+    this.stream.push(buffer);
+    this.offset += buffer.length;
+  }
+  
+  writeString(string, encoding, nullTerminated) {
+    let buf = new Buffer(string, encoding);
+    if (buf.length < this.buffer.length) {
+      this.ensure(buf.length);
+      this.buffer.set(buf, this.bufferOffset);
+      this.bufferOffset += buf.length;
+      this.offset += buf.length;
+    } else {
+      this.writeBuffer(buf);
+    }
+  }
+}