@gmod/cram 1.5.9 → 1.6.2

package/src/rans/frequencies.js

@@ -0,0 +1,121 @@
+import { CramMalformedError } from '../errors'
+
+import { TOTFREQ } from './constants'
+import Decoding from './decoding'
+
+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 {
+    if (decoder.fc[j] == null) {
+      decoder.fc[j] = new Decoding.FC()
+    }
+    decoder.fc[j].F = cp.get() & 0xff
+    if (decoder.fc[j].F >= 128) {
+      decoder.fc[j].F &= ~128
+      decoder.fc[j].F = ((decoder.fc[j].F & 127) << 8) | (cp.get() & 0xff)
+    }
+    decoder.fc[j].C = x
+
+    Decoding.symbolInit(syms[j], decoder.fc[j].C, decoder.fc[j].F)
+
+    /* Build reverse lookup table */
+    if (!decoder.R) {
+      decoder.R = new Array(TOTFREQ)
+    }
+    decoder.R.fill(j, x, x + decoder.fc[j].F)
+
+    x += decoder.fc[j].F
+
+    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 {
+      if (D[i].fc[j] == null) {
+        D[i].fc[j] = new Decoding.FC()
+      }
+      D[i].fc[j].F = 0xff & cp.get()
+      if (D[i].fc[j].F >= 128) {
+        D[i].fc[j].F &= ~128
+        D[i].fc[j].F = ((D[i].fc[j].F & 127) << 8) | (0xff & cp.get())
+      }
+      D[i].fc[j].C = x
+
+      if (D[i].fc[j].F === 0) {
+        D[i].fc[j].F = TOTFREQ
+      }
+
+      if (syms[i][j] == null) {
+        syms[i][j] = new Decoding.RansDecSymbol()
+      }
+
+      Decoding.symbolInit(syms[i][j], D[i].fc[j].C, D[i].fc[j].F)
+
+      /* Build reverse lookup table */
+      if (D[i].R == null) {
+        D[i].R = new Array(TOTFREQ)
+      }
+      D[i].R.fill(j, x, x + D[i].fc[j].F)
+
+      x += D[i].fc[j].F
+      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)
+}

package/src/rans/index.js

