@gmod/cram 6.0.0 → 7.0.0

package/src/rans/d04.ts

@@ -1,112 +0,0 @@
-// @ts-nocheck
-import { CramMalformedError } from '../errors.ts'
-import { TF_SHIFT } from './constants.ts'
-import Decoding from './decoding.ts'
-
-// Inline constants for performance
-const RANS_BYTE_L = 8388608 // 1 << 23
-const MASK = 4095 // (1 << 12) - 1
-
-export default function uncompress(
-  /* ByteBuffer */ input,
-  /* Decoding.AriDecoder */ D,
-  /* Decoding.Symbol[] */ syms,
-  /* ByteBuffer */ out,
-) {
-  let rans0 = input.getInt()
-  let rans1 = input.getInt()
-  let rans2 = input.getInt()
-  let rans3 = input.getInt()
-
-  const /* int */ outputSize = out.remaining()
-  const /* int */ outputEnd = outputSize & ~3
-  const D_R = D.R
-
-  for (let i = 0; i < outputEnd; i += 4) {
-    const /* byte */ c0 = D_R[rans0 & MASK]
-    const /* byte */ c1 = D_R[rans1 & MASK]
-    const /* byte */ c2 = D_R[rans2 & MASK]
-    const /* byte */ c3 = D_R[rans3 & MASK]
-
-    // Inline putAt to avoid function call overhead
-    out._buffer[i] = c0
-    out._buffer[i + 1] = c1
-    out._buffer[i + 2] = c2
-    out._buffer[i + 3] = c3
-
-    const sym0 = syms[0xff & c0]
-    const sym1 = syms[0xff & c1]
-    const sym2 = syms[0xff & c2]
-    const sym3 = syms[0xff & c3]
-
-    rans0 = sym0.freq * (rans0 >> TF_SHIFT) + (rans0 & MASK) - sym0.start
-    rans1 = sym1.freq * (rans1 >> TF_SHIFT) + (rans1 & MASK) - sym1.start
-    rans2 = sym2.freq * (rans2 >> TF_SHIFT) + (rans2 & MASK) - sym2.start
-    rans3 = sym3.freq * (rans3 >> TF_SHIFT) + (rans3 & MASK) - sym3.start
-
-    // Inline renormalize to avoid function call overhead
-    if (rans0 < RANS_BYTE_L) {
-      do {
-        rans0 = (rans0 << 8) | (0xff & input.get())
-      } while (rans0 < RANS_BYTE_L)
-    }
-    if (rans1 < RANS_BYTE_L) {
-      do {
-        rans1 = (rans1 << 8) | (0xff & input.get())
-      } while (rans1 < RANS_BYTE_L)
-    }
-    if (rans2 < RANS_BYTE_L) {
-      do {
-        rans2 = (rans2 << 8) | (0xff & input.get())
-      } while (rans2 < RANS_BYTE_L)
-    }
-    if (rans3 < RANS_BYTE_L) {
-      do {
-        rans3 = (rans3 << 8) | (0xff & input.get())
-      } while (rans3 < RANS_BYTE_L)
-    }
-  }
-
-  out.setPosition(outputEnd)
-  let /* byte */ c: number
-  switch (outputSize & 3) {
-    case 0:
-      break
-    case 1:
-      c = D.R[Decoding.get(rans0, TF_SHIFT)]
-      Decoding.advanceSymbol(rans0, input, syms[0xff & c], TF_SHIFT)
-      out.put(c)
-      break
-
-    case 2:
-      c = D.R[Decoding.get(rans0, TF_SHIFT)]
-      Decoding.advanceSymbol(rans0, input, syms[0xff & c], TF_SHIFT)
-      out.put(c)
-
-      c = D.R[Decoding.get(rans1, TF_SHIFT)]
-      Decoding.advanceSymbol(rans1, input, syms[0xff & c], TF_SHIFT)
-      out.put(c)
-      break
-
-    case 3:
-      c = D.R[Decoding.get(rans0, TF_SHIFT)]
-      Decoding.advanceSymbol(rans0, input, syms[0xff & c], TF_SHIFT)
-      out.put(c)
-
-      c = D.R[Decoding.get(rans1, TF_SHIFT)]
-      Decoding.advanceSymbol(rans1, input, syms[0xff & c], TF_SHIFT)
-      out.put(c)
-
-      c = D.R[Decoding.get(rans2, TF_SHIFT)]
-      Decoding.advanceSymbol(rans2, input, syms[0xff & c], TF_SHIFT)
-      out.put(c)
-      break
-
-    default:
-      throw new CramMalformedError(
-        'invalid output size encountered during rANS decoding',
-      )
-  }
-
-  out.setPosition(0)
-}

