Week 42 of 2025

function op1OffsetToSampleIndex(num = 0, stereo = false) {
	// i have NO IDEA why it's 2032, i don't understand how that relates to
	// anything. not to 65536, not to 44100, not to 2147483646, not to 12
	// seconds, not to 16 bits. kara points out that it is 127*16, which
	// _are_ both computer numbers. but why?
	// but i've tried all the other numbers and this is the best number,
	// hands down, no question
	// the 1219.2 i got by 2032*12/20
	// (because on the field there are 20 tracks)
	// the "stereo" prop is the indicator that you are reading a field kit
	// it's funny, because there's this drum_version field but that only
	// changed once when they changed the format from big endian to little endian
	// so the effective version number is something you have to calculate from
	// .drum_version and .stereo
	const divisor = stereo == true ? 1219.2 : 2032
	return Math.floor(num / divisor / 2) * 2
}

// todo use text decoder?
/**
 * @param {DataView} view
 * @param {number} offset
 * @param {number} length
 */
function readString(view, offset, length) {
	let chars = []
	for (let i = offset; i <= offset + length - 1; i++) {
		chars.push(view.getUint8(i))
	}

	return String.fromCharCode(...chars.filter(n => n))
}

/**
 * Get the individual chunks of an op-1 drum aif as arraybuffers
 * return array will be .length=1 if aif is not an op-1 kit
 * @param {ArrayBuffer} aif
 * @returns {Array<ArrayBuffer>}
 */
function split(aif) {
	const view = new DataView(aif)
	const sampleRate = -1
	const numberOfChannels = -1
	/** @type {ArrayBuffer?} */
	let ssnd = null

	/** @type {{
	 *    start: number[],
	 *    end: number[],
	 *    stereo: boolean,
	 *    drum_version: number
	 * }?}
	 * */
	let op1Config = null

	for (let offset = 0; offset + 4 < aif.byteLength; offset += 1) {
		const id = readString(view, offset, 4)
		// todo write a chunk lib
		if (id == "COMM") {
			const _len = view.getUint32(offset + 4)
			numberOfChannels = view.getInt16(offset + 8)
			const _numSampleFrames = view.getUint32(offset + 10)
			// `10` tells us this 16-bit audio
			const _sampleSize = view.getInt16(offset + 14)
			// lmao i have no idea how to read a long  double
			// https://wiki.multimedia.cx/index.php/Audio_Interchange_File_Format
			/*
			 * SignBit    1 bit
			 * Exponent   15 bits
			 * Mantissa   64 bits
			 */
			// [becky avery doing chee voice voice] however,
			// on the op-1 and field it's always `0x400EAC44000000000000`,
			// i.e. 44.1k
			sampleRate = 44100
		}

		if (id == "APPL") {
			const len = view.getInt32(offset + 4)
			const op1 = readString(view, offset + 8, 4)
			if (op1 != "op-1") {
				continue
			}
			const json = readString(view, offset + 12, len - 4)
			try {
				op1Config = JSON.parse(json)
			} catch (error) {
				console.error(error)
				console.info(json)
			}
		}

		if (id == "SSND") {
			const len = view.getUint32(offset + 4)
			ssnd = aif.slice(offset + 8, offset + 8 + len)
		}
	}

	if (!ssnd) {
		throw new Error(`did not find pcm block?`)
	}

	if (op1Config && op1Config.drum_version) {
		return op1Config.start
			.map(
				/**
				 * @param {number} s
				 * @param {number} index
				 */
				(s, index) => {
					const e = op1Config.end[index]
					const start = op1OffsetToSampleIndex(s, op1Config.stereo)
					const end = op1OffsetToSampleIndex(e, op1Config.stereo)

					if (start < end) {
						const pcm = ssnd.slice(
							start * numberOfChannels,
							end * numberOfChannels
						)

						return decode16BitPCM(pcm, {
							numberOfChannels,
							sampleRate,
							littleEndian: op1Config.drum_version == 2,
						})
					}
				}
			)
			.filter(Boolean)
	} else {
		return [
			decode16BitPCM(ssnd, {
				numberOfChannels,
				sampleRate,
				// todo detect
				littleEndian: true,
			}),
		]
	}
}

/**
 * @typedef {Object} Decode16BitPCMOptions
 * @prop {number} numberOfChannels
 * @prop {number} sampleRate
 * @prop {boolean} [littleEndian]
 */

/**
 * @param {ArrayBuffer} pcm
 * @param {Decode16BitPCMOptions} options
 */
export function decode16BitPCM(pcm, options) {
	const {numberOfChannels, sampleRate, littleEndian = true} = options
	let audiobuffer = new AudioBuffer({
		numberOfChannels,
		length: pcm.byteLength / numberOfChannels / 2,
		sampleRate,
	})
	for (let channel = 0; channel < numberOfChannels; channel++) {
		let channelData = audiobuffer.getChannelData(channel)
		let view = new DataView(pcm)

		for (
			let i = 0, j = channel * 2;
			i < channelData.length;
			i++, j += numberOfChannels * 2
		) {
			let sample = view.getInt16(j, littleEndian)
			channelData[i] = sample / 0x8000
		}
	}
	return audiobuffer
}