carta1 1.6.1 → 1.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,358 +1,22 @@
1
- /** Configurable polyphase quadrature-mirror analysis and synthesis. */
1
+ /** ATRAC1 two-band polyphase quadrature-mirror analysis and synthesis. */
2
2
 
3
3
  import {
4
- QMF_ANALYSIS_MODULATION_SCALE,
5
- QMF_ANALYSIS_START_SAMPLE,
6
- QMF_ANALYSIS_STEP_SAMPLES,
7
4
  QMF_ANALYSIS_TERMS,
8
5
  QMF_ANALYSIS_WINDOW_SAMPLES,
9
6
  QMF_BANDS,
10
7
  QMF_SYNTHESIS_DELAY_ROWS,
11
8
  QMF_SYNTHESIS_TERMS,
12
9
  } from '../core/constants.js'
13
- import {
14
- QMF_ANALYSIS_HALF_BUTTERFLY_SCALES,
15
- QMF_ANALYSIS_ODD_PI_OVER_16_COSINES,
16
- QMF_ANALYSIS_ODD_PI_OVER_32_COSINES,
17
- QMF_ANALYSIS_ODD_PI_OVER_64_COSINES,
18
- QMF_ANALYSIS_PI_OVER_8_BUTTERFLY_SCALES,
19
- QMF_ANALYSIS_FILTER_COEFFICIENTS,
20
- QMF_ANALYSIS_MODULATION_COEFFICIENTS,
21
- QMF_ANALYSIS_SAMPLE_OFFSETS,
22
- QMF_SYNTHESIS_DELAY_COMPONENTS,
23
- QMF_SYNTHESIS_DELAY_ROW_OFFSETS,
24
- QMF_SYNTHESIS_FILTER_COEFFICIENTS,
25
- QMF_SYNTHESIS_MODULATION_COEFFICIENTS,
26
- } from '../core/tables.js'
27
-
28
- /**
29
- * @typedef {object} QmfScratch
30
- * @property {Float32Array} polyphase - Filter components.
31
- * @property {Float64Array} extended - Extended-precision components.
32
- * @property {Float32Array} bands - Modulated subband samples.
33
- */
10
+ import { QMF_EVEN, QMF_ODD } from '../core/tables.js'
34
11
 