package/src/rans/d14.ts

@@ -1,106 +0,0 @@
-// @ts-nocheck
-import { TF_SHIFT } from './constants.ts'
-
-// Inline constants for performance
-const RANS_BYTE_L = 8388608 // 1 << 23
-const MASK = 4095 // (1 << 12) - 1
-
-export default function uncompress(
-  /* ByteBuffer */ input,
-  /* ByteBuffer */ output,
-  /* Decoding.AriDecoder[] */ D,
-  /* Decoding.Symbol[][] */ syms,
-) {
-  const /* int */ outputSize = output.remaining()
-  let rans0 = input.getInt()
-  let rans1 = input.getInt()
-  let rans2 = input.getInt()
-  let rans7 = input.getInt()
-
-  const /* int */ isz4 = outputSize >> 2
-  let /* int */ i0 = 0
-  let /* int */ i1 = isz4
-  let /* int */ i2 = 2 * isz4
-  let /* int */ i7 = 3 * isz4
-  let /* int */ l0 = 0
-  let /* int */ l1 = 0
-  let /* int */ l2 = 0
-  let /* int */ l7 = 0
-
-  for (; i0 < isz4; i0 += 1, i1 += 1, i2 += 1, i7 += 1) {
-    const D_l0_R = D[l0].R
-    const D_l1_R = D[l1].R
-    const D_l2_R = D[l2].R
-    const D_l7_R = D[l7].R
-
-    const /* int */ c0 = 0xff & D_l0_R[rans0 & MASK]
-    const /* int */ c1 = 0xff & D_l1_R[rans1 & MASK]
-    const /* int */ c2 = 0xff & D_l2_R[rans2 & MASK]
-    const /* int */ c7 = 0xff & D_l7_R[rans7 & MASK]
-
-    // Inline putAt to avoid function call overhead
-    output._buffer[i0] = c0
-    output._buffer[i1] = c1
-    output._buffer[i2] = c2
-    output._buffer[i7] = c7
-
-    const sym_l0_c0 = syms[l0][c0]
-    const sym_l1_c1 = syms[l1][c1]
-    const sym_l2_c2 = syms[l2][c2]
-    const sym_l7_c7 = syms[l7][c7]
-
-    rans0 =
-      sym_l0_c0.freq * (rans0 >> TF_SHIFT) + (rans0 & MASK) - sym_l0_c0.start
-    rans1 =
-      sym_l1_c1.freq * (rans1 >> TF_SHIFT) + (rans1 & MASK) - sym_l1_c1.start
-    rans2 =
-      sym_l2_c2.freq * (rans2 >> TF_SHIFT) + (rans2 & MASK) - sym_l2_c2.start
-    rans7 =
-      sym_l7_c7.freq * (rans7 >> TF_SHIFT) + (rans7 & MASK) - sym_l7_c7.start
-
-    // Inline renormalize to avoid function call overhead
-    if (rans0 < RANS_BYTE_L) {
-      do {
-        rans0 = (rans0 << 8) | (0xff & input.get())
-      } while (rans0 < RANS_BYTE_L)
-    }
-    if (rans1 < RANS_BYTE_L) {
-      do {
-        rans1 = (rans1 << 8) | (0xff & input.get())
-      } while (rans1 < RANS_BYTE_L)
-    }
-    if (rans2 < RANS_BYTE_L) {
-      do {
-        rans2 = (rans2 << 8) | (0xff & input.get())
-      } while (rans2 < RANS_BYTE_L)
-    }
-    if (rans7 < RANS_BYTE_L) {
-      do {
-        rans7 = (rans7 << 8) | (0xff & input.get())
-      } while (rans7 < RANS_BYTE_L)
-    }
-
-    l0 = c0
-    l1 = c1
-    l2 = c2
-    l7 = c7
-  }
-
-  // Remainder
-  for (; i7 < outputSize; i7 += 1) {
-    const /* int */ c7 = 0xff & D[l7].R[rans7 & MASK]
-    // Inline putAt to avoid function call overhead
-    output._buffer[i7] = c7
-
-    // Inline advanceSymbol to avoid function call overhead
-    const sym = syms[l7][c7]
-    rans7 = sym.freq * (rans7 >> TF_SHIFT) + (rans7 & MASK) - sym.start
-    if (rans7 < RANS_BYTE_L) {
-      do {
-        rans7 = (rans7 << 8) | (0xff & input.get())
-      } while (rans7 < RANS_BYTE_L)
-    }
-
-    l7 = c7
-  }
-}

