@gmod/cram 3.0.7 → 4.0.0

package/src/htscodecs/fqzcomp.js

@@ -277,7 +277,7 @@ function decode_fqz(src, q_lens) {
   // Create our entropy encoder and output buffers
   var rc = new RangeCoder(src)
   rc.RangeStartDecode(src)
-  var output = new Buffer.allocUnsafe(n_out)
+  var output = new Uint8Array(n_out)
 
   // Internal FQZ state
   var state = {
@@ -357,478 +357,4 @@ function decode(src, q_lens) {
   return decode_fqz(stream, q_lens)
 }
 
-//----------------------------------------------------------------------
-// FQZComp encoder.
-
-function pick_fqz_params(src, q_lens, q_dirs, qhist) {
-  // Find cardinality of q_dirs
-  var qd_last = q_dirs[0]
-  for (var i = 0; i < q_dirs.length; i++) if (q_dirs[i] != qd_last) break
-  var qd_fixed = i == q_dirs.length ? 1 : 0
-
-  // Scan input to find number of symbols and max symbol
-  var nsym = 0
-  var max_sym = 0
-
-  // selector == 0: Assume one single input dataset
-  for (var i = 0; i < 256; i++) qhist[0][i] = 0
-
-  var rec = 0
-  var len = 0
-  for (var i = 0; i < src.length; i++) {
-    if (len == 0) {
-      len = q_lens[rec < q_lens.length - 1 ? rec++ : rec]
-    }
-    qhist[0][src[i]]++
-    len--
-  }
-  for (var i = 0; i < 256; i++) {
-    if (!qhist[0][i]) continue
-    if (max_sym < i) max_sym = i
-    nsym++
-  }
-
-  var qshift = 5
-  var do_qmap = 0
-  // Reduced symbol frequencies implies lower qshift and
-  // a lookup table to go from qual to Q
-  if (nsym <= 16) {
-    do_qmap = 1 // based on qhist
-    if (nsym <= 2) qshift = 1
-    else if (nsym <= 4) qshift = 2
-    else if (nsym <= 8) qshift = 3
-    else qshift = 4
-  }
-
-  //    // Two params and a 1-bit selector.
-  //    // This is 1% overhead vs two data sets compressed independently.
-  //    // It's 6.9% smaller than compressing both together with 1 param.
-  //    if (0) return [{
-  //	// q4
-  //	qbits:     8,
-  //	qshift:    2,
-  //	qloc:      7,
-  //
-  //	pbits:     7,
-  //	pshift:    1,
-  //	ploc:      0,
-  //
-  //	dbits:     0,
-  //	dshift:    0,
-  //	dloc:      0,
-  //
-  //      sbits:     0,
-  //      sloc:      0,
-  //
-  //	//sbits:     2,
-  //	//do_stab:   1,
-  //	sbits:     1,
-  //	do_stab:   0,
-  //	context:   (0<<15),
-  //
-  //	max_sym:   36,
-  //	nsym:      4,
-  //
-  //	do_qmap:   1,
-  //	do_dedup:  0,
-  //	fixed_len: 1,
-  //	do_sel:  0,
-  //	do_rev:    0,
-  //	do_pos:    1,
-  //	do_delta:  0,
-  //	do_qtab:   0
-  //    }, {
-  //	//q40
-  //	qbits:     9,
-  //	qshift:    5,
-  //	qloc:      7,
-  //
-  //	pbits:     7,
-  //	pshift:    0,
-  //	ploc:      0,
-  //
-  //	dbits:     0,
-  //	dshift:    0,
-  //	dloc:      0,
-  //
-  //      sbits:     0,
-  //      sloc:      0,
-  //
-  //	//sbits:     2,
-  //	//do_stab:   1,
-  //	sbits:     1,
-  //	do_stab:   0,
-  //	context:   (1<<15),
-  //
-  //	max_sym:   44,
-  //	nsym:      45,
-  //
-  //	do_qmap:   0,
-  //	do_dedup:  0,
-  //	fixed_len: 1,
-  //	do_sel:  0,
-  //	do_rev:    0,
-  //	do_pos:    1,
-  //	do_delta:  0,
-  //	do_qtab:   0
-  //    }]
-
-  return [
-    {
-      qbits: 8 + (qshift > 4),
-      qshift: qshift,
-      qloc: 7,
-
-      pbits: 7,
-      pshift: q_lens[0] > 128 ? 1 : 0,
-      ploc: 0,
-
-      dbits: qshift > 4 ? 0 : 1,
-      dshift: 3,
-      dloc: 15,
-
-      // NB: Also useful as a way of embedding sel and doing sel
-      // specific contexts. Identical bar context. Eg 0<<15 or 1<<15.
-      sbits: 0,
-      sloc: 15,
-      do_stab: 0,
-      context: 0 << 15,
-
-      max_sym: max_sym,
-      nsym: nsym,
-
-      do_qmap: do_qmap,
-      do_dedup: 0,
-      fixed_len: q_lens.length == 1 ? 1 : 0,
-      do_sel: 0,
-      do_rev: 0,
-      do_pos: 1,
-      do_delta: qshift <= 4 ? 1 : 0,
-      do_qtab: 0,
-
-      // Override above with some attempt at using selectors
-      // when the q_dirs are specific and non-fixed.
-      qbits: 8 + (qshift > 4) - (qd_fixed == 0),
-      sbits: 1,
-      sloc: 15 - (qshift <= 4), // read1 vs read2
-      do_stab: 1,
-      do_sel: 1,
-
-      //	     // q4+dir: 7245769 with, 7353962 without. 1.5% saving
-      //	     qbits:     6,
-      //	     dbits:     2,
-      //	     dshift:    2,
-      //	     dloc:      13,
-      //	     sbits:     1,
-      //	     sloc:      15,
-      //	     do_stab:   1,
-      //	     do_sel:    1,
-
-      // with 20 bits of context, q40 = 31741545
-      // qbits 10, dbits 2, pbits 7, sbits 1
-    },
-  ]
-}
-
-function store_array(out, tab, size) {
-  var i = 0 // index into tab
-  var j = 0 // current value in tab[i]
-
-  var tmp1 = new Array(size * 2)
-  var sz1 = 0
-
-  // First level of RLE.  Replace all runs of 'j' values
-  // with run-lengths, including zeros for missing values.
-  // Eg 0 1 2 2 2 3 3 3 4 4 4 5 5 5 5   7 7
-  // to 1 1 3     3     3     4       0 2
-  while (i < size) {
-    // Length of j^{th} element
-    var i_start = i
-    while (i < size && tab[i] == j) i++
-    var run_len = i - i_start
-
-    // Encode run length to tmp array
-    do {
-      var r = Math.min(255, run_len)
-      tmp1[sz1++] = r
-      run_len -= r
-    } while (r == 255)
-    j++
-  }
-
-  // Second round of RLE on our tmp array, using a different
-  // RLE algorithm.
-  // Eg 1 1    3 3  3 4 0 2
-  // to 1 1 +0 3 3 +1 4 0 2
-  var last = -1
-  var tmp2 = new Array(size * 2)
-  var sz2 = 0
-  i = 0 // index into tmp1]
-  // k is used size of tmp1[]
-  while (i < sz1) {
-    var curr = tmp1[i++]
-    tmp2[sz2++] = curr
-    if (curr == last) {
-      var i_start = i
-      while (i < sz1 && tmp1[i] == last && i - i_start < 255) i++
-      tmp2[sz2++] = i - i_start
-    } else {
-      last = curr
-    }
-  }
-
-  // Append 2nd RLE, tmp2, to out.
-  out.WriteData(tmp2, sz2)
-}
-
-// q_lens is an array of quality lengths per record.
-// (If they're all the same, just set one value.)
-function encode_fqz_params(out, params, qhist, qtab, ptab, dtab, stab) {
-  var dsqr = [
-    0, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-    5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7,
-    7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
-  ]
-
-  for (var i = 0; i < params.length; i++) stab[i] = i // 1 parameter set per selector value
-  for (; i < 256; i++) stab[i] = params.length - 1
-
-  // Store global meta-data
-  out.WriteByte(5) // FQZ format number
-  var gflags =
-    (params.length > 1 ? GFLAG_MULTI_PARAM : 0) |
-    (params[0].do_stab ? GFLAG_HAVE_STAB : 0)
-  out.WriteByte(gflags)
-
-  if (gflags & GFLAG_MULTI_PARAM) out.WriteByte(params.length) // Number of parameter blocks.
-
-  if (gflags & GFLAG_HAVE_STAB) {
-    var max_sel = 1 << params[0].sbits
-    if (max_sel > 0) max_sel--
-    out.WriteByte(max_sel)
-    store_array(out, stab, 256)
-  }
-
-  // Store per-param meta-data
-  for (var p = 0; p < params.length; p++) {
-    out.WriteUint16(params[p].context)
-    out.WriteByte(
-      (params[p].do_qtab ? FLAG_QTAB : 0) | // FLAG
-        (params[p].do_delta ? FLAG_DTAB : 0) |
-        (params[p].do_pos ? FLAG_PTAB : 0) |
-        (params[p].do_qmap ? FLAG_QMAP : 0) |
-        (params[p].do_sel ? FLAG_SEL : 0) |
-        (params[p].fixed_len ? FLAG_FLEN : 0) |
-        (params[p].do_dedup ? FLAG_DEDUP : 0),
-    )
-    if (params[p].do_qmap) out.WriteByte(params[p].nsym)
-    else out.WriteByte(params[p].max_sym)
-    out.WriteByte((params[p].qbits << 4) | params[p].qshift)
-    out.WriteByte((params[p].qloc << 4) | params[p].sloc)
-    out.WriteByte((params[p].ploc << 4) | params[p].dloc)
-
-    if (params[p].do_qmap) {
-      params[p].max_sym = params[p].nsym
-      var n = 0
-      for (var i = 0; i < 256; i++) {
-        if (qhist[p][i]) {
-          out.WriteByte(i)
-          qhist[p][i] = n++
-        }
-      }
-      // Ensure we have all matched input params
-      for (; n < params[p].nsym; n++) out.WriteByte(0)
-    } else {
-      //params[p].nsym = 255;
-      for (var i = 0; i < 256; i++) qhist[p][i] = i // NOP
-    }
-
-    if (params[p].qbits > 0) {
-      //	// Eg map 0-44 to a smaller range, to improve context usage.
-      //	// Makes q40 test set go from 33596471 to 33450075 (-0.4%)
-      //	params[p].do_qtab = 1;
-      //	for (var j = i = 0; i < params[p].max_sym; i++) {
-      //	    qtab[i]=j;
-      //	    if ((i%3)!=0 | i >= 28) j++
-      //	    console.log("qtab[",i,"]=",qtab[i]);
-      //	}
-      //	for (; i < 256; i++)
-      //	    qtab[i] = qtab[params[p].max_sym-1]
-
-      for (var i = 0; i < 256; i++) qtab[p][i] = i // NOP for now
-
-      if (params[p].do_qtab) store_array(out, qtab[p], 256)
-    }
-
-    if (params[p].pbits > 0) {
-      for (var i = 0; i < 1024; i++)
-        ptab[p][i] = Math.min((1 << params[p].pbits) - 1, i >> params[p].pshift)
-
-      store_array(out, ptab[p], 1024)
-    }
-
-    if (params[p].dbits > 0) {
-      for (var i = 0; i < 256; i++)
-        if (dsqr[i] > (1 << params[p].dbits) - 1)
-          dsqr[i] = (1 << params[p].dbits) - 1
-      for (var i = 0; i < 256; i++)
-        dtab[p][i] = dsqr[Math.min(dsqr.length - 1, i >> params[p].dshift)]
-
-      store_array(out, dtab[p], 256)
-    }
-  }
-
-  return out
-}
-
-function encode_fqz(
-  out,
-  src,
-  q_lens,
-  q_dirs,
-  params,
-  qhist,
-  qtab,
-  ptab,
-  dtab,
-  stab,
-) {
-  //console.error("0:",params[0])
-  //console.error("1:",params[1])
-
-  var max_sel = 1 << params[0].sbits
-  if (max_sel > 0) max_sel--
-  var n_in = src.length
-
-  // Create the models
-  var max_sym = 0
-  for (var p = 0; p < params.length; p++)
-    if (max_sym < params[p].max_sym) max_sym = params[p].max_sym
-
-  var model_qual = new Array(1 << 16)
-  for (var i = 0; i < 1 << 16; i++) model_qual[i] = new ByteModel(max_sym + 1)
-
-  var model_len = new Array(4)
-  for (var i = 0; i < 4; i++) model_len[i] = new ByteModel(256)
-
-  var model_rev = new ByteModel(2)
-  var model_dup = new ByteModel(2)
-  var model_sel = new ByteModel(max_sel + 1)
-
-  // Note: our JavaScript encoder doesn't have a way for reversing
-  // some quality strings, so we ignore do_rev for now.
-  var rc = new RangeCoder(src)
-
-  // The main encoding loop
-  var p = 0 // remaining position along current record
-  var i = 0 // index in src data
-  var rec = 0
-
-  while (i < n_in) {
-    if (p == 0) {
-      //var s = 0 // single non-mixed sample
-      var s = q_dirs[rec]
-      if (params[0].sbits > 0) {
-        // FIXME: check All params[].do_stab / sbits must be identical
-        //console.log("Ssel", s)
-        model_sel.ModelEncode(out, rc, s)
-      }
-      var x = stab[s]
-
-      // Reset contexts at the statr of each new record
-      var len = q_lens[Math.min(q_lens.length - 1, rec++)]
-      if (params[x].fixed_len) {
-        if (params[x].fixed_len > 0) {
-          // First length
-          //console.log("Len", len)
-          model_len[0].ModelEncode(out, rc, len & 0xff)
-          model_len[1].ModelEncode(out, rc, (len >> 8) & 0xff)
-          model_len[2].ModelEncode(out, rc, (len >> 16) & 0xff)
-          model_len[3].ModelEncode(out, rc, (len >> 24) & 0xff)
-          params[x].fixed_len = -1 // indicate we've stored it once
-        }
-      } else {
-        //console.log("len", len)
-        model_len[0].ModelEncode(out, rc, len & 0xff)
-        model_len[1].ModelEncode(out, rc, (len >> 8) & 0xff)
-        model_len[2].ModelEncode(out, rc, (len >> 16) & 0xff)
-        model_len[3].ModelEncode(out, rc, (len >> 24) & 0xff)
-      }
-
-      if (params[x].do_dedup) process.exit(1) // FIXME
-
-      p = len
-      var delta = 0
-      //var last  = 0
-      var last = params[x].context
-      var qlast = 0
-      var q1 = 0
-    }
-
-    // Encode current quality
-    var q = src[i++]
-    var Q = qhist[x][q]
-    model_qual[last].ModelEncode(out, rc, Q)
-    //console.log("Ctx",last,qhist[x][q])
-
-    // Update contexts for next quality
-    qlast = (qlast << params[x].qshift) + qtab[x][Q]
-    last = params[x].context
-    last += (qlast & ((1 << params[x].qbits) - 1)) << params[x].qloc
-
-    // 46.6-48.6 billion cycles with ifs + "<< params[x].?loc" shifts
-    // 47.3-47.3 billion cycles with ifs
-    // 47.1-47.9 billion cycles without ifs
-    if (params[x].pbits > 0)
-      last += ptab[x][Math.min(p, 1023)] << params[x].ploc
-
-    if (params[x].dbits > 0) {
-      last += dtab[x][Math.min(delta, 255)] << params[x].dloc
-      delta += q1 != Q ? 1 : 0
-      q1 = Q
-    }
-
-    if (params[x].do_sel) last += s << params[x].sloc
-
-    last = last & 0xffff
-    p--
-  }
-
-  rc.RangeFinishEncode(out)
-  return out.buf.slice(0, out.pos)
-}
-
-function encode(src, q_lens, q_dirs) {
-  var qhist = new Array(2)
-  var qtab = new Array(2)
-  var ptab = new Array(2)
-  var dtab = new Array(2)
-  var stab = new Array(256)
-
-  for (var s = 0; s < 2; s++) {
-    qhist[s] = new Array(256)
-    qtab[s] = new Array(256)
-    ptab[s] = new Array(1024)
-    dtab[s] = new Array(256)
-  }
-
-  var out = new IOStream('', 0, src.length * 1.1 + 100) // FIXME: guestimate worst case
-
-  out.WriteUint7(src.length)
-  var params = pick_fqz_params(src, q_lens, q_dirs, qhist)
-  var out = encode_fqz_params(out, params, qhist, qtab, ptab, dtab, stab)
-  return encode_fqz(
-    out,
-    src,
-    q_lens,
-    q_dirs,
-    params,
-    qhist,
-    qtab,
-    ptab,
-    dtab,
-    stab,
-  )
-}
-
-module.exports = { decode, encode }
+module.exports = { decode }

package/src/htscodecs/index.js

@@ -37,8 +37,6 @@
 // This JavaScript file is not part of the reference implementation
 // and is simply and interface to get a consistent interface for cram-js.
 
-'use strict'
-
 var r4x8 = require('./rans')
 var r4x16 = require('./rans4x16')
 var arith = require('./arith_gen')
@@ -46,28 +44,28 @@ var fqzcomp = require('./fqzcomp')
 var tok3 = require('./tok3')
 
 function r4x8_uncompress(inputBuffer, outputBuffer) {
-  r4x8.decode(inputBuffer).copy(outputBuffer, 0, 0)
+  return r4x8.decode(inputBuffer)
 }
 
-function r4x16_uncompress(inputBuffer, outputBuffer) {
-  r4x16.decode(inputBuffer).copy(outputBuffer, 0, 0)
+function r4x16_uncompress(inputBuffer) {
+  return r4x16.decode(inputBuffer)
 }
 
-function arith_uncompress(inputBuffer, outputBuffer) {
+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).copy(outputBuffer, 0, 0)
+  return new arith().decode(inputBuffer)
 }
 
-function fqzcomp_uncompress(inputBuffer, outputBuffer) {
+function fqzcomp_uncompress(inputBuffer) {
   var q_lens = new Array()
-  fqzcomp.decode(inputBuffer, q_lens).copy(outputBuffer, 0, 0)
+  return fqzcomp.decode(inputBuffer, q_lens)
 }
 
-function tok3_uncompress(inputBuffer, outputBuffer) {
+function tok3_uncompress(inputBuffer) {
   // Returns in string form instead of buffer
   var out = tok3.decode(inputBuffer, 0, '\0')
-  Buffer.from(out, 'binary').copy(outputBuffer, 0, 0)
+  return Uint8Array.from(Array.from(out).map(letter => letter.charCodeAt(0)))
 }
 
 module.exports = {

package/src/htscodecs/iostream.js

@@ -36,12 +36,13 @@
 module.exports = class IOStream {
   constructor(buf, start_pos = 0, size = 0) {
     if (size != 0) {
-      this.buf = Buffer.allocUnsafe(size)
+      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
   }
 
@@ -76,7 +77,7 @@ module.exports = class IOStream {
   }
 
   ReadUint32() {
-    const i = this.buf.readInt32LE(this.pos)
+    const i = this.dataView.getInt32(this.pos, true)
     this.pos += 4
     return i
   }