Signed-off-by: mihaisc <mihai.scarlat@smartcontrol.ro>
pull/226/head
mihaisc 1 year ago
parent d8c0d1c9ae
commit 4ac408de51
No known key found for this signature in database
GPG Key ID: 4FB0C2329B4C6E29
  1. 33
      .eslintrc
  2. 35
      .prettierrc
  3. 36
      schema.graphql
  4. 42
      src/lzma/bit-tree-decoder.ts
  5. 42
      src/lzma/len-decoder.ts
  6. 312
      src/lzma/lzma-decoder.ts
  7. 43
      src/lzma/lzma-helper.ts
  8. 36
      src/lzma/lzma-worker.ts
  9. 135
      src/lzma/lzma.ts
  10. 92
      src/lzma/out-window.ts
  11. 96
      src/lzma/range-decoder.ts

@ -1,27 +1,14 @@
{
"parser": "@typescript-eslint/parser",
"root": true,
"extends": [
"eslint:recommended",
"plugin:@typescript-eslint/recommended"
],
"plugins": [
"@typescript-eslint"
],
"parserOptions": {
"project": ["./tsconfig.json"]
},
"extends": ["oceanprotocol", "plugin:prettier/recommended"],
"plugins": ["@typescript-eslint"],
"rules": {
"comma-spacing": [
"error",
{
"before": false,
"after": true
}
],
"prefer-const": [
"off"
],
"prettier/prettier": "error",
"mocha-no-only/mocha-no-only": [
"error"
],
"no-use-before-define": "off",
"eqeqeq": "off",
"@typescript-eslint/no-use-before-define": "error",
"no-undef": ["warn"]
}
}
}

@ -1,31 +1,6 @@
{
"overrides": [
{
"files": "*.sol",
"options": {
"bracketSpacing": true,
"explicitTypes": "always",
"printWidth": 120,
"singleQuote": false,
"tabWidth": 4,
"useTabs": false
}
},
{
"files": "*.ts",
"options": {
"bracketSpacing": true,
"explicitTypes": "always",
"newline-before-return": true,
"no-duplicate-variable": [true, "check-parameters"],
"no-var-keyword": true,
"printWidth": 120,
"semi": true,
"singleQuote": true,
"tabWidth": 2,
"trailingComma": "es5",
"useTabs": false
}
}
]
}
"semi": false,
"singleQuote": true,
"trailingComma": "none",
"tabWidth": 2
}

