carta1 1.1.8 → 1.1.10

package/README.md

@@ -1,128 +1,202 @@
 # Carta1
 
-An ATRAC1 audio codec implementation in JS.
+Carta1 is an ATRAC1 encoder and decoder in JavaScript. It converts PCM WAVE
+audio to Sony's AEA container, decodes AEA back to PCM WAVE, exposes stateful
+frame and stream APIs, and ships browser Web Worker bundles.
 
-## Features
+## Supported format
 
-- Pure JavaScript implementation of ATRAC1 codec
-- Encoding WAV to AEA (ATRAC1) format
-- Decoding AEA to WAV format
-- Command-line interface
-- Browser-compatible with Web Workers
-- Streaming support for large files
+| Property           | Support                                       |
+| ------------------ | --------------------------------------------- |
+| Sample rate        | 44.1 kHz                                      |
+| Channels           | Mono or stereo                                |
+| Frame size         | 512 PCM samples per channel                   |
+| Encoded sound unit | 212 bytes per channel                         |
+| Nominal bitrate    | About 146 kbps per channel / 292 kbps stereo  |
+| Container          | AEA                                           |
+| JavaScript PCM     | Planar `Float32Array`, normalized `-1` to `1` |
+
+Stereo channels are encoded independently and stored as interleaved AEA sound
+units.
 
 ## Installation
 
+Carta1 is an ES module and requires Node.js 20.16 or newer.
+
 ```bash
 npm install carta1
 ```
 
-## CLI Usage
-
-### Encoding
+To work from a repository checkout:
 
 ```bash
-carta1 --encode input.wav output.aea
+npm ci
+npm run check
 ```
 
-### Decoding
+## CLI
+
+Run the installed executable directly, or use `npx carta1` from a project that
+depends on Carta1:
 
 ```bash
+carta1 --encode input.wav output.aea
 carta1 --decode input.aea output.wav
-```
-
-### Options
-
-- `-e, --encode` - Encode WAV to AEA
-- `-d, --decode` - Decode AEA to WAV
-- `-j, --json` - Dump AEA file structure to JSON
-- `-q, --quiet` - Suppress all output except errors
-- `-f, --force` - Overwrite output file if it exists
-- `-t, --title <title>` - Custom title for AEA file metadata (encoding only)
+carta1 --json input.aea structure.json
 
-## Browser Usage
-
-```html
-<script src="https://unpkg.com/carta1/dist/carta1-worker.min.js"></script>
-<script src="https://unpkg.com/carta1/dist/carta1-worker-interface.min.js"></script>
+npx carta1 --encode input.wav output.aea
 ```
 
-```javascript
-// Create codec instance
-const codec = new Carta1Worker('carta1-worker.min.js')
+The encoder accepts mono or stereo PCM WAVE input. Carta1 is designed for
+44.1 kHz audio; it warns when the input sample rate differs. Decoding writes
+signed 16-bit PCM WAVE output.
+
+| Option                | Meaning                                              |
+| --------------------- | ---------------------------------------------------- |
+| `-e, --encode`        | Encode PCM WAVE to AEA.                              |
+| `-d, --decode`        | Decode AEA to PCM WAVE.                              |
+| `-j, --json`          | Write AEA metadata and frame structure as JSON.      |
+| `-q, --quiet`         | Suppress normal output and progress.                 |
+| `-f, --force`         | Overwrite an existing output file.                   |
+| `-t, --title <title>` | Set the AEA title while encoding.                    |
+| `-b, --bias <value>`  | Set the bit-allocation bias; defaults to `1.0`.      |
+| `-m, --modes <modes>` | Fix low, mid, and high block modes, such as `0,0,0`. |
+| `-V, --version`       | Print the Carta1 version.                            |
+| `-h, --help`          | Print command help.                                  |
+
+Exactly one of `--encode`, `--decode`, and `--json` is required. The input and
+output are positional paths. Existing output is preserved unless `--force` is
+provided.
+
+## JavaScript API
+
+### Complete AEA files
+
+Use `encodeAeaPcm()` and `decodeAeaPcm()` when the complete input fits in
+memory:
+
+```js
+import { decodeAeaPcm, encodeAeaPcm } from 'carta1'
+
+const aea = await encodeAeaPcm([left, right], {
+  allocationBias: 1.0,
+  title: 'Example',
+})
+const [decodedLeft, decodedRight] = await decodeAeaPcm(aea)
+```
 
-// Encode PCM to ATRAC1
-const result = await codec.encode(pcmData, options)
+`encodeAeaPcm()` returns a `Uint8Array` containing a complete AEA file.
+`decodeAeaPcm()` accepts AEA bytes or a `Blob` and returns normalized planar
+`Float32Array` channels. A mono input uses `[mono]`. The final partial input
+frame is zero-padded.
 
-// Decode ATRAC1 to PCM
-const wavData = await codec.decode(aeaData)
+### Stateful frames
 
-// Clean up
-codec.terminate()
-```
+`encode()` and `decode()` create closures for chronological, complete mono
+frames. Reuse each closure for one stream:
 
