carta1 1.1.10 → 1.3.0

package/codec/boundary/stream.js

@@ -0,0 +1,361 @@
+/**
+ * Carta1 chronological stream adapters.
+ */
+
+import {
+  AEA_HEADER_SIZE,
+  SAMPLES_PER_FRAME,
+  SOUND_UNIT_SIZE,
+  STREAM_FLUSH_TAIL_FRAMES,
+  STREAM_PRIMING_SAMPLES,
+} from '../core/constants.js'
+import { EncoderOptions } from '../core/options.js'
+import { decode } from '../pipeline/decoder.js'
+import { encode } from '../pipeline/encoder.js'
+import { deserializeFrame, serializeFrame } from '../syntax/frame.js'
+import { AeaFile } from './container.js'
+import { frameBufferToFrames, joinChannelFrames } from './pcm.js'
+
+/**
+ * Validate a supported channel mode.
+ *
+ * @param {number} channelCount
+ * @throws {Error} If the channel count is unsupported
+ */
+function validateChannels(channelCount) {
+  if (channelCount !== 1 && channelCount !== 2) {
+    throw new Error(`Unsupported channel count: ${channelCount}`)
+  }
+}
+
+/**
+ * Validate one PCM frame in the selected channel mode.
+ *
+ * @param {object} frame
+ * @param {number} channelCount
+ * @throws {TypeError} If the frame does not match the selected mode
+ * @throws {RangeError} If a selected channel is not one complete frame
+ */
+function validateChunk(frame, channelCount) {
+  const channels = channelCount === 1 ? [frame] : frame
+  if (
+    !Array.isArray(channels) ||
+    channels.length !== channelCount ||
+    channels.some((channel) => !(channel instanceof Float32Array))
+  ) {
+    throw new TypeError(
+      `ATRAC1 streaming requires ${channelCount} Float32 channel${
+        channelCount === 1 ? '' : 's'
+      } per frame`
+    )
+  }
+
+  if (channels.some((channel) => channel.length !== SAMPLES_PER_FRAME)) {
+    throw new RangeError(
+      `ATRAC1 streaming requires exactly ${SAMPLES_PER_FRAME} samples per channel`
+    )
+  }
+}
+
+/**
+ * Create an empty structured frame for an unmatched stereo channel.
+ *
+ * @returns {object}
+ */
+function createDummyFrame() {
+  return {
+    nBfu: 0,
+    blockModes: [0, 0, 0],
+    scaleFactorIndices: new Int32Array(0),
+    wordLengthIndices: new Int32Array(0),
+    quantizedCoefficients: [],
+  }
+}
+
+/**
+ * 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.
+ */
+export class AeaStreamingEncoder {
+  /**
+   * @param {object} [options]
+   */
+  constructor(options = {}) {
+    const { channelCount = 1, onProgress, encoderOptions } = options
+    validateChannels(channelCount)
+
+    const codecOptions = encoderOptions || new EncoderOptions()
+    this.channelCount = channelCount
+    this.onProgress = onProgress
+    this.frameIndex = 0
+    this.sampleCount = 0
+    this.finalized = false
+    this.leftEncoder = encode(codecOptions)
+    this.rightEncoder = channelCount === 2 ? encode(codecOptions) : null
+  }
+
+  /**
+   * @param {AsyncIterable<object>} frames
+   * @returns {AsyncGenerator<object>}
+   */
+  async *frames(frames) {
+    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
+
+      if (this.onProgress) {
+        this.onProgress(this.frameIndex++)
+      }
+    }
+  }
+
+  /**
+   * Flush the synthesis tail after a nonempty stream.
+   *
+   * @returns {Generator<object>}
+   */
+  *finish() {
+    if (this.finalized) return
+    this.finalized = true
+    if (this.sampleCount === 0) return
+    const silence = new Float32Array(SAMPLES_PER_FRAME)
+    for (let frame = 0; frame < STREAM_FLUSH_TAIL_FRAMES; frame++) {
+      yield this.leftEncoder(silence)
+      if (this.channelCount === 2) yield this.rightEncoder(silence)
+    }
+  }
+}
+
+/**
+ * Decode chronological structured frames.
+ */
+export class AeaStreamingDecoder {
+  /**
+   * @param {object} [options]
+   */
+  constructor(options = {}) {
+    const {
+      channelCount = 1,
+      onProgress,
+      primingSampleCount = 0,
+      sampleCount = Number.POSITIVE_INFINITY,
+    } = options
+    validateChannels(channelCount)
+
+    this.channelCount = channelCount
+    this.onProgress = onProgress
+    this.frameIndex = 0
+    this.primingSampleCount = primingSampleCount
+    this.sampleCount = sampleCount
+    this.timelinePosition = 0
+    this.emittedSamples = 0
+    this.leftFrame = null
+    this.leftDecoder = decode()
+    this.rightDecoder = channelCount === 2 ? decode() : null
+  }
+
+  /**
+   * @param {AsyncIterable<object>} frames
+   * @returns {AsyncGenerator<object>}
+   */
+  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()
+      }
+    }
+  }
+
+  /**
+   * Complete an unmatched stereo pair.
+   *
+   * @returns {Generator<[Float32Array, Float32Array]>}
+   */
+  *finish() {
+    if (this.channelCount === 2 && this.leftFrame !== null) {
+      yield this.trim([
+        this.leftDecoder(this.leftFrame),
+        this.rightDecoder(createDummyFrame()),
+      ])
+      this.leftFrame = null
+      this.reportProgress()
+    }
+    if (
+      Number.isFinite(this.sampleCount) &&
+      this.emittedSamples !== this.sampleCount
+    ) {
+      throw new RangeError(
+        `Truncated ATRAC1 timeline: decoded ${this.emittedSamples} of ${this.sampleCount} samples`
+      )
+    }
+  }
+
+  /**
+   * Apply stream priming and visible-length trimming once per PCM frame.
+   *
+   * @param {object} frame
+   * @returns {object}
+   * @private
+   */
+  trim(frame) {
+    const start = Math.max(0, this.primingSampleCount - this.timelinePosition)
+    const remaining = this.sampleCount - this.emittedSamples
+    const count = Math.max(0, Math.min(SAMPLES_PER_FRAME - start, remaining))
+    this.timelinePosition += SAMPLES_PER_FRAME
+    this.emittedSamples += count
+    if (this.channelCount === 1) return frame.slice(start, start + count)
+    return frame.map((channel) => channel.slice(start, start + count))
+  }
+
+  /**
+   * Publish one frame's progress.
+   *
+   * @private
+   */
+  reportProgress() {
+    if (this.onProgress) {
+      this.onProgress(this.frameIndex++)
+    }
+  }
+}
+
+/**
+ * Create a chronological encoder.
+ *
+ * @param {object} [options]
+ * @returns {AeaStreamingEncoder}
+ */
+export function createAeaStreamingEncoder(options) {
+  return new AeaStreamingEncoder(options)
+}
+
+/**
+ * Create a chronological decoder.
+ *
+ * @param {object} [options]
+ * @returns {AeaStreamingDecoder}
+ */
+export function createAeaStreamingDecoder(options) {
+  return new AeaStreamingDecoder(options)
+}
+
+/**
+ * Encode complete planar PCM buffers into an AEA byte image.
+ *
+ * @param {Float32Array[]} channels
+ * @param {object} [options]
+ * @returns {Promise<Uint8Array>}
+ */
+export async function encodeAeaPcm(channels, options = {}) {
+  if (
+    !Array.isArray(channels) ||
+    (channels.length !== 1 && channels.length !== 2) ||
+    channels.some((channel) => !(channel instanceof Float32Array))
+  ) {
+    throw new TypeError('ATRAC1 encoding requires one or two Float32 channels')
+  }
+
+  const { title = 'encoded by carta1', ...encoderValues } = options
+  const encoder = createAeaStreamingEncoder({
+    channelCount: channels.length,
+    encoderOptions: new EncoderOptions(encoderValues),
+  })
+  const frames = encoder.frames(frameBufferToFrames(channels))
+  const encoded = await collect(frames)
+  encoded.push(...encoder.finish())
+
+  const header = AeaFile.createHeader(
+    title,
+    encoded.length,
+    channels.length,
+    channels[0].length,
+    STREAM_PRIMING_SAMPLES
+  )
+  const output = new Uint8Array(
+    header.length + encoded.length * SOUND_UNIT_SIZE
+  )
+  output.set(header)
+  encoded.forEach((frame, index) => {
+    output.set(serializeFrame(frame), header.length + index * SOUND_UNIT_SIZE)
+  })
+  return output
+}
+
+/**
+ * Decode a complete AEA byte image into planar normalized PCM buffers.
+ *
+ * @param {Uint8Array|ArrayBuffer|Blob} input
+ * @returns {Promise<Float32Array[]>}
+ */
+export async function decodeAeaPcm(input) {
+  let bytes
+  if (input instanceof Blob) {
+    bytes = new Uint8Array(await input.arrayBuffer())
+  } else if (input instanceof Uint8Array) {
+    bytes = input
+  } else if (input instanceof ArrayBuffer) {
+    bytes = new Uint8Array(input)
+  } else {
+    throw new TypeError('ATRAC1 decoding requires AEA bytes or a Blob')
+  }
+
+  const info = AeaFile.parseHeader(bytes.subarray(0, AEA_HEADER_SIZE))
+  const decoder = createAeaStreamingDecoder({
+    channelCount: info.channelCount,
+    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))
+  decoded.push(...decoder.finish())
+
+  if (info.channelCount === 1) {
+    return [joinChannelFrames(decoded)]
+  }
+  return [
+    joinChannelFrames(decoded.map(([left]) => left)),
+    joinChannelFrames(decoded.map(([, right]) => right)),
+  ]
+}

