ebml.js 4.0.1

package/src/decoder.js

@@ -0,0 +1,301 @@
+const { Transform } = require('stream');
+const tools = require('./tools');
+const schema = require('./schema');
+const { debugLog } = require('./debug-log');
+
+const debug = debugLog('ebml:decoder');
+
+const STATE_TAG = 1;
+const STATE_SIZE = 2;
+const STATE_CONTENT = 3;
+
+class EbmlDecoder extends Transform {
+  /**
+   * @property
+   * @private
+   * @type {Buffer}
+   */
+  mBuffer = null;
+
+  /**
+   * @private
+   * @property
+   * @readonly
+   */
+  mTagStack = [];
+
+  /**
+   * @property
+   * @private
+   * @type {Number}
+   */
+  mState = STATE_TAG;
+
+  /**
+   * @property
+   * @private
+   * @type {Number}
+   */
+  mCursor = 0;
+
+  /**
+   * @property
+   * @private
+   * @type {Number}
+   */
+  mTotal = 0;
+
+  /**
+   * @constructor
+   * @param {Object} options The options to be passed along to the super class
+   */
+  constructor(options = {}) {
+    super({ ...options, readableObjectMode: true });
+  }
+
+  get buffer() {
+    return this.mBuffer;
+  }
+
+  get cursor() {
+    return this.mCursor;
+  }
+
+  get state() {
+    return this.mState;
+  }
+
+  get tagStack() {
+    return this.mTagStack;
+  }
+
+  get total() {
+    return this.mTotal;
+  }
+
+  set buffer(buffer) {
+    this.mBuffer = buffer;
+  }
+
+  /**
+   * @param {number} cursor
+   */
+  set cursor(cursor) {
+    this.mCursor = cursor;
+  }
+
+  set state(state) {
+    this.mState = state;
+  }
+
+  set total(total) {
+    this.mTotal = total;
+  }
+
+  _transform(chunk, enc, done) {
+    if (!this.buffer) {
+      this.buffer = Buffer.from(chunk);
+    } else {
+      this.buffer = tools.concatenate(this.buffer, Buffer.from(chunk));
+    }
+
+    while (this.cursor < this.buffer.length) {
+      if (this.state === STATE_TAG && !this.readTag()) {
+        break;
+      }
+      if (this.state === STATE_SIZE && !this.readSize()) {
+        break;
+      }
+      if (this.state === STATE_CONTENT && !this.readContent()) {
+        break;
+      }
+    }
+
+    done();
+  }
+
+  static getSchemaInfo(tag) {
+    if (Number.isInteger(tag) && schema.has(tag)) {
+      return schema.get(tag);
+    }
+    const tagStr = `0x${tag.toString(16).toUpperCase()}`
+    const unknown = {
+      type: null,
+      name: `unknown-${tagStr}`,
+      description: `${tagStr}`,
+      level: -1,
+      minver: -1,
+      multiple: false,
+      webm: false,
+    };
+    schema.set(tag, unknown)
+    console.warn('[SCHEMA]', 'unknown tag:', tagStr)
+    return unknown
+  }
+
+  readTag() {
+    /* istanbul ignore if */
+    if (debug.enabled) {
+      debug('parsing tag');
+    }
+
+    if (this.cursor >= this.buffer.length) {
+      /* istanbul ignore if */
+      if (debug.enabled) {
+        debug('waiting for more data');
+      }
+      return false;
+    }
+
+    const start = this.total;
+    const tag = tools.readVint(this.buffer, this.cursor);
+
+    if (tag == null) {
+      /* istanbul ignore if */
+      if (debug.enabled) {
+        debug('waiting for more data');
+      }
+
+      return false;
+    }
+
+    const tagStr = tools.readHexString(
+      this.buffer,
+      this.cursor,
+      this.cursor + tag.length,
+    );
+    const tagNum = Number.parseInt(tagStr, 16);
+    this.cursor += tag.length;
+    this.total += tag.length;
+    this.state = STATE_SIZE;
+
+    const tagObj = {
+      tag: tag.value,
+      tagStr,
+      type: EbmlDecoder.getSchemaInfo(tagNum).type,
+      name: EbmlDecoder.getSchemaInfo(tagNum).name,
+      start,
+      end: start + tag.length,
+    };
+
+    this.tagStack.push(tagObj);
+    /* istanbul ignore if */
+    if (debug.enabled) {
+      debug(`read tag: ${tagStr}`);
+    }
+
+    return true;
+  }
+
+  readSize() {
+    const tagObj = this.tagStack[this.tagStack.length - 1];
+
+    /* istanbul ignore if */
+    if (debug.enabled) {
+      debug(`parsing size for tag: ${tagObj.tagStr}`);
+    }
+
+    if (this.cursor >= this.buffer.length) {
+      /* istanbul ignore if */
+      if (debug.enabled) {
+        debug('waiting for more data');
+      }
+
+      return false;
+    }
+
+    const size = tools.readVint(this.buffer, this.cursor);
+
+    if (size == null) {
+      /* istanbul ignore if */
+      if (debug.enabled) {
+        debug('waiting for more data');
+      }
+
+      return false;
+    }
+
+    this.cursor += size.length;
+    this.total += size.length;
+    this.state = STATE_CONTENT;
+    tagObj.dataSize = size.value;
+
+    // unknown size
+    if (size.value === -1) {
+      tagObj.end = -1;
+    } else {
+      tagObj.end += size.value + size.length;
+    }
+    /* istanbul ignore if */
+    if (debug.enabled) {
+      debug(`read size: ${size.value}`);
+    }
+
+    return true;
+  }
+
+  readContent() {
+    const { tagStr, type, dataSize, ...rest } = this.tagStack[this.tagStack.length - 1];
+
+    /* istanbul ignore if */
+    if (debug.enabled) {
+      debug(`parsing content for tag: ${tagStr}`);
+    }
+
+    if (type === 'm') {
+      /* istanbul ignore if */
+      if (debug.enabled) {
+        debug('content should be tags');
+      }
+      this.push(['start', { tagStr, type, dataSize, ...rest }]);
+      this.state = STATE_TAG;
+
+      return true;
+    }
+
+    if (this.buffer.length < this.cursor + dataSize) {
+      /* istanbul ignore if */
+      if (debug.enabled) {
+        debug(`got: ${this.buffer.length}`);
+        debug(`need: ${this.cursor + dataSize}`);
+        debug('waiting for more data');
+      }
+
+      return false;
+    }
+
+    const data = this.buffer.subarray(this.cursor, this.cursor + dataSize);
+    this.total += dataSize;
+    this.state = STATE_TAG;
+    this.buffer = this.buffer.subarray(this.cursor + dataSize);
+    this.cursor = 0;
+
+    this.tagStack.pop(); // remove the object from the stack
+
+    this.push([
+      'tag',
+      tools.readDataFromTag(
+        { tagStr, type, dataSize, ...rest },
+        Buffer.from(data),
+      ),
+    ]);
+
+    while (this.tagStack.length > 0) {
+      const topEle = this.tagStack[this.tagStack.length - 1];
+      if (this.total < topEle.end) {
+        break;
+      }
+      this.push(['end', topEle]);
+      this.tagStack.pop();
+    }
+
+    /* istanbul ignore if */
+    if (debug.enabled) {
+      debug(`read data: ${data.toString('hex')}`);
+    }
+
+    return true;
+  }
+}
+
+module.exports = EbmlDecoder