35
12
  /**
36
- * Preserve the reference spill order of the native sixteen-band polyphase sum.
37
- * Other supported widths use the dense configurable path below.
13
+ * Transform a window of samples into two chronological subband rows.
14
+ * The input includes the preceding 46 samples of history.
38
15
  *
39
16
  * @param {Float32Array} input
40
- * @param {i32} inputOffset
41
- * @param {Float32Array} accumulator
42
- * @param {Float64Array} extended
43
- */
44
- function filter16Band(input, inputOffset, accumulator, extended) {
45
- const c = QMF_ANALYSIS_FILTER_COEFFICIENTS
46
-
47
- for (let component = 0; component < 16; component++) {
48
- const coefficientOffset = component * QMF_ANALYSIS_TERMS
49
- const firstSample = component < 8 ? component : component + 8
50
- const secondSample = component < 8 ? 15 - component : 39 - component
51
- const firstProduct = input[inputOffset + firstSample] * c[coefficientOffset]
52
- accumulator[component] = Math.fround(
53
- input[inputOffset + secondSample] * c[coefficientOffset + 1] +
54
- (component % 4 === 0 ? Math.fround(firstProduct) : firstProduct)
55
- )
56
- }
57
-
58
- let extended7 = accumulator[7]
59
- let extended8 = accumulator[8]
60
- let extended10 = accumulator[10]
61
- let extended11 = accumulator[11]
62
- let extended12 = accumulator[12]
63
- let extended13 = accumulator[13]
64
- let extended14 = accumulator[14]
65
- let extended15 = accumulator[15]
66
-
67
- for (let segment = 1; segment < 12; segment++) {
68
- const inputBase = inputOffset + segment * 32
69
- const term = segment * 2
70
-
71
- const product0 = Math.fround(input[inputBase] * c[term])
72
- accumulator[0] = Math.fround(
73
- accumulator[0] + product0 + input[inputBase + 15] * c[term + 1]
74
- )
75
- accumulator[1] = Math.fround(
76
- input[inputBase + 1] * c[QMF_ANALYSIS_TERMS + term] +
77
- Math.fround(
78
- input[inputBase + 14] * c[QMF_ANALYSIS_TERMS + term + 1] +
79
- accumulator[1]
80
- )
81
- )
82
- const product2 = Math.fround(
83
- input[inputBase + 2] * c[QMF_ANALYSIS_TERMS * 2 + term]
84
- )
85
- accumulator[2] = Math.fround(
86
- accumulator[2] +
87
- product2 +
88
- input[inputBase + 13] * c[QMF_ANALYSIS_TERMS * 2 + term + 1]
89
- )
90
- accumulator[3] = Math.fround(
91
- accumulator[3] +
92
- input[inputBase + 3] * c[QMF_ANALYSIS_TERMS * 3 + term] +
93
- input[inputBase + 12] * c[QMF_ANALYSIS_TERMS * 3 + term + 1]
94
- )
95
- const product4 = Math.fround(
96
- input[inputBase + 4] * c[QMF_ANALYSIS_TERMS * 4 + term]
97
- )
98
- const product4Sum =
99
- product4 + input[inputBase + 11] * c[QMF_ANALYSIS_TERMS * 4 + term + 1]
100
- accumulator[4] = Math.fround(accumulator[4] + product4Sum)
101
- accumulator[5] = Math.fround(
102
- input[inputBase + 5] * c[QMF_ANALYSIS_TERMS * 5 + term] +
103
- Math.fround(
104
- input[inputBase + 10] * c[QMF_ANALYSIS_TERMS * 5 + term + 1] +
105
- accumulator[5]
106
- )
107
- )
108
- const product6 = Math.fround(
109
- input[inputBase + 6] * c[QMF_ANALYSIS_TERMS * 6 + term]
110
- )
111
- accumulator[6] = Math.fround(
112
- accumulator[6] +
113
- product6 +
114
- input[inputBase + 9] * c[QMF_ANALYSIS_TERMS * 6 + term + 1]
115
- )
116
- extended7 =
117
- accumulator[7] +
118
- (input[inputBase + 7] * c[QMF_ANALYSIS_TERMS * 7 + term] +
119
- input[inputBase + 8] * c[QMF_ANALYSIS_TERMS * 7 + term + 1])
120
- accumulator[7] = Math.fround(extended7)
121
-
122
- extended8 =
123
- input[inputBase + 31] * c[QMF_ANALYSIS_TERMS * 8 + term + 1] +
124
- input[inputBase + 16] * c[QMF_ANALYSIS_TERMS * 8 + term] +
125
- accumulator[8]
126
- accumulator[8] = Math.fround(extended8)
127
- accumulator[9] = Math.fround(
128
- input[inputBase + 17] * c[QMF_ANALYSIS_TERMS * 9 + term] +
129
- Math.fround(
130
- input[inputBase + 30] * c[QMF_ANALYSIS_TERMS * 9 + term + 1] +
131
- accumulator[9]
132
- )
133
- )
134
- extended10 =
135
- accumulator[10] +
136
- (input[inputBase + 18] * c[QMF_ANALYSIS_TERMS * 10 + term] +
137
- input[inputBase + 29] * c[QMF_ANALYSIS_TERMS * 10 + term + 1])
138
- accumulator[10] = Math.fround(extended10)
139
- extended11 =
140
- accumulator[11] +
141
- (input[inputBase + 19] * c[QMF_ANALYSIS_TERMS * 11 + term] +
142
- input[inputBase + 28] * c[QMF_ANALYSIS_TERMS * 11 + term + 1])
143
- accumulator[11] = Math.fround(extended11)
144
- extended12 =
145
- accumulator[12] +
146
- (input[inputBase + 20] * c[QMF_ANALYSIS_TERMS * 12 + term] +
147
- input[inputBase + 27] * c[QMF_ANALYSIS_TERMS * 12 + term + 1])
148
- accumulator[12] = Math.fround(extended12)
149
- extended13 =
150
- accumulator[13] +
151
- (input[inputBase + 21] * c[QMF_ANALYSIS_TERMS * 13 + term] +
152
- input[inputBase + 26] * c[QMF_ANALYSIS_TERMS * 13 + term + 1])
153
- accumulator[13] = Math.fround(extended13)
154
- extended14 =
155
- accumulator[14] +
156
- (input[inputBase + 22] * c[QMF_ANALYSIS_TERMS * 14 + term] +
157
- input[inputBase + 25] * c[QMF_ANALYSIS_TERMS * 14 + term + 1])
158
- accumulator[14] = Math.fround(extended14)
159
- const product15 =
160
- input[inputBase + 24] * c[QMF_ANALYSIS_TERMS * 15 + term + 1] +
161
- input[inputBase + 23] * c[QMF_ANALYSIS_TERMS * 15 + term]
162
- extended15 = accumulator[15] + product15
163
- accumulator[15] = Math.fround(extended15)
164
- }
165
-
166
- extended[7] = extended7
167
- extended[10] = extended10
168
- extended[11] = extended11
169
- extended[12] = extended12
170
- extended[13] = extended13
171
- extended[14] = extended14
172
- extended[15] = extended15
173
- }
174
-
175
- /**
176
- * Preserve the reference factorization and spill order of 16-band modulation.
177
- *
178
- * @param {Float32Array} polyphase
179
- * @param {Float64Array} extended
180
- * @param {Float32Array} output
181
- */
182
- function modulate16Band(polyphase, extended, output) {
183
- const half = QMF_ANALYSIS_HALF_BUTTERFLY_SCALES
184
- const cos32 = QMF_ANALYSIS_ODD_PI_OVER_32_COSINES
185
- const cos16 = QMF_ANALYSIS_ODD_PI_OVER_16_COSINES
186
- const cos64 = QMF_ANALYSIS_ODD_PI_OVER_64_COSINES
187
- const pi8 = QMF_ANALYSIS_PI_OVER_8_BUTTERFLY_SCALES
188
-
189
- const twoCosPi8 = pi8[0]
190
- const cosPi4 = half[0]
191
- const twoCosPi32 = cos32[0]
192
- const twoCosPi16 = cos16[0]
193
-
194
- const rotated7Extended = extended[7] * cos64[0]
195
- const rotated0Extended = polyphase[0] * cos64[7]
196
- const rotated13Extended = extended[13] * cos64[13]
197
- const rotated7 = Math.fround(rotated7Extended)
198
- const rotated5 = Math.fround(polyphase[5] * cos64[2])
199
- const rotated6Extended = polyphase[6] * cos64[1]
200
- const rotated6 = Math.fround(rotated6Extended)
201
- const rotated4Extended = polyphase[4] * cos64[3]
202
- const rotated4 = Math.fround(rotated4Extended)
203
- const rotated3 = Math.fround(polyphase[3] * cos64[4])
204
- const rotated3Extended = rotated3
205
- const rotated2 = Math.fround(polyphase[2] * cos64[5])
206
- const rotated0 = Math.fround(rotated0Extended)
207
- const rotated1Extended = polyphase[1] * cos64[6]
208
- const rotated8Extended = polyphase[8] * cos64[8]
209
- const rotated8 = Math.fround(rotated8Extended)
210
- const rotated14Extended = extended[14] * cos64[14]
211
- const rotated14 = Math.fround(rotated14Extended)
212
- const rotated15Extended = extended[15] * cos64[15]
213
- const rotated9Extended = polyphase[9] * cos64[9]
214
- const rotated9 = Math.fround(rotated9Extended)
215
- const rotated13 = Math.fround(rotated13Extended)
216
- const rotated10Extended = extended[10] * cos64[10]
217
- const rotated10 = Math.fround(rotated10Extended)
218
- const rotated11Extended = extended[11] * cos64[11]
219
- const rotated11 = Math.fround(rotated11Extended)
220
- const rotated12Extended = extended[12] * cos64[12]
221
-
222
- const sum0Extended = rotated0 + rotated8 + (rotated7 + rotated15Extended)
223
- const mix0Term0Extended = (rotated7 - rotated15Extended) * twoCosPi32
224
- const mix0Term1Extended = (rotated0 - rotated8) * cos32[7]
225
- const mix0Extended = mix0Term0Extended + mix0Term1Extended
226
- const mix0 = Math.fround(mix0Extended)
227
- const mixASum0Extended = rotated7 + rotated15Extended
228
- const mixASum1Extended = rotated0 + rotated8
229
- const mixAExtended = twoCosPi16 * (mixASum0Extended - mixASum1Extended)
230
- const mix1 = Math.fround(twoCosPi16 * (mix0Term0Extended - mix0Term1Extended))
231
-
232
- const sum1Extended = rotated14 + rotated1Extended + (rotated6 + rotated9)
233
- const sum1Float32 = Math.fround(sum1Extended)
234
- const mix2Term0Extended = (rotated1Extended - rotated9) * cos32[6]
235
- const mixBInnerExtended = rotated6 + rotated14 - rotated1Extended - rotated9
236
- const mixBInnerFloat32 = Math.fround(mixBInnerExtended)
237
- const mixBExtended = cos16[1] * mixBInnerFloat32
238
- const mixB = Math.fround(mixBExtended)
239
- const mix2Term1Extended = Math.fround(rotated6 - rotated14) * cos32[1]
240
- const mix2 = Math.fround(mix2Term1Extended + mix2Term0Extended)
241
- const mix3 = Math.fround(cos16[1] * (mix2Term1Extended - mix2Term0Extended))
242
-
243
- const sum2Pair0Extended = rotated5 + rotated13
244
- const sum2Pair1Extended = rotated2 + rotated10
245
- const sum2Extended = sum2Pair0Extended + sum2Pair1Extended
246
- const sum2Float32 = Math.fround(sum2Extended)
247
- const mixCInnerExtended = sum2Pair0Extended - rotated2 - rotated10
248
- const mixCInnerFloat32 = Math.fround(mixCInnerExtended)
249
- const mixCExtended = cos16[2] * mixCInnerFloat32
250
- const mixC = Math.fround(mixCExtended)
251
- const mix4Term0Extended = (rotated5 - rotated13) * cos32[2]
252
- const mix4Term1Extended = (rotated2 - rotated10) * cos32[5]
253
- const mix4 = Math.fround(mix4Term0Extended + mix4Term1Extended)
254
- const mix5 = Math.fround(cos16[2] * (mix4Term0Extended - mix4Term1Extended))
255
-
256
- const sum3Extended =
257
- rotated3 + rotated4 + rotated11Extended + rotated12Extended
258
- const mix6Term0Extended = (rotated4 - rotated12Extended) * cos32[3]
259
- const mixDInnerExtended =
260
- rotated4 + rotated12Extended - rotated3Extended - rotated11Extended
261
- const mixDExtended = cos16[3] * mixDInnerExtended
262
- const mix6Term1Extended = (rotated3Extended - rotated11) * cos32[4]
263
- const mix6 = Math.fround(mix6Term0Extended + mix6Term1Extended)
264
- const mix6Term0SpilledExtended = Math.fround(mix6Term0Extended)
265
- const mix7 = Math.fround(
266
- cos16[3] * (mix6Term0SpilledExtended - mix6Term1Extended)
267
- )
268
-
269
- const sumAllExtended = sum0Extended + sum1Float32 + sum2Float32 + sum3Extended
270
- const out0Extended = sumAllExtended * 0.5
271
- output[0] = Math.fround(out0Extended)
272
- const mid0Extended =
273
- cosPi4 * (sum0Extended - sum1Float32 - sum2Float32 + sum3Extended)
274
- const mid0 = Math.fround(mid0Extended)
275
- const diff03Extended = (sum0Extended - sum3Extended) * twoCosPi8
276
- const diff12Extended = Math.fround(sum1Float32 - sum2Float32) * pi8[1]
277
- const diff12 = Math.fround(diff12Extended)
278
- const mid1Extended = half[1] * diff03Extended - half[2] * diff12
279
- const mid1 = Math.fround(mid1Extended)
280
- const mid2Extended = (mixAExtended - mixDExtended) * pi8[2]
281
- const mid2 = Math.fround(mid2Extended)
282
- const mid3Extended = (mixB - mixC) * pi8[3]
283
- const avg2Pair0Extended = mixB + mixC
284
- const avg2Pair1Extended = mixAExtended + mixDExtended
285
- const avg2Extended = (avg2Pair0Extended + avg2Pair1Extended) * 0.5
286
- const mid4Extended = (mid2 + mid3Extended) * 0.5 - avg2Extended
287
- const mid4 = Math.fround(mid4Extended)
288
- const mid5Extended =
289
- cosPi4 * (mixAExtended - mixB - mixC + mixDExtended) - mid4Extended
290
- const mid6Extended = half[1] * mid2 - half[2] * mid3Extended - mid5Extended
291
- const mid6 = Math.fround(mid6Extended)
292
-
293
- const avg1Extended = (mix0 + mix2 + mix4 + mix6) * 0.5
294
- const out1Extended = avg1Extended - output[0]
295
- output[1] = Math.fround(out1Extended)
296
- const out2Extended = avg2Extended - out1Extended
297
- output[2] = Math.fround(out2Extended)
298
- const mid7Extended = cosPi4 * (mix0 - mix2 - mix4 + mix6)
299
- const mid7 = Math.fround(mid7Extended)
300
- const mid8Extended = twoCosPi8 * (mix0 - mix6)
301
- const mid8 = Math.fround(mid8Extended)
302
- const mid9 = Math.fround(pi8[1] * Math.fround(mix2 - mix4))
303
- const mid10Extended = half[1] * mid8 - half[2] * mid9
304
- const mid10 = Math.fround(mid10Extended)
305
- const avg3Extended = (mix1 + mix3 + mix5 + mix7) * 0.5 - avg1Extended
306
- const out3Extended = avg3Extended - out2Extended
307
- output[3] = Math.fround(out3Extended)
308
- const mid11Extended = (mid8 + mid9) * 0.5 - avg3Extended
309
- const mid11 = Math.fround(mid11Extended)
310
- const out4Extended = (diff03Extended + diff12) * 0.5 - out3Extended
311
- output[4] = Math.fround(out4Extended)
312
- const mid12Extended = (mix1 - mix7) * pi8[2]
313
- const mid13Extended = (mix3 - mix5) * pi8[3]
314
- const out5Extended = mid11Extended - out4Extended
315
- output[5] = Math.fround(out5Extended)
316
- const out6Extended = mid4 - out5Extended
317
- output[6] = Math.fround(out6Extended)
318
- const mid14Extended =
319
- mid12Extended + mid13Extended - mix1 - mix3 - mix5 - mix7
320
- const mid14HalfExtended = mid14Extended * 0.5
321
- const mid15Extended = cosPi4 * (mix1 - mix3 - mix5 + mix7) - mid14HalfExtended
322
- const mid16Extended =
323
- half[1] * mid12Extended - half[2] * mid13Extended - mid15Extended
324
- const mid17Extended = mid14HalfExtended - mid11
325
- const out7Extended = mid17Extended - output[6]
326
- output[7] = Math.fround(out7Extended)
327
- const mid18Extended = mid7 - mid17Extended
328
- const out8Extended = mid0 - out7Extended
329
- output[8] = Math.fround(out8Extended)
330
- const out9Extended = mid18Extended - out8Extended
331
- output[9] = Math.fround(out9Extended)
332
- const mid19Extended = mid15Extended - mid18Extended
333
- const out10Extended = mid5Extended - out9Extended
334
- output[10] = Math.fround(out10Extended)
335
- const out11Extended = mid19Extended - out10Extended
336
- output[11] = Math.fround(out11Extended)
337
- const mid20Extended = mid10 - mid19Extended
338
- const out12Extended = mid1 - out11Extended
339
- output[12] = Math.fround(out12Extended)
340
- const out13Extended = mid20Extended - out12Extended
341
- output[13] = Math.fround(out13Extended)
342
- const mid21Extended = mid16Extended - mid20Extended
343
- const out14Extended = mid6 - out13Extended
344
- output[14] = Math.fround(out14Extended)
345
- const out15Extended = mid21Extended - out14Extended
346
- output[15] = Math.fround(out15Extended)
347
- }
348
-
349
- /**
350
- * Transform one complete time window into caller-owned QMF subband rows.
351
- *
352
- * @param {Float32Array} input Current samples preceded by the required history.
353
- * @param {Float32Array[]} outputBands Caller-owned chronological subband rows.
354
- * @param {QmfScratch} scratch Reusable component and modulation storage.
355
- * @returns {Float32Array[]} The completed subband rows.
17
+ * @param {Float32Array[]} outputBands
18
+ * @param {object} scratch Reusable QMF storage.
19
+ * @returns {Float32Array[]}
356
20
  * @nativeUnchecked Native callers supply frame-bounded buffers and indices.
357
21
  */