-## API Reference
+```js
+import { decode, encode, EncoderOptions } from 'carta1'
 
-### Node.js
+const encodeFrame = encode(new EncoderOptions({ transientThresholdLow: 1.0 }))
+const decodeFrame = decode()
 
-```javascript
-import { encode, decode, AudioProcessor } from 'carta1'
+const encoded = encodeFrame(new Float32Array(512))
+const decoded = decodeFrame(encoded)
+```
 
-// Encode PCM frames
-const encoder = encode(options)
-const encodedFrame = encoder(pcmFrame)
+Use separate closures for separate streams and for the left and right channels
+of stereo audio. `AudioProcessor.encodeStream()` and `decodeStream()` handle
+that ownership automatically.
 
-// Decode ATRAC1 frames
-const decoder = decode()
-const pcmFrame = decoder(encodedFrame)
-```
+### Encoder options
 
-### Browser Worker API
+`EncoderOptions` validates these settings:
 
-#### `new Carta1Worker(workerPath)`
+- `transientThresholdLow`, `transientThresholdMid`, and
+  `transientThresholdHigh` tune short-block detection per frequency band.
+- `allocationBias` changes how strongly allocation favors louder spectral
+  components.
+- `fixedBlockModes` accepts `[low, mid, high]`, where low and mid are `0` or
+  `2`, and high is `0` or `3`; this bypasses transient detection.
 
-Create a new codec worker instance.
+## Browser worker
 
-#### `encode(pcmData, options)`
+The production build writes a worker and an ES module client to `dist/`. Serve
+both from a location allowed by your application's worker and Content Security
+Policy settings:
 
-Encode PCM audio data to ATRAC1 format.
+```js
+import { Carta1Worker } from '/vendor/carta1-worker-interface.min.js'
 
-#### `decode(aeaData)`
+const codec = new Carta1Worker('/vendor/carta1-worker.min.js')
 
-Decode ATRAC1 data to PCM format.
+const { aeaBlob } = await codec.encode([left, right], {
+  allocationBias: 1.0,
+})
+const parsed = await codec.parseAeaBlob(aeaBlob)
+const { wavBlob, info } = await codec.decode({
+  aeaData: parsed.frameData,
+  info: parsed.info,
+})
+const optionMetadata = await codec.getEncoderOptions()
 
-#### `parseAeaBlob(blob)`
+codec.terminate()
+```
 
-Parse AEA file blob to extract metadata.
+Always call `terminate()` when the worker is no longer needed. The build also
+produces `dist/carta1.min.js`, a UMD bundle exposing the main JavaScript API as
+the global `Carta1` object.
 
-#### `terminate()`
+## Compatibility and limitations
 