package/src/decoder.test.js

@@ -0,0 +1,158 @@
+const unexpected = require('unexpected');
+const unexpectedDate = require('unexpected-date');
+
+const Decoder = require('./decoder');
+
+const expect = unexpected.clone().use(unexpectedDate);
+
+const STATE_TAG = 1;
+const STATE_SIZE = 2;
+const STATE_CONTENT = 3;
+
+describe('EBML', () => {
+  describe('Decoder', () => {
+    it('should wait for more data if a tag is longer than the buffer', () => {
+      const decoder = new Decoder();
+      decoder.write(Buffer.from([0x1a, 0x45]));
+
+      expect(decoder.state, 'to be', STATE_TAG);
+      expect(decoder.buffer.length, 'to be', 2);
+      expect(decoder.cursor, 'to be', 0);
+    });
+
+    it('should clear the buffer after a full tag is written in one chunk', () => {
+      const decoder = new Decoder();
+      decoder.write(Buffer.from([0x42, 0x86, 0x81, 0x01]));
+
+      expect(decoder.state, 'to be', STATE_TAG);
+      expect(decoder.buffer.length, 'to be', 0);
+      expect(decoder.cursor, 'to be', 0);
+    });
+
+    it('should clear the buffer after a full tag is written in multiple chunks', () => {
+      const decoder = new Decoder();
+
+      decoder.write(Buffer.from([0x42, 0x86]));
+      decoder.write(Buffer.from([0x81, 0x01]));
+
+      expect(decoder.state, 'to be', STATE_TAG);
+      expect(decoder.buffer.length, 'to be', 0);
+      expect(decoder.cursor, 'to be', 0);
+    });
+
+    it('should increment the cursor on each step', () => {
+      const decoder = new Decoder();
+
+      decoder.write(Buffer.from([0x42])); // 4
+
+      expect(decoder.state, 'to be', STATE_TAG);
+      expect(decoder.buffer.length, 'to be', 1);
+      expect(decoder.cursor, 'to be', 0);
+
+      decoder.write(Buffer.from([0x86])); // 5
+
+      expect(decoder.state, 'to be', STATE_SIZE);
+      expect(decoder.buffer.length, 'to be', 2);
+      expect(decoder.cursor, 'to be', 2);
+
+      decoder.write(Buffer.from([0x81])); // 6 & 7
+
+      expect(decoder.state, 'to be', STATE_CONTENT);
+      expect(decoder.buffer.length, 'to be', 3);
+      expect(decoder.cursor, 'to be', 3);
+
+      decoder.write(Buffer.from([0x01])); // 6 & 7
+
+      expect(decoder.state, 'to be', STATE_TAG);
+      expect(decoder.buffer.length, 'to be', 0);
+      expect(decoder.cursor, 'to be', 0);
+    });
+
+    it('should emit correct tag events for simple data', done => {
+      const decoder = new Decoder();
+      decoder.on('data', ([state, { dataSize, tag, type, tagStr, data }]) => {
+        expect(state, 'to be', 'tag');
+        expect(tag, 'to be', 0x286);
+        expect(tagStr, 'to be', '4286');
+        expect(dataSize, 'to be', 0x01);
+        expect(type, 'to be', 'u');
+        expect(data, 'to equal', Buffer.from([0x01]));
+        done();
+        decoder.on('finish', done);
+      });
+      decoder.on('finish', done);
+      decoder.write(Buffer.from([0x42, 0x86, 0x81, 0x01]));
+      decoder.end();
+    });
+
+    it('should emit correct EBML tag events for master tags', done => {
+      const decoder = new Decoder();
+
+      decoder.on('data', ([state, { dataSize, tag, type, tagStr, data }]) => {
+        expect(state, 'to be', 'start');
+        expect(tag, 'to be', 0x0a45dfa3);
+        expect(tagStr, 'to be', '1a45dfa3');
+        expect(dataSize, 'to be', 0);
+        expect(type, 'to be', 'm');
+        expect(data, 'to be undefined');
+        done();
+        decoder.on('finish', done);
+      });
+      decoder.on('finish', done);
+
+      decoder.write(Buffer.from([0x1a, 0x45, 0xdf, 0xa3, 0x80]));
+      decoder.end();
+    });
+
+    it('should emit correct EBML:end events for master tags', done => {
+      const decoder = new Decoder();
+      let tags = 0;
+      decoder.on('data', d => {
+        const [state, data] = d;
+        if (state === 'end') {
+          expect(tags, 'to be', 2); // two tags
+          expect(data.tag, 'to be', 0x0a45dfa3);
+          expect(data.tagStr, 'to be', '1a45dfa3');
+          expect(data.dataSize, 'to be', 4);
+          expect(data.type, 'to be', 'm');
+          expect(data.data, 'to be undefined');
+          done();
+          decoder.on('finish', done);
+        } else {
+          tags += 1;
+        }
+      });
+      decoder.on('finish', done);
+
+      decoder.write(Buffer.from([0x1a, 0x45, 0xdf, 0xa3]));
+      decoder.write(Buffer.from([0x84, 0x42, 0x86, 0x81, 0x00]));
+      decoder.end();
+    });
+    describe('::getSchemaInfo', () => {
+      it('returns a correct tag if possible', () => {
+        expect(Decoder.getSchemaInfo(0x4286), 'to satisfy', {
+          name: 'EBMLVersion',
+          level: 1,
+          type: 'u',
+          mandatory: true,
+          default: 1,
+          minver: 1,
+          description: 'The version of EBML parser used to create the file.',
+          multiple: false,
+          webm: false,
+        });
+      });
+      it('returns a default object if not found', () => {
+        expect(Decoder.getSchemaInfo(0x404), 'to satisfy', {
+          type: expect.it('to be null'),
+          name: expect.it('to be a string').and('to be', 'unknown'),
+          description: expect.it('to be a string').and('to be empty'),
+          level: expect.it('to be a number').and('not to be positive'),
+          minver: expect.it('to be a number').and('not to be positive'),
+          multiple: expect.it('to be a boolean'),
+          webm: expect.it('to be a boolean'),
+        });
+      });
+    });
+  });
+});