package/codec/{browser → boundary}/worker.js

@@ -9,50 +9,11 @@
  *   new Worker('carta1-worker.min.js')
  */
 
-import { AeaFile } from '../io/serialization.js'
+import { AeaFile } from './container.js'
 import { EncoderOptions } from '../core/options.js'
-import { AudioProcessor } from '../io/processor.js'
+import { AudioProcessor } from './processor.js'
 import { SAMPLE_RATE } from '../core/constants.js'
 
-/**
- * Handle messages from the main thread
- *
- * Supported message types:
- * - 'encode': Encode PCM to ATRAC1
- * - 'decode': Decode ATRAC1 to PCM
- * - 'parseAea': Parse AEA blob metadata
- * - 'getEncoderOptions': Get default encoder options
- */
-self.onmessage = async (e) => {
-  const { jobId, type, pcmData, aea, options, title, blob } = e.data
-
-  try {
-    let result
-
-    switch (type) {
-      case 'encode':
-        result = await encodeAtrac(pcmData, options, title)
-        break
-      case 'decode':
-        result = await decodeAtrac(aea)
-        break
-      case 'parseAea':
-        result = await AudioProcessor.parseAeaBlob(blob)
-        break
-      case 'getEncoderOptions':
-        result = getEncoderOptionsMetadata()
-        break
-      default:
-        throw new Error(`Unknown worker message type: ${type}`)
-    }
-
-    self.postMessage({ jobId, result })
-  } catch (error) {
-    console.error('Worker error:', error)
-    self.postMessage({ jobId, error: error.message })
-  }
-}
-
 /**
  * Encode PCM audio data to ATRAC1 format
  *
@@ -79,6 +40,7 @@ async function encodeAtrac(pcmData, options, title) {
     const aeaBlob = await AudioProcessor.createAeaBlob(frameArray, {
       title,
       channelCount,
+      sampleCount: pcmData[0].length,
     })
 
     // Return the blob
@@ -125,12 +87,14 @@ async function decodeAtrac(aea) {
   const encodedFrameStream = AudioProcessor.deserializedFrameStream(aeaData)
   const decodedFrames = AudioProcessor.decodeStream(encodedFrameStream, {
     channelCount: decodingInfo.channelCount,
+    primingSampleCount: decodingInfo.primingSampleCount,
+    sampleCount: decodingInfo.sampleCount,
   })
 
   const pcmFrames = await AudioProcessor.collectFrames(decodedFrames)
 
   // Create WAV blob directly
-  const wavBlob = AudioProcessor.createWavBlob(
+  const wavBlob = AudioProcessor.createPcmWaveBlob(
     pcmFrames,
     decodingInfo.channelCount,
     decodingInfo.sampleRate
@@ -138,3 +102,42 @@ async function decodeAtrac(aea) {
 
   return { wavBlob, info: decodingInfo }
 }
+
+/**
+ * Handle messages from the main thread
+ *
+ * Supported message types:
+ * - 'encode': Encode PCM to ATRAC1
+ * - 'decode': Decode ATRAC1 to PCM
+ * - 'parseAea': Parse AEA blob metadata
+ * - 'getEncoderOptions': Get default encoder options
+ */
+self.onmessage = async (e) => {
+  const { jobId, type, pcmData, aea, options, title, blob } = e.data
+
+  try {
+    let result
+
+    switch (type) {
+      case 'encode':
+        result = await encodeAtrac(pcmData, options, title)
+        break
+      case 'decode':
+        result = await decodeAtrac(aea)
+        break
+      case 'parseAea':
+        result = await AudioProcessor.parseAeaBlob(blob)
+        break
+      case 'getEncoderOptions':
+        result = getEncoderOptionsMetadata()
+        break
+      default:
+        throw new Error(`Unknown worker message type: ${type}`)
+    }
+
+    self.postMessage({ jobId, result })
+  } catch (error) {
+    console.error('Worker error:', error)
+    self.postMessage({ jobId, error: error.message })
+  }
+}

