@libraz/libsonare 1.7.2 → 1.8.1

package/src/worklet/engine-strips.ts

@@ -1,5 +1,13 @@
 import { panLawCode, panModeCode } from '../codes';
 import type { EqBand, PanLawInput, PanMode, RealtimeEngine } from '../index';
+import type { InsertParamOverrideMap } from './engine-mixer-facade';
+import {
+  emptyStripJson,
+  type InsertParamOverride,
+  insertParamOverrideKey,
+  replaceStripScene,
+  type StripJsonTarget,
+} from './engine-mixer-facade';
 import type { SonareEngineInstrumentSyncMessage, SonareEngineSyncMessage } from './messages';
 
 /**
@@ -14,20 +22,80 @@ export interface EngineStripContext {
   postInstrumentSync(message: SonareEngineInstrumentSyncMessage): void;
   ensureTrackLane(target: string | number): number;
   resolveTargetId(target: string | number): number;
+  readStripJson(target: StripJsonTarget): string | undefined;
+  writeStripJson(target: StripJsonTarget, sceneJson: string): void;
+  readonly insertParamOverrides: InsertParamOverrideMap;
+  clearInsertAutomationLanes(target: StripJsonTarget): void;
 }
 
 function trackIdFor(ctx: EngineStripContext, target: string | number): number {
   return ctx.trackLaneIds[ctx.ensureTrackLane(target)];
 }
 
+type SceneEntry = Record<string, unknown>;
+
+/**
+ * Folds a setter's change into the strip's cached scene JSON, so the next
+ * syncMixer re-post replays it instead of reverting it on the worklet.
+ */
+function mergeStripJson(
+  ctx: EngineStripContext,
+  target: StripJsonTarget,
+  update: (entry: SceneEntry) => void,
+): void {
+  const scene = JSON.parse(ctx.readStripJson(target) ?? emptyStripJson(target)) as {
+    strips: SceneEntry[];
+    buses: SceneEntry[];
+  };
+  update(target.kind === 'bus' ? scene.buses[0] : scene.strips[0]);
+  ctx.writeStripJson(target, JSON.stringify(scene));
+}
+
+function mergeEqBand(
+  ctx: EngineStripContext,
+  target: StripJsonTarget,
+  bandIndex: number,
+  bandJson: string,
+): void {
+  mergeStripJson(ctx, target, (entry) => {
+    const eq = (entry.eq ?? { enabled: true, bands: [] }) as { bands?: unknown[] };
+    const bands = eq.bands ?? [];
+    while (bands.length < bandIndex) {
+      bands.push({});
+    }
+    bands[bandIndex] = JSON.parse(bandJson);
+    entry.eq = { ...eq, bands };
+  });
+}
+
+function setInsertParamByName(
+  ctx: EngineStripContext,
+  target: StripJsonTarget,
+  insertIndex: number,
+  paramName: string,
+  value: number,
+  applyNative: () => void,
+  message: SonareEngineSyncMessage,
+): void {
+  applyNative();
+  // Keep the construction scene unchanged. Rewriting insert params here makes
+  // a later syncMixer rebuild stateful effects; the override is replayed after
+  // the scene on both engines instead.
+  const override: InsertParamOverride = { target, insertIndex, paramName, value };
+  ctx.insertParamOverrides.set(insertParamOverrideKey(override), override);
+  ctx.postSync(message);
+}
+
 export function setTrackStripJson(
   ctx: EngineStripContext,
   trackId: number,
   sceneJson: string,
   trackStripJson: Map<number, string>,
-): void {
-  ctx.offlineEngine.setTrackStripJson(trackId, sceneJson);
+): { insertBaseResets: StripJsonTarget[]; constructionOverrides: InsertParamOverride[] } {
+  const target: StripJsonTarget = { kind: 'track', trackId };
+  const result = replaceStripScene(ctx, target, trackStripJson.get(trackId), sceneJson);
   trackStripJson.set(trackId, sceneJson);
+  return result;
 }
 
 export function setTrackStripEqBand(
@@ -39,6 +107,7 @@ export function setTrackStripEqBand(
   const trackId = trackIdFor(ctx, target);
   const bandJson = typeof band === 'string' ? band : JSON.stringify(band);
   ctx.offlineEngine.setTrackStripEqBandJson(trackId, bandIndex, bandJson);
+  mergeEqBand(ctx, { kind: 'track', trackId }, bandIndex, bandJson);
   ctx.postSync({ type: 'syncTrackStripEqBand', trackId, bandIndex, bandJson });
 }
 
@@ -68,8 +137,16 @@ export function setTrackStripInsertParamByName(
   value: number,
 ): void {
   const trackId = trackIdFor(ctx, target);
-  ctx.offlineEngine.setTrackStripInsertParamByName(trackId, insertIndex, paramName, value);
-  ctx.postSync({ type: 'syncTrackStripInsertParamByName', trackId, insertIndex, paramName, value });
+  setInsertParamByName(
+    ctx,
+    { kind: 'track', trackId },
+    insertIndex,
+    paramName,
+    value,
+    () =>
+      ctx.offlineEngine.restoreTrackStripInsertParamByName(trackId, insertIndex, paramName, value),
+    { type: 'syncTrackStripInsertParamByName', trackId, insertIndex, paramName, value },
+  );
 }
 
 export function setTrackStripPan(
@@ -79,6 +156,9 @@ export function setTrackStripPan(
 ): void {
   const trackId = trackIdFor(ctx, target);
   ctx.offlineEngine.setTrackStripPan(trackId, pan);
+  mergeStripJson(ctx, { kind: 'track', trackId }, (entry) => {
+    entry.pan = pan;
+  });
   ctx.postSync({ type: 'syncTrackStripPan', trackId, pan });
 }
 
@@ -90,6 +170,9 @@ export function setTrackStripPanLaw(
   const trackId = trackIdFor(ctx, target);
   const code = panLawCode(panLaw);
   ctx.offlineEngine.setTrackStripPanLaw(trackId, code);
+  mergeStripJson(ctx, { kind: 'track', trackId }, (entry) => {
+    entry.panLaw = code;
+  });
   ctx.postSync({ type: 'syncTrackStripPanLaw', trackId, panLaw: code });
 }
 
@@ -101,6 +184,9 @@ export function setTrackStripPanMode(
   const trackId = trackIdFor(ctx, target);
   const code = panModeCode(panMode);
   ctx.offlineEngine.setTrackStripPanMode(trackId, code);
+  mergeStripJson(ctx, { kind: 'track', trackId }, (entry) => {
+    entry.panMode = code;
+  });
   ctx.postSync({ type: 'syncTrackStripPanMode', trackId, panMode: code });
 }
 
@@ -112,6 +198,10 @@ export function setTrackStripDualPan(
 ): void {
   const trackId = trackIdFor(ctx, target);
   ctx.offlineEngine.setTrackStripDualPan(trackId, leftPan, rightPan);
+  mergeStripJson(ctx, { kind: 'track', trackId }, (entry) => {
+    entry.dualPanLeft = leftPan;
+    entry.dualPanRight = rightPan;
+  });
   ctx.postSync({ type: 'syncTrackStripDualPan', trackId, leftPan, rightPan });
 }
 
@@ -122,9 +212,26 @@ export function setTrackStripChannelDelaySamples(
 ): void {
   const trackId = trackIdFor(ctx, target);
   ctx.offlineEngine.setTrackStripChannelDelaySamples(trackId, delaySamples);
+  mergeStripJson(ctx, { kind: 'track', trackId }, (entry) => {
+    entry.channelDelaySamples = delaySamples;
+  });
   ctx.postSync({ type: 'syncTrackStripChannelDelaySamples', trackId, delaySamples });
 }
 
+/**
+ * Records a master fader or pan value the parameter path applied, so a master
+ * strip re-post does not reset it; a track lane keeps these outside its strip.
+ */
+export function cacheMasterStripScalar(
+  ctx: EngineStripContext,
+  field: 'faderDb' | 'pan',
+  value: number,
+): void {
+  mergeStripJson(ctx, { kind: 'master' }, (entry) => {
+    entry[field] = value;
+  });
+}
+
 export function setMasterStripEqBand(
   ctx: EngineStripContext,
   bandIndex: number,
@@ -132,6 +239,7 @@ export function setMasterStripEqBand(
 ): void {
   const bandJson = typeof band === 'string' ? band : JSON.stringify(band);
   ctx.offlineEngine.setMasterStripEqBandJson(bandIndex, bandJson);
+  mergeEqBand(ctx, { kind: 'master' }, bandIndex, bandJson);
   ctx.postSync({ type: 'syncMasterStripEqBand', bandIndex, bandJson });
 }
 
@@ -151,8 +259,15 @@ export function setMasterStripInsertParamByName(
   paramName: string,
   value: number,
 ): void {
-  ctx.offlineEngine.setMasterStripInsertParamByName(insertIndex, paramName, value);
-  ctx.postSync({ type: 'syncMasterStripInsertParamByName', insertIndex, paramName, value });
+  setInsertParamByName(
+    ctx,
+    { kind: 'master' },
+    insertIndex,
+    paramName,
+    value,
+    () => ctx.offlineEngine.restoreMasterStripInsertParamByName(insertIndex, paramName, value),
+    { type: 'syncMasterStripInsertParamByName', insertIndex, paramName, value },
+  );
 }
 
 export function setBusStripInsertParamByName(
@@ -162,8 +277,86 @@ export function setBusStripInsertParamByName(
   paramName: string,
   value: number,
 ): void {
-  ctx.offlineEngine.setBusStripInsertParamByName(busId, insertIndex, paramName, value);
-  ctx.postSync({ type: 'syncBusStripInsertParamByName', busId, insertIndex, paramName, value });
+  setInsertParamByName(
+    ctx,
+    { kind: 'bus', busId },
+    insertIndex,
+    paramName,
+    value,
+    () => ctx.offlineEngine.restoreBusStripInsertParamByName(busId, insertIndex, paramName, value),
+    { type: 'syncBusStripInsertParamByName', busId, insertIndex, paramName, value },
+  );
+}
+
+export function setBusStripInsertBypassed(
+  ctx: EngineStripContext,
+  busId: number,
+  insertIndex: number,
+  bypassed: boolean,
+  resetOnBypass: boolean,
+): void {
+  ctx.offlineEngine.setBusStripInsertBypassed(busId, insertIndex, bypassed, resetOnBypass);
+  ctx.postSync({ type: 'syncBusStripInsertBypassed', busId, insertIndex, bypassed, resetOnBypass });
+}
+
+export function setBusStripEqBand(
+  ctx: EngineStripContext,
+  busId: number,
+  bandIndex: number,
+  band: EqBand | string,
+): void {
+  const bandJson = typeof band === 'string' ? band : JSON.stringify(band);
+  ctx.offlineEngine.setBusStripEqBandJson(busId, bandIndex, bandJson);
+  mergeEqBand(ctx, { kind: 'bus', busId }, bandIndex, bandJson);
+  ctx.postSync({ type: 'syncBusStripEqBand', busId, bandIndex, bandJson });
+}
+
+export function setBusStripPan(ctx: EngineStripContext, busId: number, pan: number): void {
+  ctx.offlineEngine.setBusStripPan(busId, pan);
+  mergeStripJson(ctx, { kind: 'bus', busId }, (entry) => {
+    entry.pan = pan;
+  });
+  ctx.postSync({ type: 'syncBusStripPan', busId, pan });
+}
+
+export function setBusStripPanLaw(
+  ctx: EngineStripContext,
+  busId: number,
+  panLaw: PanLawInput,
+): void {
+  const code = panLawCode(panLaw);
+  ctx.offlineEngine.setBusStripPanLaw(busId, code);
+  mergeStripJson(ctx, { kind: 'bus', busId }, (entry) => {
+    entry.panLaw = code;
+  });
+  ctx.postSync({ type: 'syncBusStripPanLaw', busId, panLaw: code });
+}
+
+export function setBusStripPanMode(
+  ctx: EngineStripContext,
+  busId: number,
+  panMode: PanMode | number,
+): void {
+  const code = panModeCode(panMode);
+  ctx.offlineEngine.setBusStripPanMode(busId, code);
+  mergeStripJson(ctx, { kind: 'bus', busId }, (entry) => {
+    entry.panMode = code;
+  });
+  ctx.postSync({ type: 'syncBusStripPanMode', busId, panMode: code });
+}
+
+export function setBusStripDualPan(
+  ctx: EngineStripContext,
+  busId: number,
+  leftPan: number,
+  rightPan: number,
+): void {
+  ctx.offlineEngine.setBusStripDualPan(busId, leftPan, rightPan);
+  mergeStripJson(ctx, { kind: 'bus', busId }, (entry) => {
+    entry.dualPanLeft = leftPan;
+    entry.dualPanRight = rightPan;
+  });
+  ctx.postSync({ type: 'syncBusStripDualPan', busId, leftPan, rightPan });
 }
 
 export function pushMidiNoteOn(
@@ -232,6 +425,77 @@ export function pushMidiCc(
   });
 }
 
+export function pushMidiPitchBend(
+  ctx: EngineStripContext,
+  trackId: string | number,
+  group: number,
+  channel: number,
+  bend14: number,
+  renderFrame: number,
+): void {
+  const destinationId = ctx.resolveTargetId(trackId);
+  ctx.offlineEngine.pushMidiPitchBend(destinationId, group, channel, bend14, renderFrame);
+  ctx.postSync({
+    type: 'syncMidiPitchBend',
+    destinationId,
+    group,
+    channel,
+    data0: bend14,
+    data1: 0,
+    renderFrame,
+  });
+}
+
+export function pushMidiChannelPressure(
+  ctx: EngineStripContext,
+  trackId: string | number,
+  group: number,
+  channel: number,
+  pressure: number,
+  renderFrame: number,
+): void {
+  const destinationId = ctx.resolveTargetId(trackId);
+  ctx.offlineEngine.pushMidiChannelPressure(destinationId, group, channel, pressure, renderFrame);
+  ctx.postSync({
+    type: 'syncMidiChannelPressure',
+    destinationId,
+    group,
+    channel,
+    data0: pressure,
+    data1: 0,
+    renderFrame,
+  });
+}
+
+export function pushMidiPolyPressure(
+  ctx: EngineStripContext,
+  trackId: string | number,
+  group: number,
+  channel: number,
+  note: number,
+  pressure: number,
+  renderFrame: number,
+): void {
+  const destinationId = ctx.resolveTargetId(trackId);
+  ctx.offlineEngine.pushMidiPolyPressure(
+    destinationId,
+    group,
+    channel,
+    note,
+    pressure,
+    renderFrame,
+  );
+  ctx.postSync({
+    type: 'syncMidiPolyPressure',
+    destinationId,
+    group,
+    channel,
+    data0: note,
+    data1: pressure,
+    renderFrame,
+  });
+}
+
 export function pushMidiUmp(
   ctx: EngineStripContext,
   trackId: string | number,
@@ -239,7 +503,7 @@ export function pushMidiUmp(
   renderFrame: number,
 ): void {
   const destinationId = ctx.resolveTargetId(trackId);
-  ctx.offlineEngine.pushMidiUmp(destinationId, word0, renderFrame);
+  ctx.offlineEngine.pushMidiUmp(destinationId, [word0], renderFrame);
   ctx.postSync({ type: 'syncMidiUmp', destinationId, word0, renderFrame });
 }
 
@@ -276,6 +540,8 @@ export function setSf2Instrument(
     gain?: number;
     polyphony?: number;
     preferModelForModeledFamilies?: boolean;
+    clearBankRig?: boolean;
+    gsEfxRealization?: 'modern' | 'classic';
   },
 ): void {
   const destinationId = ctx.resolveTargetId(trackId);

package/src/worklet/engine-sync.ts

@@ -11,25 +11,30 @@ import type { SonareEngineSyncTempoMessage } from './messages';
  * Builds the ordered mixer-lane descriptors for a sync message.
  *
  * Each declared track id is paired with its current send list and output bus
- * (both omitted when absent), defensively copying the send entries.
+ * (both omitted when absent) and source channel layout, defensively copying the
+ * send entries.
  *
  * @param trackLaneIds Lane order (track ids) declared on the engine.
  * @param trackSends Per-track send lists.
  * @param trackOutputBus Per-track output bus routing.
+ * @param trackSourceChannelLayout Per-track source channel layouts.
  * @returns Lane descriptors in lane order.
  */
 export function buildMixerLanes(
   trackLaneIds: readonly number[],
   trackSends: ReadonlyMap<number, EngineTrackSend[]>,
   trackOutputBus: ReadonlyMap<number, number>,
+  trackSourceChannelLayout: ReadonlyMap<number, number>,
 ): EngineTrackLane[] {
   return trackLaneIds.map((trackId) => {
     const sends = trackSends.get(trackId);
     const outputBusId = trackOutputBus.get(trackId);
+    const sourceChannelLayout = trackSourceChannelLayout.get(trackId);
     return {
       trackId,
       ...(sends && sends.length > 0 ? { sends: sends.map((send) => ({ ...send })) } : {}),
       ...(outputBusId !== undefined ? { outputBusId } : {}),
+      ...(sourceChannelLayout !== undefined ? { sourceChannelLayout } : {}),
     };
   });
 }
@@ -54,15 +59,23 @@ export function buildTempoSync(
 }
 
 /**
- * Resolves a target id from a string or number; non-numeric strings resolve to
- * 0, mirroring the engine's integer-id namespace.
+ * Resolves a target id given as a number, or as a string naming one.
+ *
+ * Both spellings reach one refusal. Reading the string with `Number.parseInt`
+ * stops at the first non-digit, so `"3.5"` resolves to `3` and `"5abc"` to `5`,
+ * and an unparseable name resolves to `0` -- all ids the caller never named.
+ * `0` is a legal destination, so the native check these feed cannot tell the
+ * substitution from a deliberate choice and never reports one.
  */
 export function resolveTargetId(target: string | number): number {
-  if (typeof target === 'number') {
-    return target;
+  // An empty or blank string is not a spelling of zero, which is what Number
+  // reads it as.
+  const value =
+    typeof target === 'number' ? target : target.trim() === '' ? Number.NaN : Number(target);
+  if (!Number.isInteger(value)) {
+    throw new RangeError(`target id must be an integer, got ${JSON.stringify(target)}`);
   }
-  const parsed = Number.parseInt(target, 10);
-  return Number.isFinite(parsed) ? parsed : 0;
+  return value;
 }
 
 /** Resolves a registered parameter name or passes through a numeric id. */