@@ -0,0 +1,249 @@
+import { CramMalformedError } from '../errors'
+
+import Decoding from './decoding'
+import { readStatsO0, readStatsO1 } from './frequencies'
+
+import D04 from './d04'
+import D14 from './d14'
+
+// const /* int */ ORDER_BYTE_LENGTH = 1
+// const /* int */ COMPRESSED_BYTE_LENGTH = 4
+const /* int */ RAW_BYTE_LENGTH = 4
+// const /* int */ PREFIX_BYTE_LENGTH =
+//   ORDER_BYTE_LENGTH + COMPRESSED_BYTE_LENGTH + RAW_BYTE_LENGTH
+
+// enum ORDER {
+//     ZERO, ONE;
+
+//     static ORDER fromInt(const /* int */ value) {
+//         try {
+//             return ORDER.values()[value];
+//         } catch (const ArrayIndexOutOfBoundsException e) {
+//             throw new RuntimeException("Unknown rANS order: " + value);
+//         }
+//     }
+// }
+
+// static ByteBuffer compress(const ByteBuffer input, const ORDER order, const ByteBuffer out) {
+//     if (input.remaining() == 0)
+//         return EMPTY_BUFFER;
+
+//     if (input.remaining() < 4)
+//         return encode_order0_way4(input, out);
+
+//     switch (order) {
+//         case ZERO:
+//             return encode_order0_way4(input, out);
+//         case ONE:
+//             return encode_order1_way4(input, out);
+
+//         default:
+//             throw new RuntimeException("Unknown rANS order: " + order);
+//     }
+// }
+
+// static /* ByteBuffer */ allocateIfNeeded(/* const int */ in_size,
+//                                            /* const ByteBuffer */ out_buf) {
+//     const /* int */ compressedSize = (/* int */) (1.05 * in_size + 257 * 257 * 3 + 4);
+//     if (out_buf == null)
+//         return ByteBuffer.allocate(compressedSize);
+//     if (out_buf.remaining() < compressedSize)
+//         throw new RuntimeException("Insufficient buffer size.");
+//     out_buf.order(ByteOrder.LITTLE_ENDIAN);
+//     return out_buf;
+// }
+
+// static ByteBuffer encode_order0_way4(const ByteBuffer input,
+//                                              ByteBuffer out_buf) {
+//     const /* int */ in_size = input.remaining();
+//     out_buf = allocateIfNeeded(in_size, out_buf);
+//     const /* int */ freqTableStart = PREFIX_BYTE_LENGTH;
+//     out_buf.position(freqTableStart);
+
+//     const /* int */[] F = Frequencies.calcFrequencies_o0(in);
+//     const RansEncSymbol[] syms = Frequencies.buildSyms_o0(F);
+
+//     const ByteBuffer cp = out_buf.slice();
+//     const /* int */ frequencyTable_size = Frequencies.writeFrequencies_o0(cp, F);
+
+//     input.rewind();
+//     const /* int */ compressedBlob_size = E04.compress(input, syms, cp);
+
+//     finalizeCompressed(0, out_buf, in_size, frequencyTable_size,
+//             compressedBlob_size);
+//     return out_buf;
+// }
+
+// static ByteBuffer encode_order1_way4(const ByteBuffer input,
+//                                              ByteBuffer out_buf) {
+//     const /* int */ in_size = input.remaining();
+//     out_buf = allocateIfNeeded(in_size, out_buf);
+//     const /* int */ freqTableStart = PREFIX_BYTE_LENGTH;
+//     out_buf.position(freqTableStart);
+
+//     const /* int */[][] F = Frequencies.calcFrequencies_o1(in);
+//     const RansEncSymbol[][] syms = Frequencies.buildSyms_o1(F);
+
+//     const ByteBuffer cp = out_buf.slice();
+//     const /* int */ frequencyTable_size = Frequencies.writeFrequencies_o1(cp, F);
+
+//     input.rewind();
+//     const /* int */ compressedBlob_size = E14.compress(input, syms, cp);
+
+//     finalizeCompressed(1, out_buf, in_size, frequencyTable_size,
+//             compressedBlob_size);
+//     return out_buf;
+// }
+
+// static void finalizeCompressed(const /* int */ order, const ByteBuffer out_buf,
+//                                        const /* int */ in_size, const /* int */ frequencyTable_size, const /* int */ compressedBlob_size) {
+//     out_buf.limit(PREFIX_BYTE_LENGTH + frequencyTable_size
+//             + compressedBlob_size);
+//     out_buf.put(0, (byte) order);
+//     out_buf.order(ByteOrder.LITTLE_ENDIAN);
+//     const /* int */ compressedSizeOffset = ORDER_BYTE_LENGTH;
+//     out_buf.putInt(compressedSizeOffset, frequencyTable_size
+//             + compressedBlob_size);
+//     const /* int */ rawSizeOffset = ORDER_BYTE_LENGTH + COMPRESSED_BYTE_LENGTH;
+//     out_buf.putInt(rawSizeOffset, in_size);
+//     out_buf.rewind();
+// }
+
+function /* static ByteBuffer */ uncompressOrder0Way4(
+  /* const ByteBuffer  */ input,
+  /* const ByteBuffer  */ out,
+) {
+  // input.order(ByteOrder.LITTLE_ENDIAN);
+  const D = new Decoding.AriDecoder()
+  const syms = new Array(256)
+  for (let i = 0; i < syms.length; i += 1) {
+    syms[i] = new Decoding.Symbol()
+  }
+
+  readStatsO0(input, D, syms)
+
+  D04(input, D, syms, out)
+
+  return out
+}
+
+function /* static ByteBuffer */ uncompressOrder1Way4(
+  /* const ByteBuffer */ input,
+  /* const ByteBuffer */ output,
+) {
+  const D = new Array(256)
+  for (let i = 0; i < D.length; i += 1) {
+    D[i] = new Decoding.AriDecoder()
+  }
+  const /* Decoding.RansDecSymbol[][]  */ syms = new Array(256)
+  for (let i = 0; i < syms.length; i += 1) {
+    syms[i] = new Array(256)
+    for (let j = 0; j < syms[i].length; j += 1) {
+      syms[i][j] = new Decoding.Symbol()
+    }
+  }
+  readStatsO1(input, D, syms)
+
+  D14(input, output, D, syms)
+
+  return output
+}
+
+/* compat layer to make a node buffer act like a java ByteBuffer */
+class ByteBuffer {
+  constructor(nodeBuffer, initialInputPosition = 0) {
+    this._buffer = nodeBuffer
+    this._position = initialInputPosition
+    this.length = nodeBuffer.length
+  }
+
+  get() {
+    const b = this._buffer[this._position]
+    this._position += 1
+    return b
+  }
+
+  getByte() {
+    return this.get()
+  }
+
+  getByteAt(position) {
+    return this._buffer[position]
+  }
+
+  position() {
+    return this._position
+  }
+
+  put(val) {
+    this._buffer[this._position] = val
+    this._position += 1
+    return val
+  }
+
+  putAt(position, val) {
+    this._buffer[position] = val
+    return val
+  }
+
+  setPosition(pos) {
+    this._position = pos
+    return pos
+  }
+
+  getInt() {
+    const i = this._buffer.readInt32LE(this._position)
+    this._position += 4
+    return i
+  }
+
+  remaining() {
+    return this._buffer.length - this._position
+  }
+}
+
+// static /* const */ ByteBuffer EMPTY_BUFFER = ByteBuffer.allocate(0);
+export default function uncompress(
+  inputBuffer,
+  outputBuffer,
+  initialInputPosition = 0,
+) {
+  if (inputBuffer.length === 0) {
+    outputBuffer.fill(0)
+    return outputBuffer
+  }
+
+  const input = new ByteBuffer(inputBuffer, initialInputPosition)
+  // input.order(ByteOrder.LITTLE_ENDIAN);
+
+  const order = input.get()
+  if (order !== 0 && order !== 1) {
+    throw new CramMalformedError(`Invalid rANS order ${order}`)
+  }
+
+  const /* int */ inputSize = input.getInt()
+  if (inputSize !== input.remaining() - RAW_BYTE_LENGTH) {
+    throw new CramMalformedError('Incorrect input length.')
+  }
+
+  const /* int */ outputSize = input.getInt()
+  const output = new ByteBuffer(outputBuffer || Buffer.allocUnsafe(outputSize))
+  // TODO output.limit(outputSize)
+
+  if (output.length < outputSize) {
+    throw new CramMalformedError(
+      `Output buffer too small to fit ${outputSize} bytes.`,
+    )
+  }
+
+  switch (order) {
+    case 0:
+      return uncompressOrder0Way4(input, output)
+
+    case 1:
+      return uncompressOrder1Way4(input, output)
+
+    default:
+      throw new CramMalformedError(`Invalid rANS order: ${order}`)
+  }
+}

package/src/sam.js

@@ -0,0 +1,15 @@
+export function parseHeaderText(text) {
+  const lines = text.split(/\r?\n/)
+  const data = []
+  lines.forEach(line => {
+    const [tag, ...fields] = line.split(/\t/)
+    const parsedFields = fields.map(f => {
+      const [fieldTag, value] = f.split(':', 2)
+      return { tag: fieldTag, value }
+    })
+    if (tag) {
+      data.push({ tag: tag.substr(1), data: parsedFields })
+    }
+  })
+  return data
+}

package/src/unzip-pako.ts

@@ -0,0 +1,5 @@
+import { inflate } from 'pako'
+
+export function unzip(input: Buffer) {
+  return Buffer.from(inflate(input))
+}

package/src/unzip.ts

@@ -0,0 +1,2 @@
+import { gunzipSync } from 'zlib'
+export { gunzipSync as unzip }