package/src/rans/decoding.ts

@@ -1,138 +0,0 @@
-// @ts-nocheck
-import { CramMalformedError } from '../errors.ts'
-import { RANS_BYTE_L } from './constants.ts'
-
-class FC {
-  // int F, C;
-  constructor() {
-    this.F = undefined
-    this.C = undefined
-  }
-}
-
-class AriDecoder {
-  // final FC[] fc = new FC[256];
-  // byte[] R;
-
-  constructor() {
-    // Use two parallel arrays instead of array of objects for better cache efficiency
-    this.fcF = new Array(256)
-    this.fcC = new Array(256)
-    this.R = null
-  }
-}
-
-class DecodingSymbol {
-  // int start; // Start of range.
-  // int freq; // Symbol frequency.
-  constructor() {
-    this.start = undefined
-    this.freq = undefined
-  }
-}
-
-// Initialize a decoder symbol to start "start" and frequency "freq"
-function symbolInit(sym, start, freq) {
-  if (!(start <= 1 << 16)) {
-    throw new CramMalformedError('assertion failed: start <= 1<<16')
-  }
-  if (!(freq <= (1 << 16) - start)) {
-    throw new CramMalformedError('assertion failed: freq <= 1<<16')
-  }
-  sym.start = start
-  sym.freq = freq
-}
-
-// Advances in the bit stream by "popping" a single symbol with range start
-// "start" and frequency "freq". All frequencies are assumed to sum to
-// "1 << scaleBits".
-// No renormalization or output happens.
-/* private static int */ function advanceStep(
-  /* final int */ r,
-  /* final int */ start,
-  /* final int */ freq,
-  /* final int */ scaleBits,
-) {
-  /* final int */ const mask = (1 << scaleBits) - 1
-
-  // s, x = D(x)
-  return freq * (r >> scaleBits) + (r & mask) - start
-}
-
-// Equivalent to RansDecAdvanceStep that takes a symbol.
-/* static int  */ function advanceSymbolStep(
-  /* final int */ r,
-  /* final RansDecSymbol */ sym,
-  /* final int */ scaleBits,
-) {
-  return advanceStep(r, sym.start, sym.freq, scaleBits)
-}
-
-// Returns the current cumulative frequency (map it to a symbol yourself!)
-/* static int */ function get(/* final int */ r, /* final int */ scaleBits) {
-  return r & ((1 << scaleBits) - 1)
-}
-
-// Advances in the bit stream by "popping" a single symbol with range start
-// "start" and frequency "freq". All frequencies are assumed to sum to
-// "1 << scaleBits",
-// and the resulting bytes get written to ptr (which is updated).
-/* private static int */ function advance(
-  /* int */ r,
-  /* final ByteBuffer */ pptr,
-  /* final int */ start,
-  /* final int */ freq,
-  /* final int */ scaleBits,
-) {
-  /* final int */ const mask = (1 << scaleBits) - 1
-
-  // s, x = D(x)
-  r = freq * (r >> scaleBits) + (r & mask) - start
-
-  // re-normalize
-  if (r < RANS_BYTE_L) {
-    do {
-      /* final int */ const b = 0xff & pptr.get()
-      r = (r << 8) | b
-    } while (r < RANS_BYTE_L)
-  }
-
-  return r
-}
-
-// Equivalent to RansDecAdvance that takes a symbol.
-/*  static int */ function advanceSymbol(
-  /* final int */ r,
-  /* final ByteBuffer */ pptr,
-  /* final RansDecSymbol */ sym,
-  /* final int */ scaleBits,
-) {
-  return advance(r, pptr, sym.start, sym.freq, scaleBits)
-}
-
-// Re-normalize.
-/*  static int */ function renormalize(
-  /* int */ r,
-  /* final ByteBuffer */ pptr,
-) {
-  // re-normalize
-  if (r < RANS_BYTE_L) {
-    do {
-      r = (r << 8) | (0xff & pptr.get())
-    } while (r < RANS_BYTE_L)
-  }
-
-  return r
-}
-
-export default {
-  FC,
-  AriDecoder,
-  DecodingSymbol,
-  symbolInit,
-  advanceStep,
-  advanceSymbolStep,
-  get,
-  advanceSymbol,
-  renormalize,
-}

