@gmod/cram 6.0.0 → 7.0.0

package/src/htscodecs/rans.ts

@@ -1,250 +0,0 @@
-/* eslint-disable no-var */
-// @ts-nocheck
-
-/*
- * Copyright (c) 2019-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.
- */
-
-import IOStream from './iostream.ts'
-
-// ----------------------------------------------------------------------
-// rANS primitives itself
-//
-// RansGet* is decoder side
-
-function RansGetCumulativeFreq(R) {
-  return R & 0xfff
-}
-
-function RansGetSymbolFromFreq(C, f) {
-  // NOTE: Inefficient.
-  // In practice we would implement this via a precomputed
-  // lookup table C2S[f]; see RansBuildC2S below.
-  let s = 0
-  while (f >= C[s + 1]) {
-    s++
-  }
-
-  return s
-}
-
-function RansBuildC2S(C) {
-  const C2S = new Array(0x1000)
-  let s = 0
-  for (let f = 0; f < 0x1000; f++) {
-    while (f >= C[s + 1]) {
-      s++
-    }
-    C2S[f] = s
-  }
-  return C2S
-}
-
-function RansAdvanceStep(R, c, f) {
-  return f * (R >> 12) + (R & 0xfff) - c
-}
-
-function RansRenorm(src, R) {
-  while (R < 1 << 23) {
-    R = (R << 8) + src.ReadByte()
-  }
-
-  return R
-}
-// ----------------------------------------------------------------------
-// Main rANS entry function: decodes a compressed src and
-// returns the uncompressed buffer.
-export function decode(src) {
-  const stream = new IOStream(src)
-  const order = stream.ReadByte()
-  const n_in = stream.ReadUint32()
-  const n_out = stream.ReadUint32()
-
-  return order == 0 ? RansDecode0(stream, n_out) : RansDecode1(stream, n_out)
-}
-
-// ----------------------------------------------------------------------
-// Order-0 decoder
-
-// Decode a single table of order-0 frequencies,
-// filling out the F and C arrays.
-function ReadFrequencies0(src, F, C) {
-  // Initialise; not in the specification - implicit?
-  for (var i = 0; i < 256; i++) {
-    F[i] = 0
-  }
-
-  let sym = src.ReadByte()
-  let last_sym = sym
-  let rle = 0
-
-  // Read F[]
-  do {
-    const f = src.ReadITF8()
-    F[sym] = f
-    if (rle > 0) {
-      rle--
-      sym++
-    } else {
-      sym = src.ReadByte()
-      if (sym == last_sym + 1) {
-        rle = src.ReadByte()
-      }
-    }
-    last_sym = sym
-  } while (sym != 0)
-
-  // Compute C[] from F[]
-  C[0] = 0
-  for (var i = 0; i <= 255; i++) {
-    C[i + 1] = C[i] + F[i]
-  }
-}
-
-function RansDecode0(src, nbytes) {
-  // Decode frequencies
-  const F = new Array(256)
-  const C = new Array(256)
-  ReadFrequencies0(src, F, C)
-
-  // Fast lookup to avoid slow RansGetSymbolFromFreq
-  const C2S = RansBuildC2S(C)
-
-  // Initialise rANS state
-  const R = new Array(4)
-  for (var i = 0; i < 4; i++) {
-    R[i] = src.ReadUint32()
-  }
-
-  // Main decode loop
-  const output = new Uint8Array(nbytes)
-  for (var i = 0; i < nbytes; i++) {
-    const i4 = i % 4
-    const f = RansGetCumulativeFreq(R[i4])
-    const s = C2S[f] // Equiv to RansGetSymbolFromFreq(C, f);
-
-    output[i] = s
-    R[i4] = RansAdvanceStep(R[i4], C[s], F[s])
-    R[i4] = RansRenorm(src, R[i4])
-  }
-
-  return output
-}
-
-// ----------------------------------------------------------------------
-// Order-1 decoder
-
-// Decode a table of order-1 frequencies,
-// filling out the F and C arrays.
-function ReadFrequencies1(src, F, C) {
-  // Initialise; not in the specification - implicit?
-  for (let i = 0; i < 256; i++) {
-    F[i] = new Array(256)
-    C[i] = new Array(256)
-    for (let j = 0; j < 256; j++) {
-      F[i][j] = 0
-    }
-  }
-
-  let sym = src.ReadByte()
-  let last_sym = sym
-  let rle = 0
-
-  // Read F[]
-  do {
-    ReadFrequencies0(src, F[sym], C[sym])
-
-    if (rle > 0) {
-      rle--
-      sym++
-    } else {
-      sym = src.ReadByte()
-      if (sym == last_sym + 1) {
-        rle = src.ReadByte()
-      }
-    }
-    last_sym = sym
-  } while (sym != 0)
-}
-
-function RansDecode1(src, nbytes) {
-  // Decode frequencies
-  const F = new Array(256)
-  const C = new Array(256)
-  ReadFrequencies1(src, F, C)
-
-  // Fast lookup to avoid slow RansGetSymbolFromFreq
-  const C2S = new Array(256)
-  for (var i = 0; i < 256; i++) {
-    C2S[i] = RansBuildC2S(C[i])
-  }
-
-  // Initialise rANS state
-  const R = new Array(4)
-  const L = new Array(4)
-  for (var j = 0; j < 4; j++) {
-    R[j] = src.ReadUint32()
-    L[j] = 0
-  }
-
-  // Main decode loop
-  const output = new Uint8Array(nbytes)
-  const nbytes4 = Math.floor(nbytes / 4)
-  for (var i = 0; i < nbytes4; i++) {
-    for (var j = 0; j < 4; j++) {
-      var f = RansGetCumulativeFreq(R[j])
-
-      // var s = RansGetSymbolFromFreq(C[L[j]], f);
-      var s = C2S[L[j]][f] // Precomputed version of above
-
-      output[i + j * nbytes4] = s
-      R[j] = RansAdvanceStep(R[j], C[L[j]][s], F[L[j]][s])
-      R[j] = RansRenorm(src, R[j])
-      L[j] = s
-    }
-  }
-
-  // Now deal with the remainder if buffer size is not a multiple of 4,
-  // using rANS state 3 exclusively.  (It'd have been nice to have
-  // designed this to just act as if we kept going with a bail out.)
-  i = 4 * i
-  while (i < nbytes) {
-    var f = RansGetCumulativeFreq(R[3])
-    var s = RansGetSymbolFromFreq(C[L[3]], f)
-    output[i++] = s
-    R[3] = RansAdvanceStep(R[3], C[L[3]][s], F[L[3]][s])
-    R[3] = RansRenorm(src, R[3])
-    L[3] = s
-  }
-
-  return output
-}