-Clean up worker resources.
+- Encoding is fixed to the 44.1 kHz ATRAC1 profile described above; Carta1 does
+  not resample input.
+- JavaScript APIs use normalized planar PCM. Web Audio channel data already
+  follows this convention.
+- Stateful frame APIs must receive frames in order and must not be shared by
+  independent streams.
+- AEA stores whole frames rather than an exact source sample count, so a final
+  partial frame is represented with zero padding.
+- Browser worker assets must be served from a location permitted by the page's
+  worker and Content Security Policy rules.
 
 ## Development
 
-```bash
-# Install dependencies
-npm install
-
-# Run tests
-npm test
+Implementation concerns are split without hiding the top-level pipeline:
 
-# Build minified versions
-npm run build
+| Path                | Responsibility                                      |
+| ------------------- | --------------------------------------------------- |
+| `codec/pipeline/`   | Ordered encoder and decoder stage composition.      |
+| `codec/analysis/`   | Transient analysis and encoder decisions.           |
+| `codec/coding/`     | Bit allocation and quantization.                    |
+| `codec/transforms/` | FFT, QMF, MDCT, and inverse transforms.             |
+| `codec/io/`         | Bitstreams, AEA serialization, and stream adapters. |
+| `codec/core/`       | Constants, options, and reusable buffer ownership.  |
+| `codec/browser/`    | Web Worker implementation and client.               |
+| `bin/`              | Command-line boundary.                              |
+| `tests/`            | Unit, serialization, and pipeline tests.            |
 
-# Lint code
-npm run lint
+Common commands are:
 
-# Format code
-npm run format
+```bash
+npm test            # Run the test suite once
+npm run test:watch  # Re-run tests while editing
+npm run lint        # Check JavaScript and formatting
+npm run format      # Apply repository formatting
+npm run build       # Build the three browser bundles
+npm run check       # Run lint, tests, and the production build
 ```
 
-## Acknowledgements
+Run `npm run check` before submitting a change. Pull requests and pushes run
+the same gate in CI.
 
-This project would not have been possible without:
+## Acknowledgements
 
-- [**AtracDEnc**](https://github.com/dcherednik/atracdenc) by [Daniel Cherednik](https://github.com/dcherednik) - The reference ATRAC implementation that provided invaluable insights into the codec's inner workings and served as the primary source for understanding the ATRAC1 format specification.
+This project would not have been possible without
+[AtracDEnc](https://github.com/dcherednik/atracdenc) by
+[Daniel Cherednik](https://github.com/dcherednik), the reference ATRAC
+implementation used to understand the ATRAC1 format and codec behavior.
 
 ## License
 

package/codec/coding/bitallocation.js

@@ -31,8 +31,35 @@ import {
   INV_POWER_OF_TWO,
   SCALE_FACTORS,
   BFU_AMOUNTS,
+  WORD_LENGTH_DELTA_BITS,
+  DISTORTION_DELTA_FACTORS,
 } from '../core/constants.js'
 
+const biasedScaleFactorCache = new Map()
+
+/**
+ * Builds and returns a cached table of biased scale factors.
+ *
+ * @param {number} bias
+ * @returns {Float64Array}
+ */
+function buildBiasedScaleFactorTable(bias) {
+  if (biasedScaleFactorCache.has(bias)) {
+    return biasedScaleFactorCache.get(bias)
+  }
+
+  const out = new Float64Array(64)
+  if (bias === 1) {
+    out.set(SCALE_FACTORS)
+  } else {
+    for (let i = 0; i < 64; i++) {
+      out[i] = Math.pow(SCALE_FACTORS[i], bias)
+    }
+  }
+  biasedScaleFactorCache.set(bias, out)
+  return out
+}
+
 /**
  * Allocate bits by finding the optimal BFU count and distribution using RDO.
  * This function searches through the valid BFU counts to find the one that
@@ -40,23 +67,23 @@ import {
  *
  * @param {Array<Float32Array>} bfuData
  * @param {Int32Array} bfuSizes
- * @param {number} maxBfuCount The maximum BFU index to consider (e.g., from BFU_AMOUNTS)
+ * @param {number} maxBfuCount
  * @param {number} allocationBias
  * @returns {{bfuCount:number, allocation:Int32Array, scaleFactorIndices:Int32Array}}
  */
 export function allocateBits(bfuData, bfuSizes, maxBfuCount, allocationBias) {
   const allScaleFactorIndices = new Int32Array(maxBfuCount)
   const zeroBitDistortions = new Float32Array(maxBfuCount)
+  const biasedScaleFactors = buildBiasedScaleFactorTable(allocationBias)
 
   for (let i = 0; i < maxBfuCount; i++) {
     const sz = bfuSizes[i] | 0
     if (sz === 0) continue
 
-    const sfi = findScaleFactor(bfuData[i].subarray(0, sz))
+    const sfi = findScaleFactor(bfuData[i], sz)
     allScaleFactorIndices[i] = sfi
     if (sfi > 0) {
-      const scaleFactor = SCALE_FACTORS[sfi]
-      const effectiveScaleFactor = Math.pow(scaleFactor, allocationBias)
+      const effectiveScaleFactor = biasedScaleFactors[sfi]
       zeroBitDistortions[i] = effectiveScaleFactor * 2.0 * sz
     }
   }
@@ -78,7 +105,7 @@ export function allocateBits(bfuData, bfuSizes, maxBfuCount, allocationBias) {
       candidateBfuCount,
       bfuSizes,
       availableBits,
-      allocationBias,
+      biasedScaleFactors,
       allScaleFactorIndices
     )
 
@@ -88,7 +115,7 @@ export function allocateBits(bfuData, bfuSizes, maxBfuCount, allocationBias) {
       bfuSizes,
       rdoResult.wordLengths,
       rdoResult.scaleFactorIndices,
-      allocationBias,
+      biasedScaleFactors,
       zeroBitDistortions
     )
 
@@ -118,14 +145,14 @@ export function allocateBits(bfuData, bfuSizes, maxBfuCount, allocationBias) {
  * Calculates the total distortion for a given allocation.
  * This includes quantization distortion for coded bands and truncation
  * distortion for uncoded bands.
- * @param {number} activeBfuCount - The number of BFUs that were coded.
- * @param {number} maxBfuCount - The total number of BFUs considered.
- * @param {Int32Array} bfuSizes - Sizes of each BFU.
- * @param {Int32Array} wordLengths - The allocated word length for each active BFU.
- * @param {Int32Array} scaleFactorIndices - The scale factor index for each BFU.
- * @param {number} allocationBias - The RDO bias factor.
- * @param {Float32Array} zeroBitDistortions - Pre-calculated distortion for uncoded bands.
- * @returns {number} The total calculated distortion.
+ * @param {number} activeBfuCount
+ * @param {number} maxBfuCount
+ * @param {Int32Array} bfuSizes
+ * @param {Int32Array} wordLengths
+ * @param {Int32Array} scaleFactorIndices
+ * @param {number} biasedScaleFactors
+ * @param {Float32Array} zeroBitDistortions
+ * @returns {number}
  */
 function calculateTotalDistortion(
   activeBfuCount,
@@ -133,7 +160,7 @@ function calculateTotalDistortion(
   bfuSizes,
   wordLengths,
   scaleFactorIndices,
-  allocationBias,
+  biasedScaleFactors,
   zeroBitDistortions
 ) {
   let totalDistortion = 0.0
@@ -149,8 +176,7 @@ function calculateTotalDistortion(
     const sfi = scaleFactorIndices[i]
     if (sfi === 0) continue
 
-    const scaleFactor = SCALE_FACTORS[sfi]
-    const effectiveScaleFactor = Math.pow(scaleFactor, allocationBias)
+    const effectiveScaleFactor = biasedScaleFactors[sfi]
     const distortionFactor = INV_POWER_OF_TWO[bits]
 
     totalDistortion += effectiveScaleFactor * distortionFactor * bfuSizes[i]
@@ -170,105 +196,100 @@ function calculateTotalDistortion(
  * @param {number} activeBfuCount
  * @param {Int32Array} bfuSizes
  * @param {number} remainingBits
- * @param {number} allocationBias
- * @param {Int32Array} allScaleFactorIndices - Pre-calculated SFIs for all potential BFUs.
+ * @param {Float64Array} biasedScaleFactors
+ * @param {Int32Array} allScaleFactorIndices
  * @returns {{wordLengths: Int32Array, scaleFactorIndices: Int32Array}}
  */
 function distributeBitsRDO(
   activeBfuCount,
   bfuSizes,
   remainingBits,
-  allocationBias,
+  biasedScaleFactors,
   allScaleFactorIndices
 ) {
-  const scaleFactorTable = allScaleFactorIndices
   const wordLengths = new Int32Array(activeBfuCount)
 
-  const heapIndices = []
-  const heapPriorities = []
-
-  const deltaDistPerCoeff = (bfuIndex, currentWl, nextWl) => {
-    const sfi = scaleFactorTable[bfuIndex]
-    const scaleFactor = SCALE_FACTORS[sfi]
-    if (scaleFactor === 0) return 0
-
-    const effectiveScaleFactor = Math.pow(scaleFactor, allocationBias)
-
-    const bits1 = WORD_LENGTH_BITS[currentWl] | 0
-    const bits2 = WORD_LENGTH_BITS[nextWl] | 0
-
-    const f1 = bits1 === 0 ? 2.0 : INV_POWER_OF_TWO[bits1]
-    const f2 = INV_POWER_OF_TWO[bits2]
-
-    return effectiveScaleFactor * (f1 - f2)
-  }
+  const heapIndices = new Int32Array(activeBfuCount)
+  const heapPriorities = new Float32Array(activeBfuCount)
+  let heapSize = 0
 
   for (let bfuIndex = 0; bfuIndex < activeBfuCount; bfuIndex++) {
     const sz = bfuSizes[bfuIndex] | 0
     if (sz === 0) continue
 
-    const sfi = scaleFactorTable[bfuIndex]
+    const sfi = allScaleFactorIndices[bfuIndex]
     if (sfi === 0) continue
 
-    const currentWl = 0
-    const nextWl = 1
-    const deltaBits =
-      (WORD_LENGTH_BITS[nextWl] - WORD_LENGTH_BITS[currentWl]) | 0
+    const deltaBits = WORD_LENGTH_DELTA_BITS[0]
     if (deltaBits <= 0) continue
 
-    const ddPerCoeff = deltaDistPerCoeff(bfuIndex, currentWl, nextWl)
-    heapIndices.push(bfuIndex)
-    heapPriorities.push(ddPerCoeff / deltaBits)
+    const distortionDelta =
+      biasedScaleFactors[sfi] * DISTORTION_DELTA_FACTORS[0]
+
+    heapIndices[heapSize] = bfuIndex
+    heapPriorities[heapSize] = distortionDelta / deltaBits
+    heapSize++
+  }
+
+  if (heapSize === 0) {
+    return { wordLengths, scaleFactorIndices: allScaleFactorIndices }
   }
 
   // Heapify
-  for (let i = (heapIndices.length >> 1) - 1; i >= 0; i--)
-    siftDown(heapIndices, heapPriorities, i)
+  for (let i = (heapSize >> 1) - 1; i >= 0; i--) {
+    siftDown(heapIndices, heapPriorities, i, heapSize)
+  }
 
-  // Greedy spending
-  while (remainingBits > 0 && heapIndices.length > 0) {
+  // Greedy spending loop
+  while (remainingBits > 0 && heapSize > 0) {
     const bfu = heapIndices[0]
     const cur = wordLengths[bfu] | 0
-    const nxt = cur + 1
-
     const sz = bfuSizes[bfu] | 0
-    const deltaBits = (WORD_LENGTH_BITS[nxt] - WORD_LENGTH_BITS[cur]) | 0
+    const deltaBits = WORD_LENGTH_DELTA_BITS[cur]
     const cost = deltaBits * sz
 
     if (cost > remainingBits || cost <= 0) {
-      popRoot(heapIndices, heapPriorities)
+      const last = heapSize - 1
+      heapIndices[0] = heapIndices[last]
+      heapPriorities[0] = heapPriorities[last]
+      heapSize--
+      if (heapSize > 0) siftDown(heapIndices, heapPriorities, 0, heapSize)
       continue
     }
 
     remainingBits -= cost
+    const nxt = cur + 1
     wordLengths[bfu] = nxt
 
-    if (nxt < MAX_WORD_LENGTH_INDEX) {
-      const nxt2 = nxt + 1
-      const deltaBits2 = (WORD_LENGTH_BITS[nxt2] - WORD_LENGTH_BITS[nxt]) | 0
-      if (deltaBits2 > 0) {
-        heapPriorities[0] = deltaDistPerCoeff(bfu, nxt, nxt2) / deltaBits2
-        siftDown(heapIndices, heapPriorities, 0)
-      } else {
-        popRoot(heapIndices, heapPriorities)
-      }
+    const deltaBitsNext = WORD_LENGTH_DELTA_BITS[nxt]
+    if (nxt < MAX_WORD_LENGTH_INDEX && deltaBitsNext > 0) {
+      const sfi = allScaleFactorIndices[bfu]
+      const distortionDelta =
+        biasedScaleFactors[sfi] * DISTORTION_DELTA_FACTORS[nxt]
+      heapPriorities[0] = distortionDelta / deltaBitsNext
+      siftDown(heapIndices, heapPriorities, 0, heapSize)
     } else {
-      popRoot(heapIndices, heapPriorities)
+      const last = heapSize - 1
+      heapIndices[0] = heapIndices[last]
+      heapPriorities[0] = heapPriorities[last]
+      heapSize--
+      if (heapSize > 0) siftDown(heapIndices, heapPriorities, 0, heapSize)
     }
   }
 
-  return { wordLengths, scaleFactorIndices: scaleFactorTable }
+  return { wordLengths, scaleFactorIndices: allScaleFactorIndices }
 }
 
 /**
  * Find the optimal scale factor index for a set of coefficients.
  * Same semantics as the original.
  * @param {Float32Array} coefficients
+ * @param {number} length
  * @returns {number}
  */
-export function findScaleFactor(coefficients) {
+export function findScaleFactor(coefficients, length) {
   let maxAmplitude = 0.0
-  for (let i = 0; i < coefficients.length; i++) {
+  for (let i = 0; i < length; i++) {
     const a = Math.abs(coefficients[i])
     if (a > maxAmplitude) maxAmplitude = a
   }
@@ -277,25 +298,6 @@ export function findScaleFactor(coefficients) {
   return Math.max(0, Math.min(63, index))
 }
 
-/**
- * Removes the root element from a max-heap and maintains heap property.
- *
- * This function efficiently removes the maximum priority element from the heap
- * by replacing it with the last element and then restoring the heap property
- * through sifting down.
- *
- * @param {Array<number>} heapIndices
- * @param {Array<number>} heapPriorities
- */
-function popRoot(heapIndices, heapPriorities) {
-  const last = heapIndices.length - 1
-  heapIndices[0] = heapIndices[last]
-  heapPriorities[0] = heapPriorities[last]
-  heapIndices.pop()
-  heapPriorities.pop()
-  if (heapIndices.length) siftDown(heapIndices, heapPriorities, 0)
-}
-
 /**
  * Restores max-heap property by sifting an element down from a given position.
  *
@@ -304,12 +306,12 @@ function popRoot(heapIndices, heapPriorities) {
  * with its children and swaps with the larger child until the heap property
  * is satisfied, or it reaches a leaf position.
  *
- * @param {Array<number>} heapIndices
- * @param {Array<number>} heapPriorities
+ * @param {Int32Array} heapIndices
+ * @param {Float32Array} heapPriorities
  * @param {number} startIndex
+ * @param {number} heapSize
  */
-function siftDown(heapIndices, heapPriorities, startIndex) {
-  const heapSize = heapIndices.length
+function siftDown(heapIndices, heapPriorities, startIndex, heapSize) {
   let i = startIndex
   const idxVal = heapIndices[i]
   const prVal = heapPriorities[i]

package/codec/core/constants.js

@@ -158,3 +158,22 @@ export const INV_POWER_OF_TWO = (() => {
   }
   return table
 })()
+
+export const WORD_LENGTH_DELTA_BITS = (() => {
+  const table = new Int32Array(MAX_WORD_LENGTH_INDEX)
+  for (let i = 0; i < MAX_WORD_LENGTH_INDEX; i++) {
+    table[i] = (WORD_LENGTH_BITS[i + 1] - WORD_LENGTH_BITS[i]) | 0
+  }
+  return table
+})()
+
+export const DISTORTION_DELTA_FACTORS = (() => {
+  const table = new Float64Array(MAX_WORD_LENGTH_INDEX)
+  table[0] = 2.0 - INV_POWER_OF_TWO[WORD_LENGTH_BITS[1]]
+  for (let i = 1; i < MAX_WORD_LENGTH_INDEX; i++) {
+    const bits1 = WORD_LENGTH_BITS[i] | 0
+    const bits2 = WORD_LENGTH_BITS[i + 1] | 0
+    table[i] = INV_POWER_OF_TWO[bits1] - INV_POWER_OF_TWO[bits2]
+  }
+  return table
+})()

package/codec/core/options.js

@@ -52,7 +52,7 @@ class EncoderOptions {
         name: 'Bit allocation bias',
         description:
           'Controls how bits are distributed across the frequency spectrum during allocation. Higher values focus more bits on loud spectral components, while lower values spread bits more evenly across frequencies.',
-        range: [0.5, 3.0],
+        range: [0.0, 5.0],
         step: 0.01,
       },
       fixedBlockModes: {

package/codec/index.js

@@ -14,7 +14,7 @@ import { qmfAnalysisStage, mdctStage } from './pipeline/encoder.js'
 import { pipe } from './utils.js'
 import { BufferPool } from './core/buffers.js'
 import { EncoderOptions } from './core/options.js'
-import { AudioProcessor } from './io/processor.js'
+import { AudioProcessor, decodeAeaPcm, encodeAeaPcm } from './io/processor.js'
 import { FFT } from './transforms/fft.js'
 import {
   WORD_LENGTH_BITS,
@@ -37,6 +37,8 @@ export {
   BufferPool,
   EncoderOptions,
   AudioProcessor,
+  decodeAeaPcm,
+  encodeAeaPcm,
   FFT,
   WORD_LENGTH_BITS,
   SPECS_PER_BFU,

package/codec/io/bitstream.js

@@ -52,7 +52,7 @@ export function unpackBits(buffer, bitPosition, bitCount) {
   let bitOffset = bitPosition % 8
   let value = 0
 
-  for (let bitsRead = 0; bitsRead < bitCount && byteIndex < buffer.length; ) {
+  for (let bitsRead = 0; bitsRead < bitCount && byteIndex < buffer.length;) {
     const bitsAvailable = 8 - bitOffset
     const bitsToRead = Math.min(bitCount - bitsRead, bitsAvailable)