package/src/rans/frequencies.ts

@@ -1,115 +0,0 @@
-// @ts-nocheck
-import { CramMalformedError } from '../errors.ts'
-import { TOTFREQ } from './constants.ts'
-import Decoding from './decoding.ts'
-
-function assert(result) {
-  if (!result) {
-    throw new CramMalformedError('assertion failed')
-  }
-}
-
-export function readStatsO0(
-  /* ByteBuffer */ cp,
-  /* Decoding.AriDecoder */ decoder,
-  /* Decoding.RansDecSymbol[] */ syms,
-) {
-  // Pre-compute reverse lookup of frequency.
-  let rle = 0
-  let x = 0
-  let j = cp.get() & 0xff
-  do {
-    decoder.fcF[j] = cp.get() & 0xff
-    if (decoder.fcF[j] >= 128) {
-      decoder.fcF[j] &= ~128
-      decoder.fcF[j] = ((decoder.fcF[j] & 127) << 8) | (cp.get() & 0xff)
-    }
-    decoder.fcC[j] = x
-
-    Decoding.symbolInit(syms[j], decoder.fcC[j], decoder.fcF[j])
-
-    /* Build reverse lookup table */
-    if (!decoder.R) {
-      decoder.R = new Array(TOTFREQ)
-    }
-    decoder.R.fill(j, x, x + decoder.fcF[j])
-
-    x += decoder.fcF[j]
-
-    if (rle === 0 && j + 1 === (0xff & cp.getByteAt(cp.position()))) {
-      j = cp.get() & 0xff
-      rle = cp.get() & 0xff
-    } else if (rle !== 0) {
-      rle -= 1
-      j += 1
-    } else {
-      j = cp.get() & 0xff
-    }
-  } while (j !== 0)
-
-  assert(x < TOTFREQ)
-}
-
-export function readStatsO1(
-  /* ByteBuffer */ cp,
-  /*  Decoding.AriDecoder[] */ D,
-  /* Decoding.RansDecSymbol[][] */ syms,
-) {
-  let rlei = 0
-  let i = 0xff & cp.get()
-  do {
-    let rlej = 0
-    let x = 0
-    let j = 0xff & cp.get()
-    if (D[i] == null) {
-      D[i] = new Decoding.AriDecoder()
-    }
-    do {
-      D[i].fcF[j] = 0xff & cp.get()
-      if (D[i].fcF[j] >= 128) {
-        D[i].fcF[j] &= ~128
-        D[i].fcF[j] = ((D[i].fcF[j] & 127) << 8) | (0xff & cp.get())
-      }
-      D[i].fcC[j] = x
-
-      if (D[i].fcF[j] === 0) {
-        D[i].fcF[j] = TOTFREQ
-      }
-
-      if (syms[i][j] == null) {
-        syms[i][j] = new Decoding.RansDecSymbol()
-      }
-
-      Decoding.symbolInit(syms[i][j], D[i].fcC[j], D[i].fcF[j])
-
-      /* Build reverse lookup table */
-      if (D[i].R == null) {
-        D[i].R = new Array(TOTFREQ)
-      }
-      D[i].R.fill(j, x, x + D[i].fcF[j])
-
-      x += D[i].fcF[j]
-      assert(x <= TOTFREQ)
-
-      if (rlej === 0 && j + 1 === (0xff & cp.getByteAt(cp.position()))) {
-        j = 0xff & cp.get()
-        rlej = 0xff & cp.get()
-      } else if (rlej !== 0) {
-        rlej -= 1
-        j += 1
-      } else {
-        j = 0xff & cp.get()
-      }
-    } while (j !== 0)
-
-    if (rlei === 0 && i + 1 === (0xff & cp.getByteAt(cp.position()))) {
-      i = 0xff & cp.get()
-      rlei = 0xff & cp.get()
-    } else if (rlei !== 0) {
-      rlei -= 1
-      i += 1
-    } else {
-      i = 0xff & cp.get()
-    }
-  } while (i !== 0)
-}