package/codec/core/constants.js

@@ -1,128 +1,56 @@
 /**
- * Carta1 Audio Codec - Core Constants
+ * Carta1 scalar format constants.
  */
 
-// Audio format
 export const SAMPLE_RATE = 44100
 export const SAMPLES_PER_FRAME = 512
 export const FRAME_RATE = SAMPLE_RATE / SAMPLES_PER_FRAME
 
-// AEA file format
-export const AEA_MAGIC = new Uint8Array([0x00, 0x08, 0x00, 0x00])
 export const AEA_HEADER_SIZE = 2048
 export const AEA_TITLE_OFFSET = 4
 export const AEA_TITLE_SIZE = 256
 export const AEA_FRAME_COUNT_OFFSET = 260
 export const AEA_CHANNEL_COUNT_OFFSET = 264
+export const AEA_PRIMING_SAMPLE_COUNT_OFFSET = 268
+export const AEA_SOURCE_SAMPLE_COUNT_OFFSET = 272
+
+export const STREAM_PRIMING_SAMPLES = 266
+export const STREAM_FLUSH_TAIL_FRAMES = 1
 
-// Frame structure
 export const SOUND_UNIT_SIZE = 212
 export const FRAME_BITS = SOUND_UNIT_SIZE * 8
 export const FRAME_OVERHEAD_BITS = 40
 export const BITRATE_PER_CHANNEL = SOUND_UNIT_SIZE * FRAME_RATE * 8
 
