carta1 1.5.0 → 1.6.0

package/README.md

@@ -34,6 +34,11 @@ npm ci
 npm run check
 ```
 
+[Native CLI archives](docs/native.md) for Linux and macOS (x64 and ARM64) are
+built with Porffor and attached to GitHub Releases after exact WAV/AEA parity
+checks against the Node CLI. They run without Node.js. See the native guide
+for local builds, supported input formats, and verification.
+
 ## CLI
 
 Run the installed executable directly, or use `npx carta1` from a project that
@@ -202,7 +207,6 @@ implementation used to understand the ATRAC1 format and codec behavior.
 
 ISC
 
-
 ## Experimental Web MiniDisc encoder plugin
 
 `npm run build` also emits `dist/carta1.wme`, alongside the three existing
@@ -211,7 +215,7 @@ and their source maps. The npm package includes the same build outputs. Release
 CDN links are pinned to that release's version.
 
 **Carta1 (ATRAC1, experimental)** is an ATRAC1 codec for standard MD SP, not
-ATRAC3 LP2/LP4 or ATRAC3PLUS Hi-MD. Current Web MiniDisc API v1 does not support
+ATRAC3 LP2/LP4 or ATRAC3plus Hi-MD. Current Web MiniDisc API v1 does not support
 software ATRAC1 output: its SP modes request PCM for the recorder to encode in
 hardware. Installing this plugin does not enable Carta1 recording in the
 unmodified app. All current API v1 codecs (PCM, MP3, AT3, A3+) are explicitly
@@ -224,10 +228,10 @@ with the usual `init`, `deinit`, `getSupportFor`, `transcode`, and progress hook
 It adds two **proposed, nonstandard** export codec names, using the host's
 existing recording-mode names:
 
-| `exportParams.format` | PCM channels | Output |
-| --- | --- | --- |
-| `{ codec: 'SPS', bitrate: 292 }` | 2 | ATRAC1 stereo SP |
-| `{ codec: 'SPM', bitrate: 146 }` | 1 | ATRAC1 mono SP |
+| `exportParams.format`            | PCM channels | Output           |
+| -------------------------------- | ------------ | ---------------- |
+| `{ codec: 'SPS', bitrate: 292 }` | 2            | ATRAC1 stereo SP |
+| `{ codec: 'SPM', bitrate: 146 }` | 1            | ATRAC1 mono SP   |
 
 Bitrates are nominal kbps; ATRAC1 uses 212-byte sound units per channel per
 512 samples at 44.1 kHz. The host's built-in FFmpeg decodes/resamples sources
@@ -249,3 +253,6 @@ included here.
 `npm run test:wme` exercises the built archive and its bundled worker for both
 proposed formats, comparing the returned raw bytes with `encodeAeaPcm` across
 independent tracks. Lifecycle and failure tests run in the normal test suite.
+
+The repository-only WME packager lives in `build/wme.js`. Build tooling is
+excluded from the npm package; the generated `dist/` assets are included.

package/bin/cli.js

@@ -13,16 +13,18 @@
  */
 
 import { program } from 'commander'
+import { validateModes } from './options.js'
+import { inspectAea } from '../codec/boundary/inspect.js'
 import fs from 'fs'
 import path from 'path'
 import { performance } from 'perf_hooks'
 import cliProgress from 'cli-progress'
 import wav from 'wav'
 
+import { pcmBytesToChannels } from '../codec/boundary/pcm.js'
 import { AudioProcessor } from '../codec/boundary/processor.js'
 import { AeaReader } from '../codec/boundary/reader.js'
-import { AeaFile, validateAeaTitle } from '../codec/boundary/container.js'
-import { deserializeFrame } from '../codec/syntax/frame.js'
+import { validateAeaTitle } from '../codec/boundary/container.js'
 import { EncoderOptions } from '../codec/core/options.js'
 import {
   SAMPLE_RATE,
@@ -67,47 +69,6 @@ function validateTitle(title) {
  * @returns {Array<number>} [returns.modes] - Parsed modes if valid
  * @returns {string} [returns.error] - Error message if invalid
  */
-function validateModes(modes) {
-  if (!modes) {
-    return { valid: true }
-  }
-
-  const parts = modes.split(',')
-  if (parts.length !== 3) {
-    return {
-      valid: false,
-      error: `Modes must have exactly 3 values separated by commas, got ${parts.length}`,
-    }
-  }
-
-  const parsedModes = []
-  const validValues = [
-    [0, 2], // Position 1: 0 or 2
-    [0, 2], // Position 2: 0 or 2
-    [0, 3], // Position 3: 0 or 3
-  ]
-
-  for (let i = 0; i < 3; i++) {
-    const mode = parseInt(parts[i], 10)
-    if (isNaN(mode)) {
-      return {
-        valid: false,
-        error: `Mode at position ${i + 1} is not a number: "${parts[i]}"`,
-      }
-    }
-
-    if (!validValues[i].includes(mode)) {
-      return {
-        valid: false,
-        error: `Mode at position ${i + 1} must be ${validValues[i].join(' or ')}, got ${mode}`,
-      }
-    }
-
-    parsedModes.push(mode)
-  }
-
-  return { valid: true, modes: parsedModes }
-}
 
 /**
  * Progress tracking utility for encoding/decoding operations
@@ -341,42 +302,13 @@ class WavReader {
    * @returns {Float32Array|Array<Float32Array>} Processed frame data
    */
   _processFrameBuffer(frameBuffer, frameSize) {
-    if (this.channels === 1) {
-      const frame = new Float32Array(frameSize)
-      for (let i = 0; i < frameSize; i++) {
-        frame[i] = this._sampleToFloat(frameBuffer, i * (this.bitDepth / 8))
-      }
-      return frame
-    } else {
-      const left = new Float32Array(frameSize)
-      const right = new Float32Array(frameSize)
-      for (let i = 0; i < frameSize; i++) {
-        const offset = i * this.channels * (this.bitDepth / 8)
-        left[i] = this._sampleToFloat(frameBuffer, offset)
-        right[i] = this._sampleToFloat(frameBuffer, offset + this.bitDepth / 8)
-      }
-      return [left, right]
-    }
-  }
-
-  /**
-   * Convert PCM sample to normalized float32 value
-   *
-   * @private
-   * @param {Buffer} buffer - PCM data buffer
-   * @param {number} offset - Byte offset to sample
-   * @returns {number} Normalized float value [-1.0, 1.0]
-   */
-  _sampleToFloat(buffer, offset) {
-    if (this.bitDepth === 16) return buffer.readInt16LE(offset) / 32768.0
-    if (this.bitDepth === 24) {
-      let s =
-        buffer[offset] | (buffer[offset + 1] << 8) | (buffer[offset + 2] << 16)
-      if (s > 0x7fffff) s -= 0x1000000
-      return s / 8388608.0
-    }
-    if (this.bitDepth === 32) return buffer.readInt32LE(offset) / 2147483648.0
-    return 0
+    const channels = pcmBytesToChannels(
+      frameBuffer,
+      this.bitDepth,
+      this.channels,
+      frameSize
+    )
+    return this.channels === 1 ? channels[0] : channels
   }
 }
 
@@ -544,115 +476,20 @@ async function decodeFile(inputFile, outputFile, options) {
  * @throws {Error} If input file is invalid or cannot be read
  */
 async function dumpFile(inputFile, outputFile, options) {
-  const stats = fs.statSync(inputFile)
-
-  if (!options.quiet) {
-    console.log(`${inputFile} (AEA) → ${outputFile} (JSON)`)
-  }
-
-  const handle = await fs.promises.open(inputFile, 'r')
-  const headerBuffer = Buffer.alloc(AEA_HEADER_SIZE)
-  await handle.read(headerBuffer, 0, AEA_HEADER_SIZE, 0)
-
-  let metadata
-  try {
-    metadata = AeaFile.parseHeader(headerBuffer)
-  } catch (err) {
-    throw new Error(`Invalid AEA header: ${err.message}`)
-  }
-
+  const bytes = await fs.promises.readFile(inputFile)
+  if (!options.quiet) console.log(`${inputFile} (AEA) → ${outputFile} (JSON)`)
   const frameCount = Math.floor(
-    (stats.size - AEA_HEADER_SIZE) / SOUND_UNIT_SIZE
+    (bytes.length - AEA_HEADER_SIZE) / SOUND_UNIT_SIZE
   )
-
-  const dump = {
-    file: {
-      path: inputFile,
-      size: stats.size,
-      headerSize: AEA_HEADER_SIZE,
-      dataSize: stats.size - AEA_HEADER_SIZE,
-      expectedDataSize: frameCount * SOUND_UNIT_SIZE,
-      sizeDifference:
-        stats.size - AEA_HEADER_SIZE - frameCount * SOUND_UNIT_SIZE,
-    },
-    header: {
-      magic: Array.from(headerBuffer.slice(0, 4))
-        .map((b) => b.toString(16).padStart(2, '0'))
-        .join(' '),
-      title: metadata.title,
-      frameCount: metadata.frameCount,
-      channelCount: metadata.channelCount,
-      framesPerChannel: metadata.frameCount / metadata.channelCount,
-      duration: ((metadata.frameCount / metadata.channelCount) * 512) / 44100,
-    },
-    frames: [],
-  }
-
   const progress = new ProgressTracker(frameCount, 'Analyzing', options.quiet)
-
   try {
-    let offset = AEA_HEADER_SIZE
-    for (let i = 0; i < frameCount; i++) {
-      const frameBuffer = Buffer.alloc(SOUND_UNIT_SIZE)
-      await handle.read(frameBuffer, 0, SOUND_UNIT_SIZE, offset)
-
-      try {
-        const frame = deserializeFrame(frameBuffer)
-        const frameInfo = {
-          index: i,
-          offset: offset,
-          offsetHex: '0x' + offset.toString(16),
-          nBfu: frame.nBfu,
-          blockModes: frame.blockModes,
-          scaleFactorIndices: Array.from(frame.scaleFactorIndices),
-          wordLengthIndices: Array.from(frame.wordLengthIndices),
-          hasNonZeroScaleFactors: frame.scaleFactorIndices.some((sf) => sf > 0),
-          hasNonZeroWordLengths: frame.wordLengthIndices.some((wl) => wl > 0),
-          hasCoefficients: frame.quantizedCoefficients.some(
-            (coeffs) => coeffs && coeffs.some((c) => c !== 0)
-          ),
-        }
-
-        // Include full coefficient data for first few frames only
-        if (i < 3 || i === frameCount - 1) {
-          frameInfo.quantizedCoefficients = frame.quantizedCoefficients.map(
-            (coeffs) => (coeffs ? Array.from(coeffs) : null)
-          )
-        }
-
-        dump.frames.push(frameInfo)
-      } catch (err) {
-        dump.frames.push({
-          index: i,
-          offset: offset,
-          offsetHex: '0x' + offset.toString(16),
-          error: err.message,
-        })
-      }
-
+    const dump = inspectAea(bytes, inputFile, () =>
       progress.update(SAMPLE_RATE)
-      offset += SOUND_UNIT_SIZE
-    }
+    )
+    await fs.promises.writeFile(outputFile, JSON.stringify(dump, null, 2))
   } finally {
     progress.stop()
-    await handle.close()
   }
-
-  // Add summary statistics
-  dump.summary = {
-    totalFrames: frameCount,
-    validFrames: dump.frames.filter((f) => !f.error).length,
-    errorFrames: dump.frames.filter((f) => f.error).length,
-    silentFrames: dump.frames.filter(
-      (f) => !f.error && !f.hasNonZeroScaleFactors && !f.hasNonZeroWordLengths
-    ).length,
-    activeFrames: dump.frames.filter(
-      (f) => !f.error && (f.hasNonZeroScaleFactors || f.hasNonZeroWordLengths)
-    ).length,
-  }
-
-  const jsonOutput = JSON.stringify(dump, null, 2)
-  await fs.promises.writeFile(outputFile, jsonOutput)
 }
 
 /**

package/bin/options.js

@@ -0,0 +1,41 @@
+export function validateModes(modes) {
+  if (!modes) {
+    return { valid: true }
+  }
+
+  const parts = modes.split(',')
+  if (parts.length !== 3) {
+    return {
+      valid: false,
+      error: `Modes must have exactly 3 values separated by commas, got ${parts.length}`,
+    }
+  }
+
+  const parsedModes = []
+  const validValues = [
+    [0, 2], // Position 1: 0 or 2
+    [0, 2], // Position 2: 0 or 2
+    [0, 3], // Position 3: 0 or 3
+  ]
+
+  for (let i = 0; i < 3; i++) {
+    const mode = parseInt(parts[i], 10)
+    if (isNaN(mode)) {
+      return {
+        valid: false,
+        error: `Mode at position ${i + 1} is not a number: "${parts[i]}"`,
+      }
+    }
+
+    if (!validValues[i].includes(mode)) {
+      return {
+        valid: false,
+        error: `Mode at position ${i + 1} must be ${validValues[i].join(' or ')}, got ${mode}`,
+      }
+    }
+
+    parsedModes.push(mode)
+  }
+
+  return { valid: true, modes: parsedModes }
+}

package/codec/boundary/inspect.js

@@ -0,0 +1,96 @@
+/** Shared JSON inspection for the Node and native hosts. */
+import { AeaFile } from './container.js'
+import { deserializeFrame } from '../syntax/frame.js'
+import { AEA_HEADER_SIZE, SOUND_UNIT_SIZE } from '../core/constants.js'
+
+export function inspectAea(bytes, inputFile, onFrame = () => {}) {
+  const stats = { size: bytes.length }
+  const headerBuffer = bytes.subarray(0, AEA_HEADER_SIZE)
+  let metadata
+  try {
+    metadata = AeaFile.parseHeader(headerBuffer)
+  } catch (err) {
+    throw new Error(`Invalid AEA header: ${err.message}`)
+  }
+  const frameCount = Math.floor(
+    (bytes.length - AEA_HEADER_SIZE) / SOUND_UNIT_SIZE
+  )
+  const dump = {
+    file: {
+      path: inputFile,
+      size: stats.size,
+      headerSize: AEA_HEADER_SIZE,
+      dataSize: stats.size - AEA_HEADER_SIZE,
+      expectedDataSize: frameCount * SOUND_UNIT_SIZE,
+      sizeDifference:
+        stats.size - AEA_HEADER_SIZE - frameCount * SOUND_UNIT_SIZE,
+    },
+    header: {
+      magic: Array.from(headerBuffer.slice(0, 4))
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join(' '),
+      title: metadata.title,
+      frameCount: metadata.frameCount,
+      channelCount: metadata.channelCount,
+      framesPerChannel: metadata.frameCount / metadata.channelCount,
+      duration: ((metadata.frameCount / metadata.channelCount) * 512) / 44100,
+    },
+    frames: [],
+  }
+
+  let offset = AEA_HEADER_SIZE
+  for (let i = 0; i < frameCount; i++) {
+    const frameBuffer = bytes.subarray(offset, offset + SOUND_UNIT_SIZE)
+
+    try {
+      const frame = deserializeFrame(frameBuffer)
+      const frameInfo = {
+        index: i,
+        offset: offset,
+        offsetHex: '0x' + offset.toString(16),
+        nBfu: frame.nBfu,
+        blockModes: frame.blockModes,
+        scaleFactorIndices: Array.from(frame.scaleFactorIndices),
+        wordLengthIndices: Array.from(frame.wordLengthIndices),
+        hasNonZeroScaleFactors: frame.scaleFactorIndices.some((sf) => sf > 0),
+        hasNonZeroWordLengths: frame.wordLengthIndices.some((wl) => wl > 0),
+        hasCoefficients: frame.quantizedCoefficients.some(
+          (coeffs) => coeffs && coeffs.some((c) => c !== 0)
+        ),
+      }
+
+      // Include full coefficient data for first few frames only
+      if (i < 3 || i === frameCount - 1) {
+        frameInfo.quantizedCoefficients = frame.quantizedCoefficients.map(
+          (coeffs) => (coeffs ? Array.from(coeffs) : null)
+        )
+      }
+
+      dump.frames.push(frameInfo)
+    } catch (err) {
+      dump.frames.push({
+        index: i,
+        offset: offset,
+        offsetHex: '0x' + offset.toString(16),
+        error: err.message,
+      })
+    }
+
+    onFrame()
+    offset += SOUND_UNIT_SIZE
+  }
+  // Add summary statistics
+  dump.summary = {
+    totalFrames: frameCount,
+    validFrames: dump.frames.filter((f) => !f.error).length,
+    errorFrames: dump.frames.filter((f) => f.error).length,
+    silentFrames: dump.frames.filter(
+      (f) => !f.error && !f.hasNonZeroScaleFactors && !f.hasNonZeroWordLengths
+    ).length,
+    activeFrames: dump.frames.filter(
+      (f) => !f.error && (f.hasNonZeroScaleFactors || f.hasNonZeroWordLengths)
+    ).length,
+  }
+
+  return dump
+}

package/codec/boundary/pcm.js

@@ -26,6 +26,92 @@ function writeFourCc(output, offset, value) {
   }
 }
 
+/** Convert interleaved signed little-endian PCM into normalized channels. */
+export function pcmBytesToChannels(bytes, bitDepth, channelCount, sampleCount) {
+  if (![16, 24, 32].includes(bitDepth)) {
+    throw new RangeError(`Unsupported PCM bit depth: ${bitDepth}`)
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+  const channels = Array.from(
+    { length: channelCount },
+    () => new Float32Array(sampleCount)
+  )
+  let offset = 0
+  for (let sample = 0; sample < sampleCount; sample++) {
+    for (const channel of channels) {
+      let value
+      if (bitDepth === 16) value = view.getInt16(offset, true) / 32768
+      else if (bitDepth === 32) value = view.getInt32(offset, true) / 2147483648
+      else {
+        let integer =
+          bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16)
+        if (integer > 0x7fffff) integer -= 0x1000000
+        value = integer / 8388608
+      }
+      channel[sample] = value
+      offset += bitDepth / 8
+    }
+  }
+  return channels
+}
+
+/** Read a RIFF/WAVE byte image. Native file I/O stays outside this boundary. */
+export function parsePcmWave(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)
+  const fourCc = (offset) =>
+    String.fromCharCode(...bytes.subarray(offset, offset + 4))
+  if (bytes.length < 12 || fourCc(0) !== 'RIFF' || fourCc(8) !== 'WAVE') {
+    throw new Error('Invalid RIFF/WAVE file')
+  }
+  const end = view.getUint32(4, true) + 8
+  if (end > bytes.length || end < 12)
+    throw new Error('Truncated RIFF/WAVE file')
+  let format = null
+  let data = null
+  for (let offset = 12; offset + 8 <= end;) {
+    const size = view.getUint32(offset + 4, true)
+    const start = offset + 8
+    if (start + size > end) throw new Error('Truncated WAVE chunk')
+    if (fourCc(offset) === 'fmt ') {
+      if (size < 16) throw new Error('Invalid WAVE format chunk')
+      format = {
+        code: view.getUint16(start, true),
+        channelCount: view.getUint16(start + 2, true),
+        sampleRate: view.getUint32(start + 4, true),
+        blockAlign: view.getUint16(start + 12, true),
+        bitDepth: view.getUint16(start + 14, true),
+      }
+    } else if (fourCc(offset) === 'data' && data === null)
+      data = bytes.subarray(start, start + size)
+    offset = start + size + (size & 1)
+  }
+  if (!format || data === null)
+    throw new Error('WAVE requires fmt and data chunks')
+  const { code, channelCount, sampleRate, blockAlign, bitDepth } = format
+  if (code !== 1 || ![16, 24, 32].includes(bitDepth)) {
+    throw new Error('WAVE input must be signed 16, 24, or 32-bit integer PCM')
+  }
+  if (channelCount !== 1 && channelCount !== 2)
+    throw new Error(`Unsupported channel count: ${channelCount}`)
+  if (
+    sampleRate < 1 ||
+    blockAlign !== (channelCount * bitDepth) / 8 ||
+    data.length % blockAlign !== 0
+  ) {
+    throw new Error('Invalid WAVE sample layout')
+  }
+  return {
+    channels: pcmBytesToChannels(
+      data,
+      bitDepth,
+      channelCount,
+      data.length / blockAlign
+    ),
+    sampleRate,
+    bitDepth,
+  }
+}
+
 /**
  * Join complete PCM frames into one channel.
  *

package/codec/boundary/stream.js

@@ -72,20 +72,6 @@ function createDummyFrame() {
   }
 }
 
-/**
- * Collect an async iterable.
- *
- * @param {AsyncIterable} frames
- * @returns {Promise<Array>}
- */
-async function collect(frames) {
-  const output = []
-  for await (const frame of frames) {
-    output.push(frame)
-  }
-  return output
-}
-
 /**
  * Encode chronological PCM frames.
  */
@@ -115,22 +101,21 @@ export class AeaStreamingEncoder {
     if (this.finalized) {
       throw new Error('ATRAC1 encoder has already been finalized')
     }
-    for await (const frame of frames) {
-      validateChunk(frame, this.channelCount)
-      if (this.channelCount === 1) {
-        yield this.leftEncoder(frame)
-      } else {
-        const [left, right] = frame
-        yield this.leftEncoder(left)
-        yield this.rightEncoder(right)
-      }
-
-      this.sampleCount += SAMPLES_PER_FRAME
+    for await (const frame of frames) yield* this.push(frame)
+  }
 
-      if (this.onProgress) {
-        this.onProgress(this.frameIndex++)
-      }
-    }
+  /** Encode one chronological frame for either an async or synchronous host. */
+  push(frame) {
+    if (this.finalized)
+      throw new Error('ATRAC1 encoder has already been finalized')
+    validateChunk(frame, this.channelCount)
+    const encoded =
+      this.channelCount === 1
+        ? [this.leftEncoder(frame)]
+        : [this.leftEncoder(frame[0]), this.rightEncoder(frame[1])]
+    this.sampleCount += SAMPLES_PER_FRAME
+    if (this.onProgress) this.onProgress(this.frameIndex++)
+    return encoded
   }
 
   /**
@@ -184,22 +169,29 @@ export class AeaStreamingDecoder {
    */
   async *frames(frames) {
     for await (const frame of frames) {
-      if (this.channelCount === 1) {
-        yield this.trim(this.leftDecoder(frame))
-        this.reportProgress()
-      } else if (this.leftFrame === null) {
-        this.leftFrame = frame
-      } else {
-        yield this.trim([
-          this.leftDecoder(this.leftFrame),
-          this.rightDecoder(frame),
-        ])
-        this.leftFrame = null
-        this.reportProgress()
-      }
+      const decoded = this.push(frame)
+      if (decoded !== null) yield decoded
     }
   }
 
+  /** Decode one sound unit, returning null until a stereo pair is complete. */
+  push(frame) {
+    let decoded
+    if (this.channelCount === 1) decoded = this.trim(this.leftDecoder(frame))
+    else if (this.leftFrame === null) {
+      this.leftFrame = frame
+      return null
+    } else {
+      decoded = this.trim([
+        this.leftDecoder(this.leftFrame),
+        this.rightDecoder(frame),
+      ])
+      this.leftFrame = null
+    }
+    this.reportProgress()
+    return decoded
+  }
+
   /**
    * Complete an unmatched stereo pair.
    *
@@ -294,8 +286,9 @@ export async function encodeAeaPcm(channels, options = {}) {
     channelCount: channels.length,
     encoderOptions: new EncoderOptions(encoderValues),
   })
-  const frames = encoder.frames(frameBufferToFrames(channels))
-  const encoded = await collect(frames)
+  const encoded = []
+  for (const frame of frameBufferToFrames(channels))
+    encoded.push(...encoder.push(frame))
   encoded.push(...encoder.finish())
 
   const header = AeaFile.createHeader(
@@ -339,16 +332,17 @@ export async function decodeAeaPcm(input) {
     primingSampleCount: info.primingSampleCount,
     sampleCount: info.sampleCount,
   })
-  const frames = (async function* () {
-    for (
-      let offset = AEA_HEADER_SIZE;
-      offset + SOUND_UNIT_SIZE <= bytes.length;
-      offset += SOUND_UNIT_SIZE
-    ) {
-      yield deserializeFrame(bytes.subarray(offset, offset + SOUND_UNIT_SIZE))
-    }
-  })()
-  const decoded = await collect(decoder.frames(frames))
+  const decoded = []
+  for (
+    let offset = AEA_HEADER_SIZE;
+    offset + SOUND_UNIT_SIZE <= bytes.length;
+    offset += SOUND_UNIT_SIZE
+  ) {
+    const frame = decoder.push(
+      deserializeFrame(bytes.subarray(offset, offset + SOUND_UNIT_SIZE))
+    )
+    if (frame !== null) decoded.push(frame)
+  }
   decoded.push(...decoder.finish())
 
   if (info.channelCount === 1) {