@ -235,7 +235,7 @@ type Dispenser @entity {
type DispenserTransaction @entity {
id: ID!
dispenserId: Dispenser!
datatoken: Datatoken!
datatoken: Token!
user: User!
amount: BigDecimal!
block: Int!
@ -246,11 +246,11 @@ type DispenserTransaction @entity {
type PoolSnapshotTokenValue @entity {
id: ID! # pool tx + tokenAddress
tokenAddress: String!
value: BigDecimal!
id: ID! # pool tx + tokenAddress
token: Token!
value: BigDecimal!
tokenReserve: BigDecimal!
feeValue: BigDecimal! # Swap fee value in OCEAN
feeValue: BigDecimal! # Swap fee value in OCEAN
type: String!
poolSnapshot: PoolSnapshot!
}
@ -260,13 +260,15 @@ type PoolSnapshot @entity {
id: ID!
pool: Pool!
totalShares: BigDecimal!
swapVolume: BigDecimal!
swapFees: BigDecimal!
timestamp: Int!
swapVolume: BigDecimal! # swap value 24h
swapFees: BigDecimal! # swap fee value 24h
timestamp: Int! # date without time
spotPrice: BigDecimal! # TODO: last spot price or first one?
tokens: [PoolSnapshotTokenValue!] @derivedFrom(field: "poolSnapshot")
}
// shouldn't we move this to aquarius?
type MetadataUpdate @entity {
id: ID! # update tx + datatokenAddress
datatokenId: Datatoken!
@ -274,27 +276,9 @@ type MetadataUpdate @entity {
datatokenAddress: String!
userAddress: String!
//all fields from the market edit
name
description
author
links
timeout
block: Int!
timestamp: Int!
tx: Bytes!
}
type Asset {
did
name
description
author
services ? [ access, compute ] ?
datatoken : Datatoken
}

@ -1,42 +0,0 @@
import { RangeDecoder } from './range-decoder';
import { LZMA } from './lzma';
/**
* LZMA Decoder
* @author Nidin Vinayakan
*/
export class BitTreeDecoder {
public probs: Uint16Array
private numBits: u32
constructor(numBits:u32) {
this.numBits = numBits
this.probs = new Uint16Array(1 << this.numBits)
}
@inline
public init(): void {
LZMA.INIT_PROBS(this.probs)
}
@inline
public decode(rc: RangeDecoder): u32 {
var m: u32 = 1
for (var i: u32 = 0; i < this.numBits; i++) m = (m << 1) + rc.decodeBit(this.probs, m)
return m - (1 << this.numBits)
}
@inline
public reverseDecode(rc: RangeDecoder): i32 {
return LZMA.BitTreeReverseDecode(this.probs, this.numBits, rc)
}
@inline
static constructArray(numBits: i32, len: i32): Array<BitTreeDecoder> {
var vec: BitTreeDecoder[] = new Array<BitTreeDecoder>(len)
for (var i: i32 = 0; i < len; i++) {
vec.__unchecked_set(i, new BitTreeDecoder(numBits))
}
return vec
}
}

@ -1,42 +0,0 @@
import { BitTreeDecoder } from './bit-tree-decoder'
import { LZMA } from './lzma'
import { RangeDecoder } from './range-decoder'
/**
* LZMA Decoder
* @author Nidin Vinayakan
*/
export class LenDecoder {
private choice: Uint16Array
private lowCoder: Array<BitTreeDecoder>
private midCoder: Array<BitTreeDecoder>
private highCoder: BitTreeDecoder
constructor() {
this.lowCoder = BitTreeDecoder.constructArray(3, 1 << LZMA.kNumPosBitsMax)
this.midCoder = BitTreeDecoder.constructArray(3, 1 << LZMA.kNumPosBitsMax)
this.highCoder = new BitTreeDecoder(8)
}
public init(): void {
this.choice = new Uint16Array(2)
this.choice.__unchecked_set(0, LZMA.PROB_INIT_VAL)
this.choice.__unchecked_set(1, LZMA.PROB_INIT_VAL)
this.highCoder.init()
for (var i: i32 = 0; i < 1 << LZMA.kNumPosBitsMax; i++) {
this.lowCoder[i].init()
this.midCoder[i].init()
}
}
public decode(rc: RangeDecoder, posState: i32): i32 {
if (rc.decodeBit(this.choice, 0) == 0) {
return this.lowCoder[posState].decode(rc)
}
if (rc.decodeBit(this.choice, 1) == 0) {
return 8 + this.midCoder[posState].decode(rc)
}
return 16 + this.highCoder.decode(rc)
}
}

@ -1,312 +0,0 @@
import { RangeDecoder } from './range-decoder';
import { OutWindow } from './out-window';
import { BitTreeDecoder } from './bit-tree-decoder';
import { LenDecoder } from './len-decoder';
import { LZMA } from './lzma';
/**
* LZMA Decoder
* @author Nidin Vinayakan
*/
export class LzmaDecoder {
//Public
public markerIsMandatory: boolean
public rangeDec: RangeDecoder //RangeDecoder
public outWindow: OutWindow //OutWindow
public lc: i32
public pb: i32
public lp: u8
public dictSize: u32
public dictSizeInProperties: u32
//Private
private litProbs: Uint16Array
private posSlotDecoder: Array<BitTreeDecoder>
private alignDecoder: BitTreeDecoder
private posDecoders: Uint16Array
private isMatch: Uint16Array
private isRep: Uint16Array
private isRepG0: Uint16Array
private isRepG1: Uint16Array
private isRepG2: Uint16Array
private isRep0Long: Uint16Array
private lenDecoder: LenDecoder
private repLenDecoder: LenDecoder
constructor() {
this.posSlotDecoder = BitTreeDecoder.constructArray(6, LZMA.kNumLenToPosStates) //6
this.alignDecoder = new BitTreeDecoder(LZMA.kNumAlignBits)
this.posDecoders = new Uint16Array(1 + LZMA.kNumFullDistances - LZMA.kEndPosModelIndex)
this.isMatch = new Uint16Array(LZMA.kNumStates << LZMA.kNumPosBitsMax)
this.isRep = new Uint16Array(LZMA.kNumStates)
this.isRepG0 = new Uint16Array(LZMA.kNumStates)
this.isRepG1 = new Uint16Array(LZMA.kNumStates)
this.isRepG2 = new Uint16Array(LZMA.kNumStates)
this.isRep0Long = new Uint16Array(LZMA.kNumStates << LZMA.kNumPosBitsMax)
this.lenDecoder = new LenDecoder()
this.repLenDecoder = new LenDecoder()
this.rangeDec = new RangeDecoder()
this.outWindow = new OutWindow()
}
public init(): void {
this.initLiterals()
this.initDist()
LZMA.INIT_PROBS(this.isMatch)
LZMA.INIT_PROBS(this.isRep)
LZMA.INIT_PROBS(this.isRepG0)
LZMA.INIT_PROBS(this.isRepG1)
LZMA.INIT_PROBS(this.isRepG2)
LZMA.INIT_PROBS(this.isRep0Long)
this.lenDecoder.init()
this.repLenDecoder.init()
}
public create(): void {
this.outWindow.create(this.dictSize)
this.createLiterals()
}
@inline
private createLiterals(): void {
this.litProbs = new Uint16Array(0x300 << (this.lc + this.lp))
}
@inline
private initLiterals(): void {
var num: i32 = 0x300 << (this.lc + this.lp)
for (var i: i32 = 0; i < num; i++) {
this.litProbs.__unchecked_set(i, LZMA.PROB_INIT_VAL)
}
}
@inline
private decodeLiteral(state:u16, rep0:u32): void {
var prevByte:u32 = 0
if (!this.outWindow.isEmpty()) prevByte = this.outWindow.getByte(1)
var symbol:u16 = 1
var litState:u32 =
((this.outWindow.totalPos & ((1 << this.lp) - 1)) << this.lc) +
(prevByte >>> (8 - this.lc))
var probsOffset: i32 = (0x300 * litState) | 0
if (state >= 7) {
let matchByte = this.outWindow.getByte(rep0 + 1)
do {
let matchBit = (matchByte >>> 7) & 1
matchByte <<= 1
let bit = this.rangeDec.decodeBit(
this.litProbs,
probsOffset + ((1 + matchBit) << 8) + symbol,
)
symbol = (symbol << 1) | bit
if (matchBit != bit) break
} while (symbol < 0x100)
}
while (symbol < 0x100) {
symbol =
(symbol << 1) |
this.rangeDec.decodeBit(this.litProbs, probsOffset + symbol)
}
this.outWindow.putByte(<u8>(symbol - 0x100))
}
private decodeDistance(len: i32): u32 {
var lenState: u32 = <u32>len
if (lenState > LZMA.kNumLenToPosStates - 1) lenState = LZMA.kNumLenToPosStates - 1
var posSlot:u32 = this.posSlotDecoder[lenState].decode(this.rangeDec)
if (posSlot < 4) return posSlot
var numDirectBits:u32 = (posSlot >>> 1) - 1
var dist:u32 = (2 | (posSlot & 1)) << numDirectBits
if (posSlot < LZMA.kEndPosModelIndex) {
dist += LZMA.BitTreeReverseDecode(
this.posDecoders,
numDirectBits,
this.rangeDec,
dist - posSlot,
)
} else {
dist +=
this.rangeDec.decodeDirectBits(numDirectBits - LZMA.kNumAlignBits) << LZMA.kNumAlignBits
dist += this.alignDecoder.reverseDecode(this.rangeDec)
}
return dist
}
@inline
private initDist(): void {
for (var i:u32 = 0; i < LZMA.kNumLenToPosStates; i++) {
this.posSlotDecoder[i].init()
}
this.alignDecoder.init()
LZMA.INIT_PROBS(this.posDecoders)
}
@inline
public decodeProperties(properties: Uint8Array): void {
var prop = new Uint8Array(4)
var p0 = properties.__unchecked_get(0)
prop.__unchecked_set(0, p0)
if (p0 >= 9 * 5 * 5) {
throw 1
// throw 'Incorrect LZMA properties'
}
var p1 = p0 % 9
prop.__unchecked_set(1, p1)
p0 /= 9
prop.__unchecked_set(0, p0)
var p2 = p0 / 5
var p3 = p0 % 5
prop.__unchecked_set(2, p2)
prop.__unchecked_set(3, p3)
this.lc = p1
this.pb = p2
this.lp = p3
this.dictSizeInProperties = 0
for (var i: u32 = 0; i < 4; i++) {
this.dictSizeInProperties |= <u32>properties.__unchecked_get(i + 1) << (8 * i)
}
this.dictSize = this.dictSizeInProperties
if (this.dictSize < LZMA.LZMA_DIC_MIN) {
this.dictSize = LZMA.LZMA_DIC_MIN
}
}
@inline
private updateState_Literal(state: u8): u8 {
if (state < 4) return 0
else if (state < 10) return state - 3
else return state - 6
}
@inline
private updateState_ShortRep(state: u8): u8 {
return state < 7 ? 9 : 11
}
@inline
private updateState_Rep(state: u8): u8 {
return state < 7 ? 8 : 11
}
@inline
private updateState_Match(state: u8): u8 {
return state < 7 ? 7 : 10
}
public decode(unpackSizeDefined: boolean, unpackSize: i32): i32 {
this.init()
this.rangeDec.init()
if (unpackSizeDefined) {
this.outWindow.outStream = new Uint8Array(unpackSize)
} else {
this.outWindow.outStream = new Uint8Array(4)
}
var rep0:u32 = 0,
rep1:u32 = 0,
rep2:u32 = 0,
rep3:u32 = 0
var state:u8 = 0
for (;;) {
if (unpackSizeDefined && unpackSize == 0 && !this.markerIsMandatory) {
if (this.rangeDec.isFinishedOK()) {
return LZMA.LZMA_RES_FINISHED_WITHOUT_MARKER
}
}
var posState = this.outWindow.totalPos & ((1 << this.pb) - 1)
if (this.rangeDec.decodeBit(this.isMatch, (state << LZMA.kNumPosBitsMax) + posState) == 0) {
if (unpackSizeDefined && unpackSize == 0) {
return LZMA.LZMA_RES_ERROR
}
this.decodeLiteral(state, rep0)
state = this.updateState_Literal(state)
unpackSize--
continue
}
var len: i32
if (this.rangeDec.decodeBit(this.isRep, state) != 0) {
if (unpackSizeDefined && unpackSize == 0) {
return LZMA.LZMA_RES_ERROR
}
if (this.outWindow.isEmpty()) {
return LZMA.LZMA_RES_ERROR
}
if (this.rangeDec.decodeBit(this.isRepG0, state) == 0) {
if (this.rangeDec.decodeBit(this.isRep0Long, (state << LZMA.kNumPosBitsMax) + posState) == 0) {
state = this.updateState_ShortRep(state)
this.outWindow.putByte(this.outWindow.getByte(rep0 + 1))
unpackSize--
continue
}
} else {
var dist: i32
if (this.rangeDec.decodeBit(this.isRepG1, state) == 0) {
dist = rep1
} else {
if (this.rangeDec.decodeBit(this.isRepG2, state) == 0) {
dist = rep2
} else {
dist = rep3
rep3 = rep2
}
rep2 = rep1
}
rep1 = rep0
rep0 = dist
}
len = this.repLenDecoder.decode(this.rangeDec, posState)
state = this.updateState_Rep(state)
} else {
rep3 = rep2
rep2 = rep1
rep1 = rep0
len = this.lenDecoder.decode(this.rangeDec, posState)
state = this.updateState_Match(state)
rep0 = this.decodeDistance(len)
if (rep0 == 0xffffffff) {
return this.rangeDec.isFinishedOK() ? LZMA.LZMA_RES_FINISHED_WITH_MARKER : LZMA.LZMA_RES_ERROR
}
if (unpackSizeDefined && unpackSize == 0) {
return LZMA.LZMA_RES_ERROR
}
if (rep0 >= this.dictSize || !this.outWindow.checkDistance(rep0)) {
return LZMA.LZMA_RES_ERROR
}
}
len += LZMA.kMatchMinLen
var isError: boolean = false
if (unpackSizeDefined && unpackSize < len) {
len = unpackSize
isError = true
}
this.outWindow.copyMatch(rep0 + 1, len)
unpackSize -= len
if (isError) {
return LZMA.LZMA_RES_ERROR
}
}
return LZMA.LZMA_RES_ERROR
}
}

@ -1,43 +0,0 @@
import { LZMA } from './lzma'
export class LZMAHelper {
static decoder: LZMA = new LZMA()
static decoderAsync: Worker = new Worker('LZMAWorker.min.js')
static callback: Function
static ENCODE: number = 1
static DECODE: number = 2
static init(): void {
var command = 0
LZMAHelper.decoderAsync.onmessage = function(e) {
if (command == 0) {
command = e.data
} else if (command == LZMAHelper.ENCODE) {
command = 0 //encode not implemented
} else if (command == LZMAHelper.DECODE) {
command = 0
LZMAHelper.callback(e.data)
LZMAHelper.callback = null
}
}
}
static encode(data: ArrayBuffer): ArrayBuffer {
return null
}
static decode(data: ArrayBuffer): ArrayBuffer {
return LZMAHelper.decoder.decode(new Uint8Array(data)).buffer
}
static encodeAsync(data: ArrayBuffer, _callback: Function): void {}
static decodeAsync(data: ArrayBuffer, _callback: Function): void {
if (LZMAHelper.callback == null) {
LZMAHelper.callback = _callback
LZMAHelper.decoderAsync.postMessage(LZMAHelper.DECODE)
LZMAHelper.decoderAsync.postMessage(data, [data])
} else {
console.log('Warning! Another LZMA decoding is running...')
}
}
}
LZMAHelper.init()

@ -1,36 +0,0 @@
import { LZMA } from './lzma'
export class LZMAWorker {
static ENCODE: number = 1
static DECODE: number = 2
private decoder: LZMA
private command: Object = null
private time: number
constructor() {
var _this = this
this.decoder = new LZMA()
addEventListener(
'message',
(e: any) => {
if (_this.command == null) {
_this.command = e.data
} else if (_this.command['job'] == 1) {
_this.command = null
} else if (_this.command['job'] == 2) {
_this.decode(e.data)
}
},
false
)
}
private decode(data): void {
this.time = Date.now()
var result = this.decoder.decode(new Uint8Array(data))
this.command['time'] = Date.now() - this.time
;(<any>postMessage)(this.command)
;(<any>postMessage)(result.buffer, [result.buffer])
}
}
new LZMAWorker()

@ -1,135 +0,0 @@
import { LzmaDecoder } from './lzma-decoder'
import { RangeDecoder } from './range-decoder'
;('use strict')
/**
* LZMA Decoder
* @author Nidin Vinayakan
*/
export class DecodeResult {
constructor(
public success: u32,
public errorCode: u32,
public unpackSize: i32,
public data: Uint8Array
) {}
}
export class LZMA {
static readonly LZMA_DIC_MIN: u32 = 1 << 12
static readonly LZMA_RES_ERROR: u32 = 0x1
static readonly LZMA_RES_FINISHED_WITH_MARKER: u32 = 0x2
static readonly LZMA_RES_FINISHED_WITHOUT_MARKER: u32 = 0x3
static readonly kNumBitModelTotalBits: u16 = 11
static readonly kNumMoveBits: u8 = 5
static readonly PROB_INIT_VAL: u16 = (1 << LZMA.kNumBitModelTotalBits) / 2 //1024
static readonly kNumPosBitsMax: u8 = 4
static readonly kNumStates: u32 = 12
static readonly kNumLenToPosStates: u32 = 4
static readonly kNumAlignBits: u32 = 4
static readonly kStartPosModelIndex: u32 = 4
static readonly kEndPosModelIndex: u32 = 14
static readonly kNumFullDistances: u32 = 1 << (LZMA.kEndPosModelIndex >>> 1)
static readonly kMatchMinLen: u32 = 2
public decoder: LzmaDecoder
public data: Uint8Array
@inline
static INIT_PROBS(p: Uint16Array): void {
p.fill(LZMA.PROB_INIT_VAL)
}
static BitTreeReverseDecode(
probs: Uint16Array,
numBits: i32,
rc: RangeDecoder,
offset: i32 = 0
): i32 {
var m: u32 = 1
var symbol: u32 = 0
for (var i: i32 = 0; i < numBits; i++) {
var bit: u32 = rc.decodeBit(probs, offset + m)
m <<= 1
m += bit
symbol |= bit << i
}
return symbol
}
constructor() {
this.decoder = new LzmaDecoder()
}
public unpackSize(data: Uint8Array): u32 {
var header: Uint8Array = new Uint8Array(13)
var i: i32
for (i = 0; i < 13; i++) {
header[i] = data[i]
}
var unpackSize: u32 = 0
var unpackSizeDefined: boolean = false
for (i = 0; i < 8; i++) {
var b: u32 = header[5 + i]
if (b != 0xff) {
unpackSizeDefined = true
}
unpackSize |= b << (8 * i)
}
return unpackSize
}
public decode(data: Uint8Array): DecodeResult {
this.data = data
var header: Uint8Array = new Uint8Array(13)
var i: i32
for (i = 0; i < 13; i++) {
header[i] = data[i]
}
this.decoder.decodeProperties(header)
var unpackSize: u32 = 0
var unpackSizeDefined: boolean = false
for (i = 0; i < 8; i++) {
var b: u32 = header[5 + i]
if (b != 0xff) {
unpackSizeDefined = true
}
unpackSize |= b << (8 * i)
}
this.decoder.markerIsMandatory = !unpackSizeDefined
this.decoder.rangeDec.inStream = data
this.decoder.create()
// we support the streams that have uncompressed size and marker.
var res: i32 = this.decoder.decode(unpackSizeDefined, unpackSize)
if (res == LZMA.LZMA_RES_ERROR) {
return new DecodeResult(false, LZMA.LZMA_RES_ERROR, null, null)
//throw 'LZMA decoding error'
} else if (res == LZMA.LZMA_RES_FINISHED_WITHOUT_MARKER) {
//console.log("Finished without end marker");
} else if (res == LZMA.LZMA_RES_FINISHED_WITH_MARKER) {
if (unpackSizeDefined) {
if (this.decoder.outWindow.out_pos != unpackSize) {
return new DecodeResult(false, LZMA.LZMA_RES_ERROR, null, null)
//throw 'Finished with end marker before than specified size'
}
}
} else {
return new DecodeResult(false, LZMA.LZMA_RES_ERROR, null, null)
//throw 'Internal Error'
}
if (this.decoder.rangeDec.corrupted) {
// console.log('Warning: LZMA stream is corrupted')
}
return new DecodeResult(
true,
null,
this.decoder.outWindow.out_pos,
this.decoder.outWindow.outStream
)
}
}

@ -1,92 +0,0 @@
import { HEADER_SIZE } from "~lib/internal/arraybuffer";
/**
* LZMA Decoder
* @author Nidin Vinayakan
*/
export class OutWindow {
public totalPos: i32
public outStream: Uint8Array
private buf: Uint8Array
private pos: i32
public out_pos: i32
private size: i32
private isFull: boolean
constructor() {
this.out_pos = 0
}
public create(
dictSize: i32,
): void {
this.buf = new Uint8Array(dictSize)
this.pos = 0
this.size = dictSize
this.isFull = false
this.totalPos = 0
}
@inline
public putByte(b: u8): void {
this.totalPos++
this.buf.__unchecked_set(this.pos++, b)
if (this.pos == this.size) {
this.pos = 0
this.isFull = true
}
if (this.outStream.length === this.out_pos) {
this.grow()
}
this.outStream.__unchecked_set(this.out_pos++, b)
}
@inline
private grow(): void {
let tmp = this.outStream
this.outStream = new Uint8Array(tmp.length * 2)
memory.copy(
changetype<usize>(this.outStream.buffer) + this.outStream.byteOffset + HEADER_SIZE,
changetype<usize>(tmp.buffer) + tmp.byteOffset + HEADER_SIZE,
tmp.length
);
let tmp_ptr = <usize>tmp;
let AB_ptr = load<u32>(tmp_ptr, 0);
__memory_free(AB_ptr);
__memory_free(tmp_ptr)
}
public trim(): Uint8Array {
var out = this.outStream.subarray(0, this.out_pos)
return out
}
@inline
public getByte(
dist: i32,
): u8 {
return this.buf.__unchecked_get(dist <= this.pos ? this.pos - dist : this.size - dist + this.pos)
}
@inline
public copyMatch(
dist: i32,
len:i32,
): void {
for (; len > 0; len--) {
this.putByte(this.getByte(dist))
}
}
@inline
public checkDistance(dist: i32): boolean {
return dist <= this.pos || this.isFull
}
@inline
public isEmpty(): boolean {
return this.pos == 0 && !this.isFull
}
}

@ -1,96 +0,0 @@
import { LZMA } from "./lzma";
/**
* LZMA Decoder
* @author Nidin Vinayakan
*/
export class RangeDecoder {
static kTopValue: u32 = 1 << 24
public inStream: Uint8Array
public corrupted: boolean
public in_pos: i32
private range: u32 = 0
private code: u32 = 0
constructor() {
this.in_pos = 13
}
@inline
public isFinishedOK(): boolean {
return this.code == 0
}
@inline
public init(): void {
this.corrupted = false
if (this.inStream[this.in_pos++] != 0) {
this.corrupted = true
}
this.range = 0xffffffff
this.code = 0
for (var i: i32 = 0; i < 4; i++) {
this.code = (this.code << 8) | this.inStream[this.in_pos++]
}
if (this.code == this.range) {
this.corrupted = true
}
}
@inline
public normalize():void {
if (this.range < RangeDecoder.kTopValue) {
this.range <<= 8
this.code = (this.code << 8) | this.inStream[this.in_pos++]
}
}
@inline
public decodeDirectBits(numBits: i32): i32 {
var res:u32 = 0
do {
this.range >>>= 1
this.code -= this.range
let t:u32 = 0 - (this.code >>> 31)
this.code += this.range & t
if (this.code == this.range) {
this.corrupted = true
}
this.normalize()
res <<= 1
res += t + 1
} while (--numBits)
return res
}
@inline
decodeBit(prob: Uint16Array, index: i32):u16 {
var v:u16 = prob.__unchecked_get(index);
var bound:u32 = (this.range >> LZMA.kNumBitModelTotalBits) * v;
var symbol:u16 = 0;
if (this.code < bound)
{
v += ((1 << LZMA.kNumBitModelTotalBits) - v) >> LZMA.kNumMoveBits;
this.range = bound;
symbol = 0;
}
else
{
v -= v >> LZMA.kNumMoveBits;
this.code -= bound;
this.range -= bound;
symbol = 1;
}
prob.__unchecked_set(index, v)
this.normalize();
return symbol;
}
}
Loading…
Cancel
Save