-// BFU (Block Floating Unit) configuration
 export const NUM_BFUS = 52
 export const MAX_BFU_SIZE = 20
 export const BITS_PER_BFU_METADATA = 10
-
-export const SPECS_PER_BFU = new Int32Array([
-  8, 8, 8, 8, 4, 4, 4, 4, 8, 8, 8, 8, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7,
-  7, 7, 9, 9, 9, 9, 10, 10, 10, 10, 12, 12, 12, 12, 12, 12, 12, 12, 20, 20, 20,
-  20, 20, 20, 20, 20,
-])
-
 export const BFU_AMOUNTS_COUNT = 8
-export const BFU_AMOUNTS = new Int32Array([20, 28, 32, 36, 40, 44, 48, 52])
-export const BFU_BAND_BOUNDARIES = new Int32Array([20, 36, 52])
 
-// BFU start positions
-export const BFU_START_LONG = new Int32Array([
-  0, 8, 16, 24, 32, 36, 40, 44, 48, 56, 64, 72, 80, 86, 92, 98, 104, 110, 116,
-  122, 128, 134, 140, 146, 152, 159, 166, 173, 180, 189, 198, 207, 216, 226,
-  236, 246, 256, 268, 280, 292, 304, 316, 328, 340, 352, 372, 392, 412, 432,
-  452, 472, 492,
-])
-
-export const BFU_START_SHORT = new Int32Array([
-  0, 32, 64, 96, 8, 40, 72, 104, 12, 44, 76, 108, 20, 52, 84, 116, 26, 58, 90,
-  122, 128, 160, 192, 224, 134, 166, 198, 230, 141, 173, 205, 237, 150, 182,
-  214, 246, 256, 288, 320, 352, 384, 416, 448, 480, 268, 300, 332, 364, 396,
-  428, 460, 492,
-])
-
-// Transform sizes
 export const MDCT_SIZE_SHORT = 64
 export const MDCT_SIZE_MID = 256
 export const MDCT_SIZE_LONG = 512
