chore: use uint32 to simplify the code

Author: antfu

test/lt.test.ts

@@ -6,7 +6,7 @@ import { binaryToBlock, blockToBinary, createDecoder, encodeFountain } from '../
 
 it('slice binary', async () => {
   const input = (await fs.readFile(join('test', 'SampleJPGImage_100kbmb.jpg'), null)).buffer
-  const data = new Uint8Array(input)
+  const data = new Uint32Array(input)
 
   const decoder = createDecoder()
   let count = 0
@@ -24,6 +24,6 @@ it('slice binary', async () => {
 
   const result = decoder.getDecoded()!
   expect(result).toBeDefined()
-  expect(result).toBeInstanceOf(Uint8Array)
+  expect(result).toBeInstanceOf(Uint32Array)
   expect(result.length).toBe(data.length)
 })

utils/lt-codes.ts

@@ -15,36 +15,33 @@ interface EncodingMeta {
 
 interface EncodingBlock extends EncodingMeta {
   indices: number[]
-  data: Uint8Array
+  data: Uint32Array
 }
 
-export function blockToBinary(block: EncodingBlock): Uint8Array {
+export function blockToBinary(block: EncodingBlock): Uint32Array {
   const { k, length, sum, indices, data } = block
-  const header = new Uint32Array([
+  const header = [
     indices.length,
     ...indices,
     k,
     length,
     sum,
-  ])
-  const binary = new Uint8Array(header.length * 4 + data.length)
-  let offset = 0
-  binary.set(new Uint8Array(header.buffer), offset)
-  offset += header.length * 4
-  binary.set(data, offset)
+  ]
+  const binary = new Uint32Array(header.length + data.length)
+  binary.set(header)
+  binary.set(data, header.length)
   return binary
 }
 
-export function binaryToBlock(binary: Uint8Array): EncodingBlock {
-  const degree = new Uint32Array(binary.buffer, 0, 4)[0]!
-  const headerRest = Array.from(new Uint32Array(binary.buffer, 4, degree + 3))
-  const indices = headerRest.slice(0, degree)
+export function binaryToBlock(binary: Uint32Array): EncodingBlock {
+  const degree = binary[0]!
+  const indices = Array.from(binary.slice(1, degree + 1))
   const [
     k,
     length,
     sum,
-  ] = headerRest.slice(degree) as [number, number, number]
-  const data = binary.slice(4 * (degree + 4))
+  ] = Array.from(binary.slice(degree + 1)) as [number, number, number]
+  const data = binary.slice(degree + 1 + 3)
   return {
     k,
     length,
@@ -55,7 +52,7 @@ export function binaryToBlock(binary: Uint8Array): EncodingBlock {
 }
 
 // CRC32 checksum
-function checksum(data: Uint8Array): number {
+function checksum(data: Uint32Array): number {
   let crc = 0xFFFFFFFF
   for (let i = 0; i < data.length; i++) {
     crc = crc ^ data[i]!
@@ -92,25 +89,25 @@ function getRandomIndices(k: number, degree: number): number[] {
   return Array.from(indices)
 }
 
-function xorUint8Array(a: Uint8Array, b: Uint8Array): Uint8Array {
-  const result = new Uint8Array(a.length)
+function xorUint32Array(a: Uint32Array, b: Uint32Array): Uint32Array {
+  const result = new Uint32Array(a.length)
   for (let i = 0; i < a.length; i++) {
     result[i] = a[i]! ^ b[i]!
   }
   return result
 }
 
-function sliceData(data: Uint8Array, blockSize: number): Uint8Array[] {
-  const blocks: Uint8Array[] = []
+function sliceData(data: Uint32Array, blockSize: number): Uint32Array[] {
+  const blocks: Uint32Array[] = []
   for (let i = 0; i < data.length; i += blockSize) {
-    const block = new Uint8Array(blockSize)
+    const block = new Uint32Array(blockSize)
     block.set(data.slice(i, i + blockSize))
     blocks.push(block)
   }
   return blocks
 }
 
-export function *encodeFountain(data: Uint8Array, indiceSize: number): Generator<EncodingBlock> {
+export function *encodeFountain(data: Uint32Array, indiceSize: number): Generator<EncodingBlock> {
   const sum = checksum(data)
   const indices = sliceData(data, indiceSize)
   const k = indices.length
@@ -123,10 +120,10 @@ export function *encodeFountain(data: Uint8Array, indiceSize: number): Generator
   while (true) {
     const degree = getRandomDegree(k)
     const selectedIndices = getRandomIndices(k, degree)
-    let encodedData = new Uint8Array(indiceSize)
+    let encodedData = new Uint32Array(indiceSize)
 
     for (const index of selectedIndices) {
-      encodedData = xorUint8Array(encodedData, indices[index]!)
+      encodedData = xorUint32Array(encodedData, indices[index]!)
     }
 
     yield {
@@ -142,7 +139,7 @@ export function createDecoder(blocks?: EncodingBlock[]) {
 }
 
 export class LtDecoder {
-  public decodedData: (Uint8Array | undefined)[] = []
+  public decodedData: (Uint32Array | undefined)[] = []
   public decodedCount = 0
   public encodedBlocks: Set<EncodingBlock> = new Set()
   public meta: EncodingBlock = undefined!
@@ -172,7 +169,7 @@ export class LtDecoder {
 
       for (const index of indices) {
         if (this.decodedData[index] != null) {
-          data = xorUint8Array(data, this.decodedData[index]!)
+          data = xorUint32Array(data, this.decodedData[index]!)
           indices = indices.filter(i => i !== index)
         }
       }
@@ -190,16 +187,16 @@ export class LtDecoder {
     return this.decodedCount === this.meta.k
   }
 
-  getDecoded(): Uint8Array | undefined {
+  getDecoded(): Uint32Array | undefined {
     if (this.decodedCount !== this.meta.k) {
       return
     }
     if (this.decodedData.some(block => block == null)) {
       return
     }
     const indiceSize = this.meta.data.length
-    const blocks = this.decodedData as Uint8Array[]
-    const decodedData = new Uint8Array(this.meta.length)
+    const blocks = this.decodedData as Uint32Array[]
+    const decodedData = new Uint32Array(this.meta.length)
     blocks.forEach((block, i) => {
       const start = i * indiceSize
       if (start + indiceSize > decodedData.length) {
@@ -219,8 +216,8 @@ export class LtDecoder {
   }
 }
 
-export function tringToUint8Array(str: string): Uint8Array {
-  const data = new Uint8Array(str.length)
+export function tringToUint32Array(str: string): Uint32Array {
+  const data = new Uint32Array(str.length)
   for (let i = 0; i < str.length; i++) {
     data[i] = str.charCodeAt(i)
   }