@audio/decode-aiff 1.2.3 → 1.3.1

package/README.md

@@ -1,7 +1,6 @@
 # @audio/decode-aiff
 
-Decode AIFF and AIFF-C audio to PCM float samples.<br>
-Part of [decode](https://github.com/audiojs/decode).
+Decode AIFF and AIFF-C audio to PCM float samples.
 
 ## Install
 
@@ -12,42 +11,36 @@ npm i @audio/decode-aiff
 ## Usage
 
 ```js
-import decode from '@audio/decode-aiff'
+import decode, { decoder } from '@audio/decode-aiff'
 
-let { channelData, sampleRate } = await decode(aiffBuffer)
-// channelData: Float32Array[] (one per channel)
-// sampleRate: number
-```
-
-### Streaming
+let { channelData, sampleRate } = decode(aiffBytes)
 
-```js
-import { decoder } from '@audio/decode-aiff'
-
-let dec = await decoder()
+let dec = decoder()
 let result = dec.decode(chunk)
 dec.free()
 ```
 
+`decode()` and `decoder()` are synchronous.
+
 ## API
 
-### `decode(src): Promise<AudioData>`
+### `decode(src): AudioData`
 
-Whole-file decode. Accepts `Uint8Array` or `ArrayBuffer`.
+Decode a complete `Uint8Array` or `ArrayBuffer`.
 
-### `decoder(): Promise<AIFFDecoder>`
+### `decoder(): AIFFDecoder`
 
-Creates a decoder instance.
+Create a decoder instance.
 
-- **`dec.decode(data)`** — decode chunk, returns `{ channelData, sampleRate }`
-- **`dec.flush()`** — flush (returns empty — AIFF is stateless)
-- **`dec.free()`** — release resources
+- `dec.decode(data)`: decode a chunk.
+- `dec.flush()`: decode buffered `ima4` or `GSM` data; otherwise return an empty result.
+- `dec.free()`: release resources.
 
 ## Formats
 
-- AIFF — 8, 16, 24, 32-bit signed integer PCM (big-endian)
-- AIFF-C — `NONE`/`twos` (BE PCM), `sowt` (LE PCM), `fl32`/`fl64` (float), `alaw`, `ulaw`
+- AIFF: 8, 16, 24, and 32-bit signed big-endian PCM.
+- AIFF-C: `NONE`/`twos`, `sowt`, `fl32`, `fl64`, `alaw`, `ulaw`, `ima4`, and `GSM`.
 
 ## License
 
-MIT — [krishnized](https://github.com/krishnized/license)
+[ॐ](https://github.com/krishnized/license/) · [MIT](./LICENSE)

package/decode-aiff.d.ts

@@ -1,16 +1,16 @@
-interface AudioData {
+export interface AudioData {
   channelData: Float32Array[];
   sampleRate: number;
 }
 
 interface AIFFDecoder {
-  decode(data: Uint8Array): AudioData;
+  decode(data: Uint8Array | ArrayBuffer): AudioData;
   flush(): AudioData;
   free(): void;
 }
 
-/** Decode AIFF/AIFF-C audio buffer to PCM samples */
-export default function decode(src: ArrayBuffer | Uint8Array): Promise<AudioData>;
+/** Decode a complete AIFF or AIFF-C file synchronously. */
+export default function decode(src: ArrayBuffer | Uint8Array): AudioData;
 
-/** Create decoder instance */
-export function decoder(): Promise<AIFFDecoder>;
+/** Create a synchronous decoder. */
+export function decoder(): AIFFDecoder;

package/decode-aiff.js

@@ -292,8 +292,12 @@ function asr(x, n) {
 }
 
 function decodeGSM(b, ssndOff, ssndSize, nCh, nFrames, sr) {
-	let totalFrames = Math.min(nFrames, Math.floor(ssndSize / 33))
-	let channelData = [new Float32Array(totalFrames * 160)]
+	let blocks = Math.floor(Math.min(ssndSize, b.length - ssndOff) / 33)
+	// COMM counts samples (libsndfile, so Audacity), or blocks as Apple counts ima4
+	let len = nFrames > blocks ? Math.min(nFrames, blocks * 160) : nFrames * 160
+	let totalFrames = Math.ceil(len / 160)
+	// the last block's padding past len falls off the array (typed arrays drop out-of-range writes)
+	let channelData = [new Float32Array(len)]
 	let out = channelData[0], p = ssndOff
 
 	// Decoder state (mirrors struct gsm_state)
@@ -372,9 +376,9 @@ function decodeGSM(b, ssndOff, ssndSize, nCh, nFrames, sr) {
 	return { channelData, sampleRate: sr }
 }
 
-// GSM 6.10 bit unpacking: 33 bytes → LARc[8] + 4 subframes
+// GSM 6.10 bit unpacking: 33 bytes = 0xD signature nibble + 260 bits of LARc[8] and 4 subframes
 function gsmBits(buf, off) {
-	let bc = 0
+	let bc = 4
 	function r(n) {
 		let val = 0
 		for (let i = 0; i < n; i++) {
@@ -441,7 +445,7 @@ function gsmRpeDecode(xmaxc, Mc, xMc, erp) {
 	// 4.2.16: APCM inverse quantization
 	let fac = GSM_FAC[mant]
 	let shift = 6 - exp
-	let round = shift > 1 ? 1 << (shift - 1) : 0  // gsm_asl(1, shift-1)
+	let round = shift > 0 ? 1 << (shift - 1) : 0  // gsm_asl(1, shift-1)
 
 	let xMp = new Int32Array(13)
 	for (let i = 0; i < 13; i++) {
@@ -456,14 +460,10 @@ function gsmRpeDecode(xmaxc, Mc, xMc, erp) {
 	for (let i = 0; i < 13; i++) erp[Mc + 3 * i] = xMp[i]
 }
 
-/**
- * Whole-file decode
- * @param {Uint8Array|ArrayBuffer} src
- * @returns {Promise<{channelData: Float32Array[], sampleRate: number}>}
- */
-export default async function decode(src) {
+/** Decode a complete AIFF file synchronously. */
+export default function decode(src) {
 	let buf = src instanceof Uint8Array ? src : src instanceof ArrayBuffer ? new Uint8Array(src) : src
-	let dec = await decoder()
+	let dec = decoder()
 	try {
 		let result = dec.decode(buf)
 		if (!result.channelData.length) result = dec.flush()
@@ -473,27 +473,26 @@ export default async function decode(src) {
 	}
 }
 
-/**
- * Create decoder instance
- * @returns {Promise<{decode(chunk: Uint8Array): {channelData, sampleRate}, flush(), free()}>}
- */
-export async function decoder() {
-	let hdr = null, left = null, freed = false
+/** Create a synchronous decoder. */
+export function decoder() {
+	let hdr = null, left = null, deferredChunks = null, deferredLength = 0, freed = false
 	return {
 		decode(data) {
 			if (freed) throw Error('Decoder already freed')
-			if (!data?.length) return EMPTY
+			if (!data || !data.byteLength) return EMPTY
 			let chunk = data instanceof Uint8Array ? data : new Uint8Array(data)
 			if (left) { chunk = cat(left, chunk); left = null }
 			if (!hdr) {
 				hdr = scanAiffHdr(chunk)
 				if (!hdr) { left = chunk.slice(); return EMPTY }
-				// IMA4/GSM: buffer all SSND data, decode on flush
-				if (hdr.comp === 'ima4' || hdr.comp === 'GSM ' || hdr.comp === 'gsm ') {
-					left = chunk.slice()
-					return EMPTY
-				}
-				chunk = chunk.subarray(hdr.dataStart)
+				deferredChunks = hdr.comp === 'ima4' || hdr.comp === 'GSM ' || hdr.comp === 'gsm ' ? [] : null
+				if (!deferredChunks) chunk = chunk.subarray(hdr.dataStart)
+			}
+			// IMA4 and GSM need the complete container.
+			if (deferredChunks) {
+				deferredChunks.push(new Uint8Array(chunk))
+				deferredLength += chunk.length
+				return EMPTY
 			}
 			let fb = hdr.frameBytes
 			let complete = Math.floor(chunk.length / fb) * fb
@@ -502,15 +501,16 @@ export async function decoder() {
 			return decodeAiffRaw(chunk.subarray(0, complete), hdr)
 		},
 		flush() {
-			if (hdr && left && (hdr.comp === 'ima4' || hdr.comp === 'GSM ' || hdr.comp === 'gsm ')) {
-				let result = parseAiff(left)
-				left = null
-				return result
+			if (deferredChunks && deferredLength) {
+				let input = new Uint8Array(deferredLength), offset = 0
+				for (let chunk of deferredChunks) { input.set(chunk, offset); offset += chunk.length }
+				deferredChunks = []; deferredLength = 0
+				return parseAiff(input)
 			}
 			left = null
 			return EMPTY
 		},
-		free() { freed = true; left = null; hdr = null },
+		free() { freed = true; left = null; hdr = null; deferredChunks = null; deferredLength = 0 },
 	}
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@audio/decode-aiff",
-  "version": "1.2.3",
+  "version": "1.3.1",
   "description": "Decode AIFF/AIFF-C audio to PCM samples",
   "type": "module",
   "main": "decode-aiff.js",