+export const MDCT_SHORT_BLOCK_SIZE = 32
+export const MDCT_OVERLAP_SIZE = 32
+export const MDCT_TAIL_WINDOW_SIZE = 16
 
-// Window functions
-export const WINDOW_SHORT = (() => {
-  const table = new Float64Array(32)
-  for (let i = 0; i < 32; i++) {
-    table[i] = Math.sin(((i + 0.5) * Math.PI) / 64)
-  }
-  return table
-})()
-
-// QMF configuration
+export const QMF_BANDS = 2
 export const QMF_TAPS = 48
-export const QMF_DELAY = 46
+export const QMF_ANALYSIS_START_SAMPLE = 0
+export const QMF_ANALYSIS_STEP_SAMPLES = QMF_BANDS
+export const QMF_ANALYSIS_WINDOW_SAMPLES = QMF_TAPS
+export const QMF_ANALYSIS_MODULATION_SCALE = 1
+export const QMF_ANALYSIS_TERMS = 24
+export const QMF_ANALYSIS_DELAY_SAMPLES = QMF_TAPS - QMF_BANDS
+export const QMF_SYNTHESIS_DELAY_ROWS = 24
+export const QMF_SYNTHESIS_TERMS = 24
+export const QMF_SYNTHESIS_DELAY_SAMPLES = QMF_BANDS * QMF_SYNTHESIS_DELAY_ROWS
 export const QMF_HIGH_BAND_DELAY = 39
 
