@gmod/cram 3.0.6 → 4.0.0

package/src/htscodecs/fqzcomp.js

@@ -0,0 +1,360 @@
+/*
+ * Copyright (c) 2019 Genome Research Ltd.
+ * Author(s): James Bonfield
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *
+ *    3. Neither the names Genome Research Ltd and Wellcome Trust Sanger
+ *       Institute nor the names of its contributors may be used to endorse
+ *       or promote products derived from this software without specific
+ *       prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY GENOME RESEARCH LTD AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GENOME RESEARCH
+ * LTD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+const IOStream = require('./iostream')
+const ByteModel = require('./byte_model')
+const RangeCoder = require('./arith_sh')
+
+//----------------------------------------------------------------------
+// Main arithmetic entry function: decodes a compressed src and
+// returns the uncompressed buffer.
+
+function read_array(src, tab, size) {
+  var j = 0 // array value
+  var z = 0 // array index: tab[j]
+  var last = -1
+
+  // Remove first level of run-length encoding
+  var R = new Array(1024) // runs
+  while (z < size) {
+    var run = src.ReadByte()
+    R[j++] = run
+    z += run
+
+    if (run == last) {
+      var copy = src.ReadByte()
+      z += run * copy
+      while (copy--) R[j++] = run
+    }
+    last = run
+  }
+
+  // Now expand runs in R to tab, noting 255 is max run
+  var i = 0
+  j = 0
+  z = 0
+  while (z < size) {
+    var run_len = 0
+    do {
+      var part = R[j++]
+      run_len += part
+    } while (part == 255)
+
+    while (run_len--) tab[z++] = i
+    i++
+  }
+}
+
+const QMAX = 256
+
+const FLAG_DEDUP = 2
+const FLAG_FLEN = 4
+const FLAG_SEL = 8 // whether selector is used in context
+const FLAG_QMAP = 16
+const FLAG_PTAB = 32
+const FLAG_DTAB = 64
+const FLAG_QTAB = 128
+
+const GFLAG_MULTI_PARAM = 1
+const GFLAG_HAVE_STAB = 2
+const GFLAG_DO_REV = 4
+
+// Compute a new context from our current state and qual q
+function fqz_update_ctx(params, state, q) {
+  var last = params.context
+  state.qctx = (state.qctx << params.qshift) + params.qtab[q] // >>> 0
+  last += (state.qctx & ((1 << params.qbits) - 1)) << params.qloc // >>> 0
+
+  if (params.do_pos) last += params.ptab[Math.min(state.p, 1023)] << params.ploc
+
+  if (params.do_delta) {
+    last += params.dtab[Math.min(state.delta, 255)] << params.dloc
+    // Is it better to use q here or qtab[q]?
+    // If qtab[q] we can map eg [a-z0-9A-Z]->0 ,->1 and have
+    // delta being a token number count into comma separated lists?
+    state.delta += state.prevq != q ? 1 : 0
+    state.prevq = q
+  }
+
+  if (params.do_sel) last += state.s << params.sloc
+
+  state.p--
+
+  return last & 0xffff
+}
+
+function decode_fqz_single_param(src) {
+  var p = {} // params
+
+  // Load FQZ parameters
+  p.context = src.ReadUint16()
+  p.pflags = src.ReadByte()
+
+  p.do_dedup = p.pflags & FLAG_DEDUP
+  p.fixed_len = p.pflags & FLAG_FLEN
+  p.do_sel = p.pflags & FLAG_SEL
+  p.do_qmap = p.pflags & FLAG_QMAP
+  p.do_pos = p.pflags & FLAG_PTAB
+  p.do_delta = p.pflags & FLAG_DTAB
+  p.do_qtab = p.pflags & FLAG_QTAB
+
+  p.max_sym = src.ReadByte()
+
+  var x = src.ReadByte()
+  p.qbits = x >> 4
+  p.qshift = x & 15
+  x = src.ReadByte()
+  p.qloc = x >> 4
+  p.sloc = x & 15
+  x = src.ReadByte()
+  p.ploc = x >> 4
+  p.dloc = x & 15
+
+  // Qual map, eg to "unbin" Illumina qualities
+  p.qmap = new Array(256)
+  if (p.pflags & FLAG_QMAP) {
+    for (var i = 0; i < p.max_sym; i++) p.qmap[i] = src.ReadByte()
+  } else {
+    // Useful optimisation to speed up main loop
+    for (var i = 0; i < 256; i++) p.qmap[i] = i // NOP
+  }
+
+  // Read tables
+  p.qtab = new Array(1024)
+  if (p.qbits > 0 && p.pflags & FLAG_QTAB) {
+    read_array(src, p.qtab, 256)
+  } else {
+    // Useful optimisation to speed up main loop
+    for (var i = 0; i < 256; i++) p.qtab[i] = i // NOP
+  }
+
+  p.ptab = new Array(1024)
+  if (p.pflags & FLAG_PTAB) read_array(src, p.ptab, 1024)
+
+  p.dtab = new Array(256)
+  if (p.pflags & FLAG_DTAB) read_array(src, p.dtab, 256)
+
+  return p
+}
+
+function decode_fqz_params(src) {
+  var gparams = {
+    max_sym: 0,
+  }
+
+  // Check fqz format version
+  var vers = src.ReadByte()
+  if (vers != 5) {
+    console.error('Invalid FQZComp version number')
+    return
+  }
+
+  var gflags = src.ReadByte()
+  var nparam = gflags & GFLAG_MULTI_PARAM ? src.ReadByte() : 1
+  var max_sel = gflags.nparam > 1 ? gflags.nparam - 1 : 0 // Note max_sel, not num_sel
+
+  var stab = new Array(256)
+  if (gflags & GFLAG_HAVE_STAB) {
+    max_sel = src.ReadByte()
+    read_array(src, stab, 256)
+  } else {
+    for (var i = 0; i < nparam; i++) stab[i] = i
+    for (; i < 256; i++) stab[i] = nparam - 1
+  }
+  gparams.do_rev = gflags & GFLAG_DO_REV
+  gparams.stab = stab
+  gparams.max_sel = max_sel
+
+  gparams.params = new Array(gparams.nparam)
+  for (var p = 0; p < nparam; p++) {
+    gparams.params[p] = decode_fqz_single_param(src)
+    if (gparams.max_sym < gparams.params[p].max_sym)
+      gparams.max_sym = gparams.params[p].max_sym
+  }
+
+  return gparams
+}
+
+function fqz_create_models(gparams) {
+  var model = {}
+
+  model.qual = new Array(1 << 16)
+  for (var i = 0; i < 1 << 16; i++)
+    model.qual[i] = new ByteModel(gparams.max_sym + 1) // +1 as max value not num. values
+
+  model.len = new Array(4)
+  for (var i = 0; i < 4; i++) model.len[i] = new ByteModel(256)
+
+  model.rev = new ByteModel(2)
+  model.dup = new ByteModel(2)
+
+  if (gparams.max_sel > 0) model.sel = new ByteModel(gparams.max_sel + 1) // +1 as max value not num. values
+
+  return model
+}
+
+// Initialise a new record, updating state.
+// Returns 1 if dup, otherwise 0
+function decode_fqz_new_record(src, rc, gparams, model, state, rev) {
+  // Parameter selector
+  if (gparams.max_sel > 0) {
+    state.s = model.sel.ModelDecode(src, rc)
+  } else {
+    state.s = 0
+  }
+  state.x = gparams.stab[state.s]
+
+  var params = gparams.params[state.x]
+
+  // Reset contexts at the start of each new record
+  if (params.fixed_len >= 0) {
+    // Not fixed or fixed but first record
+    var len = model.len[0].ModelDecode(src, rc)
+    len |= model.len[1].ModelDecode(src, rc) << 8
+    len |= model.len[2].ModelDecode(src, rc) << 16
+    len |= model.len[3].ModelDecode(src, rc) << 24
+    if (params.fixed_len > 0) params.fixed_len = -len
+  } else {
+    len = -params.fixed_len
+  }
+  state.len = len
+
+  if (gparams.do_rev) rev[state.rec] = model.rev.ModelDecode(src, rc)
+
+  state.is_dup = 0
+  if (params.pflags & FLAG_DEDUP) {
+    if (model.dup.ModelDecode(src, rc)) state.is_dup = 1
+  }
+
+  state.p = len // number of remaining bytes in this record
+  state.delta = 0
+  state.qctx = 0
+  state.prevq = 0
+  state.rec++
+}
+
+function decode_fqz(src, q_lens) {
+  // Decode parameter block
+  var n_out = src.ReadUint7()
+  var gparams = decode_fqz_params(src)
+  if (!gparams) return
+  var params = gparams.params
+  var rev = new Array(q_lens.length)
+
+  // Create initial models
+  var model = fqz_create_models(gparams)
+
+  // Create our entropy encoder and output buffers
+  var rc = new RangeCoder(src)
+  rc.RangeStartDecode(src)
+  var output = new Uint8Array(n_out)
+
+  // Internal FQZ state
+  var state = {
+    qctx: 0, // Qual-only sub-context
+    prevq: 0, // Previous quality value
+    delta: 0, // Running delta (q vs prevq)
+    p: 0, // Number of bases left in current record
+    s: 0, // Current parameter selector value (0 if unused)
+    x: 0, // "stab" tabulated copy of s
+    len: 0, // Length of current string
+    is_dup: 0, // This string is a duplicate of last
+    rec: 0, // Record number
+  }
+
+  // The main decode loop itself
+  var i = 0 // position in output buffer
+  while (i < n_out) {
+    if (state.p == 0) {
+      decode_fqz_new_record(src, rc, gparams, model, state, rev)
+      if (state.is_dup > 0) {
+        if (model.dup.ModelDecode(src, rc)) {
+          // Duplicate of last line
+          for (var x = 0; x < len; x++)
+            output[i + x] = output[i + x - state.len]
+          i += state.len
+          state.p = 0
+          continue
+        }
+      }
+      q_lens.push(state.len)
+
+      var params = gparams.params[state.x]
+      var last = params.context
+    }
+
+    // Decode the current quality (possibly mapped via qmap)
+    var Q = model.qual[last].ModelDecode(src, rc)
+
+    //if (params.do_qmap)
+    //    output[i++] = params.qmap[Q];
+    //else
+    //    output[i++] = Q
+    output[i++] = params.qmap[Q] // optimised version of above
+    last = fqz_update_ctx(params, state, Q)
+  }
+
+  if (gparams.do_rev) reverse_qualities(output, n_out, rev, q_lens)
+
+  return output
+}
+
+function reverse_qualities(qual, qual_len, rev, len) {
+  var rec = 0
+  var i = 0
+  while (i < qual_len) {
+    if (rev[rec]) {
+      var j = 0
+      var k = len[rec] - 1
+      while (j < k) {
+        var tmp = qual[i + j]
+        qual[i + j] = qual[i + k]
+        qual[i + k] = tmp
+        j++
+        k--
+      }
+    }
+
+    i += len[rec++]
+  }
+}
+
+function decode(src, q_lens) {
+  var stream = new IOStream(src)
+
+  //var n_out = stream.ReadUint32(); stream.ReadUint32(); // move to main
+
+  return decode_fqz(stream, q_lens)
+}
+
+module.exports = { decode }

package/src/htscodecs/index.js

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2020 Genome Research Ltd.
+ * Author(s): James Bonfield
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *
+ *    3. Neither the names Genome Research Ltd and Wellcome Trust Sanger
+ *       Institute nor the names of its contributors may be used to endorse
+ *       or promote products derived from this software without specific
+ *       prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY GENOME RESEARCH LTD AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GENOME RESEARCH
+ * LTD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// This is an interface to the htscodecs reference implementation of
+// the CRAM 3.1 codecs.
+
+// This JavaScript file is not part of the reference implementation
+// and is simply and interface to get a consistent interface for cram-js.
+
+var r4x8 = require('./rans')
+var r4x16 = require('./rans4x16')
+var arith = require('./arith_gen')
+var fqzcomp = require('./fqzcomp')
+var tok3 = require('./tok3')
+
+function r4x8_uncompress(inputBuffer, outputBuffer) {
+  return r4x8.decode(inputBuffer)
+}
+
+function r4x16_uncompress(inputBuffer) {
+  return r4x16.decode(inputBuffer)
+}
+
+function arith_uncompress(inputBuffer) {
+  // fix by @cmdcolin for CRAM 3.1
+  // xref https://github.com/jkbonfield/htscodecs/pull/1/files
+  return new arith().decode(inputBuffer)
+}
+
+function fqzcomp_uncompress(inputBuffer) {
+  var q_lens = new Array()
+  return fqzcomp.decode(inputBuffer, q_lens)
+}
+
+function tok3_uncompress(inputBuffer) {
+  // Returns in string form instead of buffer
+  var out = tok3.decode(inputBuffer, 0, '\0')
+  return Uint8Array.from(Array.from(out).map(letter => letter.charCodeAt(0)))
+}
+
+module.exports = {
+  r4x8_uncompress: r4x8_uncompress,
+  r4x16_uncompress: r4x16_uncompress,
+  arith_uncompress: arith_uncompress,
+  fqzcomp_uncompress: fqzcomp_uncompress,
+  tok3_uncompress: tok3_uncompress,
+}

package/src/htscodecs/iostream.js

@@ -0,0 +1,257 @@
+/*
+ * Copyright (c) 2019 Genome Research Ltd.
+ * Author(s): James Bonfield
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *
+ *    3. Neither the names Genome Research Ltd and Wellcome Trust Sanger
+ *       Institute nor the names of its contributors may be used to endorse
+ *       or promote products derived from this software without specific
+ *       prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY GENOME RESEARCH LTD AND CONTRIBUTORS "AS
+ * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GENOME RESEARCH
+ * LTD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// Turn a buffer into a fake stream with get / put commands.
+// This enables up to closely match the published pseudocode.
+module.exports = class IOStream {
+  constructor(buf, start_pos = 0, size = 0) {
+    if (size != 0) {
+      this.buf = new Uint8Array(size)
+      this.length = size
+    } else {
+      this.buf = buf
+      this.length = buf.length
+    }
+    this.dataView = new DataView(this.buf.buffer)
+    this.pos = start_pos
+  }
+
+  // ----------
+  // Reading
+  EOF() {
+    return this.pos >= this.length
+  }
+
+  ReadData(len) {
+    var A = this.buf.slice(this.pos, this.pos + len)
+    this.pos += len
+    return A
+  }
+
+  ReadByte() {
+    const b = this.buf[this.pos]
+    this.pos++
+    return b
+  }
+
+  ReadChar() {
+    const b = this.buf[this.pos]
+    this.pos++
+    return String.fromCharCode(b)
+  }
+
+  ReadUint16() {
+    var i = this.ReadByte()
+    i |= this.ReadByte() << 8
+    return i
+  }
+
+  ReadUint32() {
+    const i = this.dataView.getInt32(this.pos, true)
+    this.pos += 4
+    return i
+  }
+
+  // nul terminated string
+  ReadString() {
+    var s = ''
+    do {
+      var b = this.buf[this.pos++]
+      if (b) s += String.fromCharCode(b)
+    } while (b)
+    return s
+  }
+
+  //    ReadUint7() {
+  //	// Variable sized unsigned integers
+  //	var i = 0;
+  //	var s = 0;
+  //	do {
+  //	    var c = this.ReadByte();
+  //	    i = i | ((c & 0x7f)<<s);
+  //	    s += 7;
+  //	} while ((c & 0x80))
+  //
+  //	return i;
+  //    }
+
+  ReadUint7() {
+    // Variable sized unsigned integers
+    var i = 0
+    do {
+      var c = this.ReadByte()
+      i = (i << 7) | (c & 0x7f)
+    } while (c & 0x80)
+
+    return i
+  }
+
+  ReadITF8() {
+    var i = this.buf[this.pos]
+    this.pos++
+
+    //process.stderr.write("i="+i+"\n");
+
+    if (i >= 0xf0) {
+      // 1111xxxx => +4 bytes
+      i = (i & 0x0f) << 28
+      i +=
+        (this.buf[this.pos + 0] << 20) +
+        (this.buf[this.pos + 1] << 12) +
+        (this.buf[this.pos + 2] << 4) +
+        (this.buf[this.pos + 3] >> 4)
+      this.pos += 4
+      //process.stderr.write("  4i="+i+"\n");
+    } else if (i >= 0xe0) {
+      // 1110xxxx => +3 bytes
+      i = (i & 0x0f) << 24
+      i +=
+        (this.buf[this.pos + 0] << 16) +
+        (this.buf[this.pos + 1] << 8) +
+        (this.buf[this.pos + 2] << 0)
+      this.pos += 3
+      //process.stderr.write("  3i="+i+"\n");
+    } else if (i >= 0xc0) {
+      // 110xxxxx => +2 bytes
+      i = (i & 0x1f) << 16
+      i += (this.buf[this.pos + 0] << 8) + (this.buf[this.pos + 1] << 0)
+      this.pos += 2
+      //process.stderr.write("  2i="+i+"\n");
+    } else if (i >= 0x80) {
+      // 10xxxxxx => +1 bytes
+      i = (i & 0x3f) << 8
+      i += this.buf[this.pos]
+      this.pos++
+      //process.stderr.write("  1i="+i+"\n");
+    } else {
+      // 0xxxxxxx => +0 bytes
+    }
+
+    return i
+  }
+
+  // ----------
+  // Writing
+  WriteByte(b) {
+    this.buf[this.pos++] = b
+  }
+
+  WriteChar(b) {
+    this.buf[this.pos++] = b.charCodeAt(0)
+  }
+
+  WriteString(str) {
+    for (var i = 0; i < str.length; i++)
+      this.buf[this.pos++] = str.charCodeAt(i)
+    this.buf[this.pos++] = 0
+  }
+
+  WriteData(buf, len) {
+    for (var i = 0; i < len; i++) this.buf[this.pos++] = buf[i]
+  }
+
+  WriteStream(stream) {
+    this.WriteData(stream.buf, stream.pos)
+  }
+
+  WriteUint16(u) {
+    //this.buf.writeInt16LE(u, this.pos);
+    this.WriteByte(u & 0xff)
+    this.WriteByte((u >> 8) & 0xff)
+  }
+
+  WriteUint32(u) {
+    this.buf.writeInt32LE(u, this.pos)
+    this.pos += 4
+  }
+
+  //    WriteUint7(i) {
+  //	do {
+  //	    this.WriteByte((i & 0x7f) | ((i > 0x80) << 7));
+  //	    i >>= 7;
+  //	} while (i > 0);
+  //    }
+
+  WriteUint7(i) {
+    var s = 0
+    var X = i
+    do {
+      s += 7
+      X >>= 7
+    } while (X > 0)
+
+    do {
+      s -= 7
+      this.WriteByte(((i >> s) & 0x7f) + ((s > 0) << 7))
+    } while (s > 0)
+  }
+
+  WriteITF8(i) {
+    // Horrid, ITF8 is unsigned, but we still write signed into it
+    if (i < 0) i = (1 << 32) + i
+
+    if (i <= 0x0000007f) {
+      // 1 byte
+      this.buf[this.pos++] = i
+    } else if (i <= 0x00003fff) {
+      // 2 bytes
+      this.buf[this.pos++] = 0x80 | Math.floor(i / 256)
+      this.buf[this.pos++] = i & 0xff
+    } else if (i < 0x0001ffff) {
+      // 3 bytes
+      this.buf[this.pos++] = 0xc0 | Math.floor(i / 65536)
+      this.buf[this.pos++] = Math.floor(i / 256) & 0xff
+      this.buf[this.pos++] = i & 0xff
+    } else if (i < 0x0fffffff) {
+      // 4 bytes
+      this.buf[this.pos++] = 0xe0 | Math.floor(i / 16777216)
+      this.buf[this.pos++] = Math.floor(i / 65536) & 0xff
+      this.buf[this.pos++] = Math.floor(i / 256) & 0xff
+      this.buf[this.pos++] = i & 0xff
+    } else {
+      // 5 bytes; oddly using 4.5 bytes
+      this.buf[this.pos++] = 0xf0 | Math.floor(i / 268435456)
+      this.buf[this.pos++] = Math.floor(i / 1048576) & 0xff
+      this.buf[this.pos++] = Math.floor(i / 4096) & 0xff
+      this.buf[this.pos++] = Math.floor(i / 4) & 0xff
+      this.buf[this.pos++] = i & 0x0f
+    }
+  }
+
+  // ----------
+  // Writing from end of buffer going backwards.
+  // Needed by rANS codec.
+  WriteByteNeg(b) {
+    this.buf[--this.pos] = b
+  }
+}