package/src/encoder.js

@@ -0,0 +1,246 @@
+const { Transform } = require('stream');
+const schema = require('./schema');
+const tools = require('./tools');
+const { debugLog } = require('./debug-log');
+
+const debug = debugLog('ebml:encoder');
+
+/** @typedef {import('./types/tag.types').Tag} Tag */
+
+/**
+ * @param {number} tagId
+ * @param {Buffer} tagData
+ * @param {number} [end]
+ */
+function encodeTag(tagId, tagData, end) {
+  const data = [Buffer.from(tagId.toString(16), 'hex')];
+  if (end === -1) {
+    data.push(Buffer.from([0xFF]))
+  } else {
+    data.push(tools.writeVint(tagData.length))
+  }
+
+  // cast ArrayBuffer to Buffer
+  if (!Buffer.isBuffer(tagData)) {
+    tagData = Buffer.from(tagData); // eslint-disable-line no-param-reassign
+  }
+  data.push(tagData);
+  return Buffer.concat(data);
+}
+
+/**
+ * Encodes a raw EBML stream
+ * @class EbmlEncoder
+ * @extends Transform
+ */
+class EbmlEncoder extends Transform {
+  /**
+   * @type {Buffer}
+   * @property
+   * @private
+   */
+  mBuffer = null;
+
+  /**
+   * @private
+   * @property
+   * @type {Boolean}
+   */
+  mCorked = false;
+
+  /**
+   * @private
+   * @property
+   * @type {Array<Tag>}
+   */
+  mStack = [];
+
+  constructor(options = {}) {
+    super({ ...options, writableObjectMode: true });
+  }
+
+  get buffer() {
+    return this.mBuffer;
+  }
+
+  get corked() {
+    return this.mCorked;
+  }
+
+  get stack() {
+    return this.mStack;
+  }
+
+  set buffer(buffer) {
+    this.mBuffer = buffer;
+  }
+
+  set corked(corked) {
+    this.mCorked = corked;
+  }
+
+  set stack(stak) {
+    this.mStack = stak;
+  }
+
+  /**
+   *
+   * @param {[string, Tag]} chunk array of chunk data, starting with the tag
+   * @param {string} enc the encoding type (not used)
+   * @param {Function} done a callback method to call after the transformation
+   */
+  _transform(chunk, enc, done) {
+    const [tag, { data, name, ...rest }] = chunk;
+    /* istanbul ignore if */
+    if (debug.enabled) {
+      debug(`encode ${tag} ${name}`);
+    }
+
+    switch (tag) {
+      case 'start':
+        this.startTag(name, { ...rest });
+        break;
+      case 'tag':
+        this.writeTag(name, data);
+        break;
+      case 'end':
+        this.endTag();
+        break;
+      default:
+        break;
+    }
+
+    return done();
+  }
+
+  /**
+   * @private
+   * @param {Function} done callback function
+   */
+  flush(done = () => {}) {
+    if (!this.buffer || this.corked) {
+      /* istanbul ignore if */
+      if (debug.enabled) {
+        debug('no buffer/nothing pending');
+      }
+      return done();
+    }
+
+    if (this.buffer.byteLength === 0) {
+      /* istanbul ignore if */
+      if (debug.enabled) {
+        debug('empty buffer');
+      }
+      return done();
+    }
+
+    /* istanbul ignore if */
+    if (debug.enabled) {
+      debug(`writing ${this.buffer.length} bytes`);
+    }
+
+    const chunk = Buffer.from(this.buffer);
+    this.buffer = null;
+    this.push(chunk);
+    return done();
+  }
+
+  /**
+   * @private
+   * @param {Buffer | Buffer[]} buffer
+   */
+  bufferAndFlush(buffer) {
+    this.buffer = tools.concatenate(this.buffer, buffer);
+    this.flush();
+  }
+
+  _flush(done = () => {}) {
+    this.flush(done);
+  }
+
+  _bufferAndFlush(buffer) {
+    this.bufferAndFlush(buffer);
+  }
+
+  /**
+   * gets the ID of the type of tagName
+   * @static
+   * @param  {string} tagName to be looked up
+   * @return {number}         A buffer containing the schema information
+   */
+  static getSchemaInfo(tagName) {
+    const tagId = Array.from(schema.keys()).find(
+      str => schema.get(str).name === tagName,
+    );
+    if (tagId) {
+      return tagId;
+    }
+
+    return null;
+  }
+
+  cork() {
+    this.corked = true;
+  }
+
+  uncork() {
+    this.corked = false;
+    this.flush();
+  }
+
+  /** @private */
+  writeTag(tagName, tagData) {
+    const tagId = EbmlEncoder.getSchemaInfo(tagName);
+    if (!tagId) {
+      throw new Error(`No schema entry found for ${tagName}`);
+    }
+    if (tagData) {
+      const data = encodeTag(tagId, tagData);
+      if (this.stack.length > 0) {
+        this.stack[this.stack.length - 1].children.push({ data });
+      } else {
+        this.bufferAndFlush(data);
+      }
+    }
+  }
+
+  /**
+   * @private
+   * @param {String} tagName The name of the tag to start
+   * @param {{end: Number}} info an information object with a `end` parameter
+   */
+  startTag(tagName, { end }) {
+    const tagId = EbmlEncoder.getSchemaInfo(tagName);
+    if (!tagId) {
+      throw new Error(`No schema entry found for ${tagName}`);
+    }
+
+    const tag = {
+      data: null,
+      id: tagId,
+      name: tagName,
+      end,
+      children: [],
+    };
+
+    if (this.stack.length > 0) {
+      this.stack[this.stack.length - 1].children.push(tag);
+    }
+    this.stack.push(tag);
+  }
+
+  /** @private */
+  endTag() {
+    const tag = this.stack.pop() || {
+      children: [],
+      data: { buffer: Buffer.from([]) },
+    };
+    const childTagDataBuffers = tag.children.map(child => child.data);
+    tag.data = encodeTag(tag.id, Buffer.concat(childTagDataBuffers), tag.end);
+    if (this.stack.length < 1) {
+      this.bufferAndFlush(tag.data);
+    }
+  }
+}
+
+module.exports = EbmlEncoder