-// QMF prototype filter coefficients
-export const QMF_COEFFS = new Float32Array([
-  -0.00001461907, -0.00009205479, -0.000056157569, 0.00030117269, 0.0002422519,
-  -0.00085293897, -0.0005205574, 0.0020340169, 0.00078333891, -0.0042153862,
-  -0.00075614988, 0.0078402944, -0.000061169922, -0.01344162, 0.0024626821,
-  0.021736089, -0.007801671, -0.034090221, 0.01880949, 0.054326009,
-  -0.043596379, -0.099384367, 0.13207909, 0.46424159,
-])
-
-// QMF window function
-export const QMF_WINDOW = (() => {
-  const window = new Float32Array(QMF_TAPS)
-  for (let i = 0; i < 24; i++) {
-    window[i] = QMF_COEFFS[i] * 2.0
-    window[47 - i] = QMF_COEFFS[i] * 2.0
-  }
-  return window
-})()
-
-// QMF even/odd taps for optimization
-export const QMF_EVEN = (() => {
-  const even = new Float32Array(24)
-  for (let i = 0; i < 24; i++) {
-    even[i] = QMF_WINDOW[i * 2]
-  }
-  return even
-})()
-
-export const QMF_ODD = (() => {
-  const odd = new Float32Array(24)
-  for (let i = 0; i < 24; i++) {
-    odd[i] = QMF_WINDOW[i * 2 + 1]
-  }
-  return odd
-})()
-
-// FFT sizes for transient detection
 export const FFT_SIZE_LOW = 128
 export const FFT_SIZE_MID = 128
 export const FFT_SIZE_HIGH = 256
 
-// MDCT/IMDCT transform configuration
-export const MDCT_BAND_CONFIGS = [
-  { size: 128, windowStart: 48 }, // Low band (0-5.5kHz)
-  { size: 128, windowStart: 48 }, // Mid band (5.5-11kHz)
-  { size: 256, windowStart: 112 }, // High band (11-22kHz)
-]
-
-export const MDCT_SHORT_BLOCK_SIZE = 32
-export const MDCT_OVERLAP_SIZE = 32
-export const MDCT_TAIL_WINDOW_SIZE = 16
-
-// WAV format
 export const WAV_HEADER_SIZE = 44
 export const WAV_BYTES_PER_SAMPLE = 2
 export const WAV_BITS_PER_SAMPLE = 16
@@ -130,50 +58,9 @@ export const WAV_PCM_MAX_POSITIVE = 0x7fff
 export const WAV_PCM_MAX_NEGATIVE = 0x8000
 export const WAV_DATA_OFFSET = 36
 
-// Frame serialization
 export const FRAME_HEADER_BITS = 16
 export const FRAME_WORD_LENGTH_BITS = 4
 export const FRAME_SCALE_FACTOR_BITS = 6
 
-// Quantization
 export const QUANTIZATION_SIGN_BIT_SHIFT = 1
 export const MAX_WORD_LENGTH_INDEX = 15
-export const WORD_LENGTH_BITS = new Int32Array([
-  0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-])
-export const SCALE_FACTORS = (() => {
-  const table = new Float64Array(64)
-  for (let i = 0; i < 64; i++) {
-    table[i] = Math.pow(2.0, i / 3.0 - 21)
-  }
-  return table
-})()
-
-// Bit allocation
-export const INV_POWER_OF_TWO = (() => {
-  const maxBits = WORD_LENGTH_BITS[MAX_WORD_LENGTH_INDEX]
-  const table = new Float64Array(maxBits + 1)
-  for (let b = 0; b <= maxBits; b++) {
-    table[b] = Math.pow(2, -b)
-  }
-  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/geometry.js

@@ -0,0 +1,25 @@
+/**
+ * Stable ATRAC1 spectral geometry.
+ */
+
+/**
+ * Calculate a band's offset in the 512-coefficient spectrum.
+ *
+ * @param {number} bandIndex
+ * @returns {number}
+ */
+export function calculateBandOffset(bandIndex) {
+  return bandIndex === 0 ? 0 : bandIndex === 1 ? 128 : 256
+}
+
+/**
+ * Extract one band from the full coefficient spectrum.
+ *
+ * @param {Float32Array} coefficients
+ * @param {number} bandIndex
+ * @returns {Float32Array}
+ */
+export function extractBandCoefficients(coefficients, bandIndex) {
+  const offsets = [0, 128, 256, 512]
+  return coefficients.subarray(offsets[bandIndex], offsets[bandIndex + 1])
+}