358
22
  export function analyzeQmf(input, outputBands, scratch) {
@@ -373,86 +37,33 @@ export function analyzeQmf(input, outputBands, scratch) {
373
37
 
374
38
  const sampleCount = outputBands[0].length
375
39
  const requiredSamples =
376
- QMF_ANALYSIS_START_SAMPLE +
377
- Math.max(0, sampleCount - 1) * QMF_ANALYSIS_STEP_SAMPLES +
378
- QMF_ANALYSIS_WINDOW_SAMPLES
40
+ Math.max(0, sampleCount - 1) * QMF_BANDS + QMF_ANALYSIS_WINDOW_SAMPLES
379
41
  if (input.length < requiredSamples) {
380
42
  throw new RangeError('QMF analysis window is incomplete')
381
43
  }
382
44
 
383
- const { polyphase, extended, bands } = scratch
384
-
385
45
  for (let sample = 0; sample < sampleCount; sample++) {
386
- const inputOffset =
387
- QMF_ANALYSIS_START_SAMPLE + sample * QMF_ANALYSIS_STEP_SAMPLES
388
- if (QMF_BANDS === 2) {
389
- for (let component = 0; component < QMF_BANDS; component++) {
390
- const termOffset = component * QMF_ANALYSIS_TERMS
391
- let sum = 0
392
- for (let term = 0; term < QMF_ANALYSIS_TERMS; term++) {
393
- const index = termOffset + term
394
- sum +=
395
- input[inputOffset + QMF_ANALYSIS_SAMPLE_OFFSETS[index]] *
396
- QMF_ANALYSIS_FILTER_COEFFICIENTS[index]
397
- }
398
- extended[component] = sum
399
- }
400
- for (let band = 0; band < QMF_BANDS; band++) {
401
- const coefficientOffset = band * QMF_BANDS
402
- let sum = 0
403
- for (let component = 0; component < QMF_BANDS; component++) {
404
- sum +=
405
- extended[component] *
406
- QMF_ANALYSIS_MODULATION_COEFFICIENTS[coefficientOffset + component]
407
- }
408
- outputBands[band][sample] = sum * QMF_ANALYSIS_MODULATION_SCALE
409
- }
410
- continue
411
- }
412
- if (QMF_BANDS === 16) {
413
- filter16Band(input, inputOffset, polyphase, extended)
414
- modulate16Band(polyphase, extended, bands)
415
- for (let band = 0; band < QMF_BANDS; band++) {
416
- outputBands[band][sample] = bands[band]
417
- }
418
- continue
419
- }
420
-
421
- for (let component = 0; component < QMF_BANDS; component++) {
422
- const termOffset = component * QMF_ANALYSIS_TERMS
423
- let sum = 0
424
- for (let term = 0; term < QMF_ANALYSIS_TERMS; term++) {
425
- const index = termOffset + term
426
- sum +=
427
- input[inputOffset + QMF_ANALYSIS_SAMPLE_OFFSETS[index]] *
428
- QMF_ANALYSIS_FILTER_COEFFICIENTS[index]
429
- }
430
- polyphase[component] = sum
431
- }
432
-
433
- for (let band = 0; band < QMF_BANDS; band++) {
434
- const coefficientOffset = band * QMF_BANDS
435
- let sum = 0
436
- for (let component = 0; component < QMF_BANDS; component++) {
437
- sum +=
438
- polyphase[component] *
439
- QMF_ANALYSIS_MODULATION_COEFFICIENTS[coefficientOffset + component]
440
- }
441
- bands[band] = sum * QMF_ANALYSIS_MODULATION_SCALE
442
- outputBands[band][sample] = bands[band]
46
+ const offset = sample * 2
47
+ let even = 0
48
+ let odd = 0
49
+ for (let term = 0; term < QMF_ANALYSIS_TERMS; term++) {
50
+ even += input[offset + 47 - term * 2] * QMF_EVEN[term]
51
+ odd += input[offset + 46 - term * 2] * QMF_ODD[term]
443
52
  }
53
+ outputBands[0][sample] = even + odd
54
+ outputBands[1][sample] = even - odd
444
55
  }
445
56
  return outputBands
446
57
  }
447
58
 
448
59
  /**
449
- * Fold caller-owned QMF subband rows through one circular synthesis delay.
60
+ * Reconstruct interleaved PCM using a circular polyphase delay line.
450
61
  *
451
62
  * @param {Float32Array[]} inputBands Chronological subband rows.
452
63
  * @param {Float32Array} delay Caller-owned component delay ring.
453
64
  * @param {i32} delayRow Current delay-ring row.
454
65
  * @param {Float32Array} output Caller-owned interleaved PCM output.
455
- * @param {QmfScratch} scratch Reusable component and modulation storage.
66
+ * @param {object} scratch Reusable QMF storage.
456
67
  * @returns {number} Next delay-ring row.
457
68
  * @nativeUnchecked Native callers supply frame-bounded buffers and indices.
458
69
  */
@@ -477,67 +88,23 @@ export function synthesizeQmf(inputBands, delay, delayRow, output, scratch) {
477
88
  throw new RangeError('QMF synthesis geometry is invalid')
478
89
  }
479
90
 
480
- const { polyphase, bands } = scratch
481
- const sampleCount = inputBands[0].length
482
-
483
- for (let sample = 0; sample < sampleCount; sample++) {
484
- for (let band = 0; band < QMF_BANDS; band++) {
485
- bands[band] = inputBands[band][sample]
486
- }
487
-
488
- const delayOffset = delayRow * QMF_BANDS
489
- for (let component = 0; component < QMF_BANDS; component++) {
490
- const coefficientOffset = component * QMF_BANDS
491
- let sum = 0
492
- for (let band = 0; band < QMF_BANDS; band++) {
493
- sum +=
494
- QMF_SYNTHESIS_MODULATION_COEFFICIENTS[coefficientOffset + band] *
495
- bands[band]
496
- }
497
- polyphase[component] = sum
498
- delay[delayOffset + component] = polyphase[component]
499
- }
500
-
501
- const outputOffset = sample * QMF_BANDS
502
- for (let outputSample = 0; outputSample < QMF_BANDS; outputSample++) {
503
- const termOffset = outputSample * QMF_SYNTHESIS_TERMS
504
- let sum = 0
505
- if (QMF_BANDS === 16) {
506
- for (let term = 0; term < QMF_SYNTHESIS_TERMS; term += 2) {
507
- const first = termOffset + term
508
- const second = first + 1
509
- const firstRow =
510
- (delayRow + QMF_SYNTHESIS_DELAY_ROW_OFFSETS[first]) %
511
- QMF_SYNTHESIS_DELAY_ROWS
512
- const secondRow =
513
- (delayRow + QMF_SYNTHESIS_DELAY_ROW_OFFSETS[second]) %
514
- QMF_SYNTHESIS_DELAY_ROWS
515
- sum = Math.fround(
516
- delay[
517
- firstRow * QMF_BANDS + QMF_SYNTHESIS_DELAY_COMPONENTS[first]
518
- ] *
519
- QMF_SYNTHESIS_FILTER_COEFFICIENTS[first] +
520
- delay[
521
- secondRow * QMF_BANDS + QMF_SYNTHESIS_DELAY_COMPONENTS[second]
522
- ] *
523
- QMF_SYNTHESIS_FILTER_COEFFICIENTS[second] +
524
- sum
525
- )
526
- }
527
- output[outputOffset + outputSample] = sum
528
- continue
529
- }
530
- for (let term = 0; term < QMF_SYNTHESIS_TERMS; term++) {
531
- const index = termOffset + term
532
- const row =
533
- (delayRow + QMF_SYNTHESIS_DELAY_ROW_OFFSETS[index]) %
534
- QMF_SYNTHESIS_DELAY_ROWS
535
- sum +=
536
- delay[row * QMF_BANDS + QMF_SYNTHESIS_DELAY_COMPONENTS[index]] *
537
- QMF_SYNTHESIS_FILTER_COEFFICIENTS[index]
538
- }
539
- output[outputOffset + outputSample] = sum
91
+ for (let sample = 0; sample < inputBands[0].length; sample++) {
92
+ const low = inputBands[0][sample]
93
+ const high = inputBands[1][sample]
94
+ delay[delayRow * 2] = low + high
95
+ delay[delayRow * 2 + 1] = low - high
96
+
97
+ let even = 0
98
+ let odd = 0
99
+ for (let term = 0; term < QMF_SYNTHESIS_TERMS; term++) {
100
+ const row =
101
+ (delayRow + QMF_SYNTHESIS_DELAY_ROWS - 1 - term) %
102
+ QMF_SYNTHESIS_DELAY_ROWS
103
+ even += delay[row * 2 + 1] * QMF_ODD[term]
104
+ odd += delay[row * 2] * QMF_EVEN[term]
540
105
  }
106
+ output[sample * 2] = even
107
+ output[sample * 2 + 1] = odd
541
108
  delayRow = delayRow === 0 ? QMF_SYNTHESIS_DELAY_ROWS - 1 : delayRow - 1
542
109
  }
543
110
  return delayRow
@@ -3,9 +3,8 @@
3
3
  */
4
4
 
5
5
  import {
6
+ MAX_MDCT_SIZE,
6
7
  MDCT_SHORT_BLOCK_SIZE,
7
- MDCT_SIZE_LONG,
8
- MDCT_SIZE_MID,
9
8
  MDCT_SIZE_SHORT,
10
9
  MDCT_TAIL_WINDOW_SIZE,
11
10
  } from '../core/constants.js'
@@ -15,9 +14,10 @@ import { IMDCT } from '../signal/mdct.js'
15
14
  import { reverseSpectrum } from '../signal/order.js'
16
15
  import { throwError } from '../utils.js'
17
16
 
18
- const shortImdct = new IMDCT(MDCT_SIZE_SHORT, MDCT_SIZE_SHORT * 8)
19
- const middleImdct = new IMDCT(MDCT_SIZE_MID, MDCT_SIZE_MID * 8)
20
- const longImdct = new IMDCT(MDCT_SIZE_LONG, MDCT_SIZE_LONG * 4)
17
+ const shortImdct = new IMDCT(MDCT_SIZE_SHORT, MDCT_SIZE_SHORT)
18
+ const longImdcts = MDCT_BAND_CONFIGS.map(
19
+ ({ longMdctSize }) => new IMDCT(longMdctSize, longMdctSize)
20
+ )
21
21
 
22
22
  /**
23
23
  * Combine adjacent inverse-transform blocks through the codec window.
@@ -54,7 +54,6 @@ export function synthesizeSpectrum(context) {
54
54
  context?.bufferPool ??
55
55
  throwError('synthesizeSpectrum: bufferPool is required')
56
56
  const overlapBuffers = bufferPool.imdctOverlap
57
- const transformFunctions = [middleImdct, middleImdct, longImdct]
58
57
 
59
58
  /**
60
59
  * @param {Float32Array} coefficients
@@ -77,7 +76,7 @@ export function synthesizeSpectrum(context) {
77
76
  bandIndex,
78
77
  overlapBuffer,
79
78
  config,
80
- transformFunctions[bandIndex]
79
+ longImdcts[bandIndex]
81
80
  )
82
81
  }
83
82
 
@@ -109,7 +108,7 @@ export function synthesizeSpectrum(context) {
109
108
  bufferPool.mdctBuffers
110
109
  )
111
110
  const inverseStart = inverse.length / 4
112
- const inverseBuffer = bufferPool.transformBuffers[MDCT_SIZE_LONG]
111
+ const inverseBuffer = bufferPool.transformBuffers[MAX_MDCT_SIZE]
113
112
  inverseBuffer.fill(0)
114
113
 
115
114
  for (let i = 0; i < config.size; i++) {
@@ -153,7 +152,7 @@ export function synthesizeSpectrum(context) {
153
152
  */
154
153
  function inverseShortBlocks(coefficients, bandIndex, overlapBuffer, config) {
155
154
  const numBlocks = 1 << (config.size === 256 ? 3 : 2)
156
- const inverseBuffer = bufferPool.transformBuffers[MDCT_SIZE_LONG]
155
+ const inverseBuffer = bufferPool.transformBuffers[MAX_MDCT_SIZE]
157
156
  inverseBuffer.fill(0)
158
157
 
159
158
  const previous = overlapBuffer.slice(
@@ -2,6 +2,7 @@
2
2
  * Carta1 PCM synthesis application.
3
3
  */
4
4
 
5
+ import { PCM16_NORM_GAIN } from '../core/constants.js'
5
6
  import { synthesizeQmf } from '../signal/qmf.js'
6
7
  import { throwError } from '../utils.js'
7
8
 
@@ -58,6 +59,9 @@ export function synthesizePcm(context) {
58
59
  const stage2 = synthesizePair([bands[0], bands[1]], states.midBand, scratch)
59
60
 
60
61
  const stage1 = synthesizePair([stage2, highBand], states.lowBand, scratch)
62
+ for (let i = 0; i < stage1.length; i++) {
63
+ stage1[i] *= PCM16_NORM_GAIN
64
+ }
61
65
 
62
66
  return stage1
63
67
  }