echogarden 1.8.7 → 2.0.0

package/src/audio/AudioBufferConversion.ts

@@ -5,7 +5,7 @@ import { BitDepth, SampleFormat } from '../codecs/WaveCodec.js'
 /////////////////////////////////////////////////////////////////////////////////////////////
 // Low level audio sample conversions
 /////////////////////////////////////////////////////////////////////////////////////////////
-export function encodeToAudioBuffer(audioChannels: Float32Array[], targetBitDepth: BitDepth = 16, targetSampleFormat: SampleFormat = SampleFormat.PCM) {
+export function encodeToAudioBuffer(audioChannels: Float32Array[], targetBitDepth: BitDepth = 16, targetSampleFormat: SampleFormat = SampleFormat.PCM): Uint8Array {
 	const interleavedChannels = interleaveChannels(audioChannels)
 
 	audioChannels = [] // Zero the array references to allow the GC to free up memory, if possible
@@ -32,13 +32,13 @@ export function encodeToAudioBuffer(audioChannels: Float32Array[], targetBitDept
 		}
 	} else if (targetSampleFormat === SampleFormat.Alaw) {
 		if (targetBitDepth === 8) {
-			return Buffer.from(AlawMulaw.alaw.encode(float32ToInt16Pcm(interleavedChannels)))
+			return AlawMulaw.alaw.encode(float32ToInt16Pcm(interleavedChannels))
 		} else {
 			throw new Error(`Unsupported alaw bit depth: ${targetBitDepth}`)
 		}
 	} else if (targetSampleFormat === SampleFormat.Mulaw) {
 		if (targetBitDepth === 8) {
-			return Buffer.from(AlawMulaw.mulaw.encode(float32ToInt16Pcm(interleavedChannels)))
+			return AlawMulaw.mulaw.encode(float32ToInt16Pcm(interleavedChannels))
 		} else {
 			throw new Error(`Unsupported mulaw bit depth: ${targetBitDepth}`)
 		}
@@ -47,7 +47,7 @@ export function encodeToAudioBuffer(audioChannels: Float32Array[], targetBitDept
 	}
 }
 
-export function decodeToChannels(audioBuffer: Buffer, channelCount: number, sourceBitDepth: number, sourceSampleFormat: SampleFormat) {
+export function decodeToChannels(audioBuffer: Uint8Array, channelCount: number, sourceBitDepth: number, sourceSampleFormat: SampleFormat) {
 	let interleavedChannels: Float32Array
 
 	if (sourceSampleFormat === SampleFormat.PCM) {
@@ -86,29 +86,39 @@ export function decodeToChannels(audioBuffer: Buffer, channelCount: number, sour
 		throw new Error(`Unsupported audio format: ${sourceSampleFormat}`)
 	}
 
-	audioBuffer = Buffer.from([]) // Zero the buffer reference to allow the GC to free up memory, if possible
+	audioBuffer = new Uint8Array(0) // Zero the buffer reference to allow the GC to free up memory, if possible
 
 	return deInterleaveChannels(interleavedChannels, channelCount)
 }
 
 // Int8 PCM <-> Float32 conversion
 export function int8PcmToFloat32(input: Int8Array) {
-	const output = new Float32Array(input.length)
+	const sampleCount = input.length
 
-	for (let i = 0; i < input.length; i++) {
-		const sample = input[i]
-		output[i] = sample < 0 ? sample / 128 : sample / 127
+	const output = new Float32Array(sampleCount)
+
+	for (let i = 0; i < sampleCount; i++) {
+		output[i] = input[i] / 128
 	}
 
 	return output
 }
 
 export function float32ToInt8Pcm(input: Float32Array) {
-	const output = new Int8Array(input.length)
+	const sampleCount = input.length
+
+	const output = new Int8Array(sampleCount)
+
+	for (let i = 0; i < sampleCount; i++) {
+		const int8Sample = input[i] * 128
 
-	for (let i = 0; i < input.length; i++) {
-		const sample = clampFloatSample(input[i])
-		output[i] = (sample < 0 ? sample * 128 : sample * 127) | 0
+		if (int8Sample < -128) {
+			output[i] = -128
+		} else if (int8Sample > 127) {
+			output[i] = 127
+		} else {
+			output[i] = int8Sample
+		}
 	}
 
 	return output
@@ -116,22 +126,32 @@ export function float32ToInt8Pcm(input: Float32Array) {
 
 // Int16 PCM <-> Float32 conversion
 export function int16PcmToFloat32(input: Int16Array) {
-	const output = new Float32Array(input.length)
+	const sampleCount = input.length
+
+	const output = new Float32Array(sampleCount)
 
-	for (let i = 0; i < input.length; i++) {
-		const sample = input[i]
-		output[i] = sample < 0 ? sample / 32768 : sample / 32767
+	for (let i = 0; i < sampleCount; i++) {
+		output[i] = input[i] / 32768
 	}
 
 	return output
 }
 
 export function float32ToInt16Pcm(input: Float32Array) {
-	const output = new Int16Array(input.length)
+	const sampleCount = input.length
+
+	const output = new Int16Array(sampleCount)
+
+	for (let i = 0; i < sampleCount; i++) {
+		const int16Sample = input[i] * 32768
 
-	for (let i = 0; i < input.length; i++) {
-		const sample = clampFloatSample(input[i])
-		output[i] = (sample < 0 ? sample * 32768 : sample * 32767) | 0
+		if (int16Sample < -32768) {
+			output[i] = -32768
+		} else if (int16Sample > 32767) {
+			output[i] = 32767
+		} else {
+			output[i] = int16Sample
+		}
 	}
 
 	return output
@@ -139,22 +159,32 @@ export function float32ToInt16Pcm(input: Float32Array) {
 
 // Int24 PCM <-> Float32 conversion (uses int32 for storage)
 export function int24PcmToFloat32(input: Int32Array) {
-	const output = new Float32Array(input.length)
+	const sampleCount = input.length
 
-	for (let i = 0; i < input.length; i++) {
-		const sample = input[i]
-		output[i] = sample < 0 ? sample / 8388608 : sample / 8388607
+	const output = new Float32Array(sampleCount)
+
+	for (let i = 0; i < sampleCount; i++) {
+		output[i] = input[i] / 8388608
 	}
 
 	return output
 }
 
 export function float32ToInt24Pcm(input: Float32Array) {
-	const output = new Int32Array(input.length)
+	const sampleCount = input.length
 
-	for (let i = 0; i < input.length; i++) {
-		const sample = clampFloatSample(input[i])
-		output[i] = (sample < 0 ? sample * 8388608 : sample * 8388607) | 0
+	const output = new Int32Array(sampleCount)
+
+	for (let i = 0; i < sampleCount; i++) {
+		const int24Sample = input[i] * 8388608
+
+		if (int24Sample < -8388608) {
+			output[i] = -8388608
+		} else if (int24Sample > 8388607) {
+			output[i] = 8388607
+		} else {
+			output[i] = int24Sample
+		}
 	}
 
 	return output
@@ -162,22 +192,32 @@ export function float32ToInt24Pcm(input: Float32Array) {
 
 // Int32 PCM <-> Float32 conversion
 export function int32PcmToFloat32(input: Int32Array) {
-	const output = new Float32Array(input.length)
+	const sampleCount = input.length
+
+	const output = new Float32Array(sampleCount)
 
-	for (let i = 0; i < input.length; i++) {
-		const sample = input[i]
-		output[i] = sample < 0 ? sample / 2147483648 : sample / 2147483647
+	for (let i = 0; i < sampleCount; i++) {
+		output[i] = input[i] / 2147483648
 	}
 
 	return output
 }
 
 export function float32ToInt32Pcm(input: Float32Array) {
-	const output = new Int32Array(input.length)
+	const sampleCount = input.length
+
+	const output = new Int32Array(sampleCount)
 
-	for (let i = 0; i < input.length; i++) {
-		const sample = clampFloatSample(input[i])
-		output[i] = (sample < 0 ? sample * 2147483648 : sample * 2147483647) | 0
+	for (let i = 0; i < sampleCount; i++) {
+		const int32Sample = input[i] * 2147483648
+
+		if (int32Sample < -2147483648) {
+			output[i] = -2147483648
+		} else if (int32Sample > 2147483647) {
+			output[i] = 2147483647
+		} else {
+			output[i] = int32Sample
+		}
 	}
 
 	return output
@@ -202,10 +242,9 @@ export function interleaveChannels(channels: Float32Array[]) {
 
 	let writeIndex = 0
 
-	for (let i = 0; i < sampleCount; i++) {
-		for (let c = 0; c < channelCount; c++) {
-			result[writeIndex] = channels[c][i]
-			writeIndex += 1
+	for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex++) {
+		for (let channelIndex = 0; channelIndex < channelCount; channelIndex++) {
+			result[writeIndex++] = channels[channelIndex][sampleIndex]
 		}
 	}
 
@@ -226,6 +265,7 @@ export function deInterleaveChannels(interleavedChannels: Float32Array, channelC
 	}
 
 	const sampleCount = interleavedChannels.length / channelCount
+
 	const channels: Float32Array[] = []
 
 	for (let i = 0; i < channelCount; i++) {
@@ -234,10 +274,9 @@ export function deInterleaveChannels(interleavedChannels: Float32Array, channelC
 
 	let readIndex = 0
 
-	for (let i = 0; i < sampleCount; i++) {
-		for (let c = 0; c < channelCount; c++) {
-			channels[c][i] = interleavedChannels[readIndex]
-			readIndex += 1
+	for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex++) {
+		for (let channelIndex = 0; channelIndex < channelCount; channelIndex++) {
+			channels[channelIndex][sampleIndex] = interleavedChannels[readIndex++]
 		}
 	}
 

package/src/audio/AudioPlayer.ts

@@ -2,37 +2,36 @@ import { parentPort } from 'node:worker_threads'
 
 import { ChildProcessWithoutNullStreams, spawn } from 'child_process'
 
-import { RawAudio, encodeRawAudioToWave, fadeAudioInOut, getRawAudioDuration, sliceRawAudioByTime } from './AudioUtilities.js'
-import * as AudioBufferConversion from './AudioBufferConversion.js'
+import { RawAudio, encodeRawAudioToWave, fadeAudioInOut, getRawAudioDuration, sliceAudioChannels, sliceRawAudioByTime } from './AudioUtilities.js'
 import * as FFMpegTranscoder from '../codecs/FFMpegTranscoder.js'
 
 import { Timer } from '../utilities/Timer.js'
-import { getRandomHexString, waitTimeout, writeToStderr } from '../utilities/Utilities.js'
-import { encodeToAudioBuffer } from './AudioBufferConversion.js'
+import { clip, getRandomHexString, waitTimeout, writeToStderr } from '../utilities/Utilities.js'
+import { encodeToAudioBuffer, float32ToInt16Pcm, interleaveChannels } from './AudioBufferConversion.js'
 import { OpenPromise } from '../utilities/OpenPromise.js'
 import { Timeline, addWordTextOffsetsToTimeline } from '../utilities/Timeline.js'
-import { readAndParseJsonFile, readFile, remove, writeFile } from '../utilities/FileSystem.js'
+import { readAndParseJsonFile, readFileAsUtf8, remove, writeFile } from '../utilities/FileSystem.js'
 import { tryResolvingSoxPath } from './SoxPath.js'
 import { SignalChannel } from '../utilities/SignalChannel.js'
 import { deepClone } from '../utilities/ObjectUtilities.js'
 import { appName } from '../api/Common.js'
-import path from 'node:path'
-import { getAppTempDir } from '../utilities/PathUtilities.js'
+import { getAppTempDir, joinPath } from '../utilities/PathUtilities.js'
+import { type AudioOutput } from '@echogarden/audio-io'
 
-export async function playAudioFileWithTimelineFile(audioFilename: string, timelineFileName: string, transcriptFileName?: string) {
+export async function playAudioFileWithTimelineFile(audioFilename: string, timelineFileName: string, transcriptFileName?: string, player?: AudioPlayerID) {
 	const rawAudio = await FFMpegTranscoder.decodeToChannels(audioFilename, 48000, 1)
 
 	const timeline = await readAndParseJsonFile(timelineFileName)
 
 	let transcript: string | undefined
 	if (transcriptFileName) {
-		transcript = await readFile(transcriptFileName, 'utf8')
+		transcript = await readFileAsUtf8(transcriptFileName)
 	}
 
-	await playAudioWithWordTimeline(rawAudio, timeline, transcript)
+	await playAudioWithWordTimeline(rawAudio, timeline, transcript, player)
 }
 
-export async function playAudioWithWordTimeline(rawAudio: RawAudio, wordTimeline: Timeline, transcript?: string) {
+export async function playAudioWithWordTimeline(rawAudio: RawAudio, wordTimeline: Timeline, transcript?: string, player?: AudioPlayerID) {
 	if (!transcript) {
 		transcript = wordTimeline.map(entry => entry.text).join(' ')
 	}
@@ -82,77 +81,178 @@ export async function playAudioWithWordTimeline(rawAudio: RawAudio, wordTimeline
 	const keypressListenerStartTimestamp = Date.now()
 
 	function keypressHandler(message: any) {
-		if (message.name == 'keypress' &&
-			message.key.name == 'return' &&
-			message.timestamp >= keypressListenerStartTimestamp) {
+		if (message.name === 'keypress') {
+			//console.log(`Keypress: ${message.key.name}`)
 
-			signalChannel.send('abort')
+			if (message.timestamp < keypressListenerStartTimestamp) {
+				return
+			}
+
+			const keyName = message.key.name
+
+			if (keyName === 'return') {
+				signalChannel.send('abort')
+			} else if (keyName === 'left') {
+				signalChannel.send('skip', -1)
+			} else if (keyName === 'right') {
+				signalChannel.send('skip', 1)
+
+				if (false) {
+					const nextTimelineEntryIndex = timelineEntryIndex
+
+					if (nextTimelineEntryIndex < wordTimeline.length) {
+						//signalChannel.send('skip', 5)
+						const targetTime = wordTimeline[nextTimelineEntryIndex].startTime
+
+						signalChannel.send('seek', targetTime)
+					}
+				}
+			} else if (keyName === 'space') {
+				signalChannel.send('togglePause')
+			}
 		}
 	}
 
 	parentPort?.on('message', keypressHandler)
 
-	await playAudioSamples(rawAudio, onTimePosition, signalChannel)
+	await playAudioSamples(rawAudio, onTimePosition, signalChannel, player)
 
 	parentPort?.off('message', keypressHandler)
 
 	writeToStderr('\n')
 }
 
-export async function playAudioWithTimelinePhones(rawAudio: RawAudio, timeline: Timeline) {
-	let wordIndex = 0
-	let phoneIndex = 0
+export async function playAudioSamplesWithKeyboardControls(rawAudio: RawAudio, player?: AudioPlayerID) {
+	const signalChannel = new SignalChannel()
 
-	function onTimePosition(timePosition: number) {
-		for (; wordIndex < timeline.length; wordIndex++) {
-			const wordEntry = timeline[wordIndex]
-			const phoneTimeline = wordEntry.timeline!
+	const keypressListenerStartTimestamp = Date.now()
 
-			if (phoneTimeline.every(phoneEntry => phoneEntry.text == '')) {
-				continue
-			}
+	function keypressHandler(message: any) {
+		if (message.name === 'keypress') {
+			//console.log(`Keypress: ${message.key.name}`)
 
-			for (; phoneIndex < phoneTimeline.length; phoneIndex++) {
-				const entry = phoneTimeline[phoneIndex]
+			if (message.timestamp < keypressListenerStartTimestamp) {
+				return
+			}
 
-				if (entry.startTime > timePosition) {
-					return
-				}
+			const keyName = message.key.name
 
-				writeToStderr(`${entry.text} `)
+			if (keyName === 'return') {
+				signalChannel.send('abort')
+			} else if (keyName === 'left') {
+				signalChannel.send('skip', -1)
+			} else if (keyName === 'right') {
+				signalChannel.send('skip', 1)
+			} else if (keyName === 'space') {
+				signalChannel.send('togglePause')
 			}
-
-			writeToStderr(`| `)
-			phoneIndex = 0
 		}
 	}
 
-	writeToStderr('\n')
+	parentPort?.on('message', keypressHandler)
 
-	await playAudioSamples(rawAudio, onTimePosition)
+	await playAudioSamples(rawAudio, undefined, signalChannel, player)
 
-	writeToStderr('\n')
+	parentPort?.off('message', keypressHandler)
+}
+
+export function playAudioSamples(rawAudio: RawAudio, onTimePosition?: (timePosition: number) => void, signalChannel?: SignalChannel, player?: AudioPlayerID) {
+	if (!player) {
+		player = 'audio-io'
+	}
+
+	if (player === 'audio-io') {
+		return playAudioSamples_AudioIO(rawAudio, onTimePosition, signalChannel)
+	} else if (player === 'sox') {
+		return playAudioSamples_Sox(rawAudio, onTimePosition, signalChannel)
+	} else {
+		throw new Error(`Unsupported audio player ID: ${player}`)
+	}
 }
 
+export async function playAudioSamples_AudioIO(rawAudio: RawAudio, onTimePosition?: (timePosition: number) => void, signalChannel?: SignalChannel) {
+	const openPromise = new OpenPromise()
+
+	const sampleRate = rawAudio.sampleRate
+	const channelCount = rawAudio.audioChannels.length
+	const bufferDuration = 100.0
+	const audioFrameCount = rawAudio.audioChannels[0].length
+	const audioDuration = getRawAudioDuration(rawAudio)
+
+	const { createAudioOutput } = await import('@echogarden/audio-io')
+
+	let frameOffset = 0
+	let audioOutput: AudioOutput
+	let abortRequested = false
+	let ended = false
+
+	let isPaused = false
+
+	// Define an audio output handler function
+	async function audioOutputHandler(outputBuffer: Int16Array) {
+		if (ended) {
+			return
+		}
+
+		if (onTimePosition) {
+			const audioTime = Math.min(frameOffset / sampleRate, audioDuration)
+
+			onTimePosition(audioTime)
+		}
+
+		if (isPaused) {
+			return
+		}
+
+		const chunkFrameCount = outputBuffer.length / channelCount
+
+		const floatAudioChunk = sliceAudioChannels(rawAudio.audioChannels, frameOffset, frameOffset + chunkFrameCount)
+		const interleavedFloatAudioChunk = interleaveChannels(floatAudioChunk)
+		const int16AudioChunk = float32ToInt16Pcm(interleavedFloatAudioChunk)
 
-export async function playAudioPairWithTimelineInterleaved(rawAudio1: RawAudio, rawAudio2: RawAudio, timeline1: Timeline, timeline2: Timeline) {
-	if (timeline1.length != timeline2.length) {
-		throw new Error('Timelines have different lengths')
+		outputBuffer.set(int16AudioChunk)
+
+		frameOffset += chunkFrameCount
+
+		if (abortRequested || int16AudioChunk.length < outputBuffer.length) {
+			ended = true
+
+			await audioOutput.dispose()
+			openPromise.resolve()
+		}
 	}
 
-	for (let i = 0; i < timeline1.length; i++) {
-		writeToStderr(`${timeline1[i].text} `)
+	if (signalChannel) {
+		signalChannel.on('abort', () => {
+			abortRequested = true
+		})
+
+		signalChannel.on('skip', (durationToSkip: number) => {
+			frameOffset += durationToSkip * sampleRate
+			frameOffset = Math.floor(frameOffset)
+			frameOffset = clip(frameOffset, 0, audioFrameCount)
+		})
 
-		await playAudioSamples(sliceRawAudioByTime(rawAudio1, timeline1[i].startTime, timeline1[i].endTime))
-		await waitTimeout(200)
-		await playAudioSamples(sliceRawAudioByTime(rawAudio2, timeline2[i].startTime, timeline2[i].endTime))
-		await waitTimeout(500)
+		signalChannel.on('seek', (timeToSeekTo: number) => {
+			frameOffset = Math.floor(timeToSeekTo * sampleRate)
+			frameOffset = clip(frameOffset, 0, audioFrameCount)
+		})
+
+		signalChannel.on('togglePause', () => {
+			isPaused = !isPaused
+		})
 	}
 
-	writeToStderr('\n')
+	audioOutput = await createAudioOutput({
+		sampleRate, // Sample rate in Hz, should be an integer like 44100, 22050, 8000
+		channelCount, // Channel count, likely 1 (mono), or 2 (stereo)
+		bufferDuration, // Target buffer duration, in milliseconds. Defaults to 100.0
+	}, audioOutputHandler)
+
+	return openPromise.promise
 }
 
-export function playAudioSamples(rawAudio: RawAudio, onTimePosition?: (timePosition: number) => void, signalChannel?: SignalChannel, microFadeInOut = true) {
+export function playAudioSamples_Sox(rawAudio: RawAudio, onTimePosition?: (timePosition: number) => void, signalChannel?: SignalChannel, microFadeInOut = true) {
 	return new Promise<void>(async (resolve, reject) => {
 		if (microFadeInOut) {
 			rawAudio = fadeAudioInOut(rawAudio, 0.0025)
@@ -180,7 +280,7 @@ export function playAudioSamples(rawAudio: RawAudio, onTimePosition?: (timePosit
 		}
 
 		let tempFilePath: string | undefined
-		let audioBuffer: Buffer | undefined
+		let audioBuffer: Uint8Array | undefined
 
 		async function cleanup() {
 			if (tempFilePath) {
@@ -199,7 +299,7 @@ export function playAudioSamples(rawAudio: RawAudio, onTimePosition?: (timePosit
 				{}
 			)
 		} else {
-			tempFilePath = path.join(getAppTempDir(appName), `${getRandomHexString(16)}.wav`)
+			tempFilePath = joinPath(getAppTempDir(appName), `${getRandomHexString(16)}.wav`)
 			const waveFileBuffer = encodeRawAudioToWave(rawAudio)
 			await writeFile(tempFilePath, waveFileBuffer)
 
@@ -282,7 +382,7 @@ export function playAudioSamples_Speaker(rawAudio: RawAudio, onTimePosition?: (t
 		}
 
 		const channelCount = rawAudio.audioChannels.length
-		let audioData = AudioBufferConversion.encodeToAudioBuffer(rawAudio.audioChannels)
+		let audioData = encodeToAudioBuffer(rawAudio.audioChannels)
 
 		const { default: Speaker } = await import('speaker')
 
@@ -315,7 +415,7 @@ export function playAudioSamples_Speaker(rawAudio: RawAudio, onTimePosition?: (t
 			mpg123AudioBufferSize = bytesPerSecond * mpg123AudioBufferDuration
 		}
 
-		audioData = concatBuffers([audioData, Buffer.alloc(mpg123AudioBufferSize)])
+		audioData = concatUint8Arrays([audioData, new Uint8Array(mpg123AudioBufferSize)])
 
 		const maxChunkSize = mpg123AudioBufferSize
 
@@ -363,3 +463,5 @@ export const charactersToWriteAhead = [
 	')', ']', '}', `"`, `'`, '”', '’',
 	'-', '—', '»', '،', '؟'
 ]
+
+export type AudioPlayerID = 'audio-io' | 'sox'

package/src/audio/AudioUtilities.ts

@@ -11,7 +11,7 @@ export function encodeRawAudioToWave(rawAudio: RawAudio, bitDepth: BitDepth = 16
 	return encodeWave(rawAudio, bitDepth, sampleFormat, speakerPositionMask)
 }
 
-export function decodeWaveToRawAudio(waveFileBuffer: Buffer, ignoreTruncatedChunks = true, ignoreOverflowingDataChunks = true) {
+export function decodeWaveToRawAudio(waveFileBuffer: Uint8Array, ignoreTruncatedChunks = true, ignoreOverflowingDataChunks = true) {
 	return decodeWave(waveFileBuffer, ignoreTruncatedChunks, ignoreOverflowingDataChunks)
 }
 
@@ -401,33 +401,25 @@ export function getRawAudioDuration(rawAudio: RawAudio) {
 export async function ensureRawAudio(input: AudioSourceParam, outSampleRate?: number, outChannelCount?: number) {
 	let inputAsRawAudio: RawAudio = input as RawAudio
 
-	if (inputAsRawAudio.audioChannels?.length > 0 && inputAsRawAudio.sampleRate) {
+	if (isRawAudio(input)) {
 		const inputAudioChannelCount = inputAsRawAudio.audioChannels.length
 
 		if (outChannelCount == 1 && inputAudioChannelCount > 1) {
 			inputAsRawAudio = downmixToMono(inputAsRawAudio)
-		}
-
-		if (outChannelCount == 2 && inputAudioChannelCount == 1) {
+		} else if (outChannelCount == 2 && inputAudioChannelCount == 1) {
 			inputAsRawAudio = cloneRawAudio(inputAsRawAudio)
 			inputAsRawAudio.audioChannels.push(inputAsRawAudio.audioChannels[0].slice())
-		}
-
-		if (outChannelCount != null && outChannelCount > 2 && outChannelCount != inputAudioChannelCount) {
+		} else if (outChannelCount != null && outChannelCount > 2 && outChannelCount != inputAudioChannelCount) {
 			throw new Error(`Can't convert ${inputAudioChannelCount} channels to ${outChannelCount} channels. Channel conversion of raw audio currently only supports mono and stereo inputs.`)
 		}
 
-		if (outSampleRate && inputAsRawAudio.sampleRate != outSampleRate) {
+		if (outSampleRate && inputAsRawAudio.sampleRate !== outSampleRate) {
 			inputAsRawAudio = await resampleAudioSpeex(inputAsRawAudio, outSampleRate)
 		}
 	} else if (typeof input == 'string' || input instanceof Uint8Array) {
-		if (input instanceof Uint8Array && !Buffer.isBuffer(input)) {
-			input = Buffer.from(input)
-		}
-
-		const inputAsStringOrBuffer = input as string | Buffer
+		const inputAsStringOrUint8Array = input as string | Uint8Array
 
-		inputAsRawAudio = await FFMpegTranscoder.decodeToChannels(inputAsStringOrBuffer, outSampleRate, outChannelCount)
+		inputAsRawAudio = await FFMpegTranscoder.decodeToChannels(inputAsStringOrUint8Array, outSampleRate, outChannelCount)
 	} else {
 		throw new Error('Received an invalid input audio data type.')
 	}
@@ -436,21 +428,45 @@ export async function ensureRawAudio(input: AudioSourceParam, outSampleRate?: nu
 }
 
 export function subtractAudio(audio1: RawAudio, audio2: RawAudio) {
-	const sampleCount = audio1.audioChannels[0].length
+	if (audio1.sampleRate !== audio2.sampleRate) {
+		throw new Error(`Audio sequences have different sample rates`)
+	}
+
+	if (audio1.audioChannels.length !== audio2.audioChannels.length) {
+		throw new Error(`Audio sequences have different channel counts`)
+	}
+
+	const sampleRate = audio1.sampleRate
+	const channelCount = audio1.audioChannels.length
+	const sampleCount = Math.min(audio1.audioChannels[0].length, audio2.audioChannels[0].length)
+
+	const subtractedAudioChannels: Float32Array[] = []
+
+	for (let channelIndex = 0; channelIndex < channelCount; channelIndex++) {
+		const subtractedSamples = new Float32Array(sampleCount)
 
-	const subtractedAudioChannels = [new Float32Array(sampleCount), new Float32Array(sampleCount)]
+		const samples1 = audio1.audioChannels[channelIndex]
+		const samples2 = audio2.audioChannels[channelIndex]
 
-	for (let i = 0; i < sampleCount; i++) {
-		for (let channelIndex = 0; channelIndex < 2; channelIndex++) {
-			subtractedAudioChannels[channelIndex][i] = audio1.audioChannels[channelIndex][i] - audio2.audioChannels[channelIndex][i]
+		for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex++) {
+			subtractedSamples[sampleIndex] = samples1[sampleIndex] - samples2[sampleIndex]
 		}
+
+		subtractedAudioChannels.push(subtractedSamples)
 	}
 
-	const subtractedRawAudio: RawAudio = { audioChannels: subtractedAudioChannels, sampleRate: audio1.sampleRate }
+	const subtractedRawAudio: RawAudio = {
+		audioChannels: subtractedAudioChannels,
+		sampleRate: sampleRate
+	}
 
 	return subtractedRawAudio
 }
 
+export function isRawAudio(obj: any): obj is RawAudio {
+	return typeof obj === 'object' && typeof obj.sampleRate === 'number' && Array.isArray(obj.audioChannels)
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////
 // Unit conversion
 ////////////////////////////////////////////////////////////////////////////////////////////////
@@ -492,4 +508,4 @@ export type AudioEncoding = {
 	bitrate?: number
 }
 
-export type AudioSourceParam = string | Buffer | Uint8Array | RawAudio
+export type AudioSourceParam = string | Uint8Array | RawAudio