fix: address native meter review feedback

Author: ChuxiJ

src/engine/bridge/TauriBackend.ts

@@ -27,9 +27,10 @@ import type {
 } from './types';
 import type { MasteringState } from '../../types/project';
 
-const ZERO_METER: MeterData = { level: -Infinity, leftLevel: -Infinity, rightLevel: -Infinity, clipped: false };
-const ZERO_MASTER: MasterMeterData = { level: -Infinity, clipped: false };
+const ZERO_METER: MeterData = { level: 0, leftLevel: 0, rightLevel: 0, clipped: false };
+const ZERO_MASTER: MasterMeterData = { level: 0, clipped: false };
 const TRANSPORT_POSITION_EVENT = 'transport-position';
+const METER_REFRESH_INTERVAL_MS = 50;
 
 function toMeterData(reading: NativeMeterReading): MeterData {
   const level = Number.isFinite(reading.peak) && reading.peak > 0 ? reading.peak : 0;
@@ -58,9 +59,11 @@ function isAlreadyRunningError(error: unknown): boolean {
 
 function getPanGains(pan: number): { left: number; right: number } {
   const clamped = Math.max(-1, Math.min(1, Number.isFinite(pan) ? pan : 0));
-  if (clamped < 0) return { left: 1, right: 1 + clamped };
-  if (clamped > 0) return { left: 1 - clamped, right: 1 };
-  return { left: 1, right: 1 };
+  const angle = ((clamped + 1) * Math.PI) / 4;
+  return {
+    left: Math.cos(angle),
+    right: Math.sin(angle),
+  };
 }
 
 function clipToNative(
@@ -122,6 +125,10 @@ export class TauriBackend implements AudioBridge {
   private _decodeContext: AudioContext | null = null;
   private _trackMeters = new Map<string, MeterData>();
   private _masterMeter: MasterMeterData = ZERO_MASTER;
+  private _lastTrackMeterRefreshMs = new Map<string, number>();
+  private _trackMeterRefreshInFlight = new Set<string>();
+  private _lastMasterMeterRefreshMs = -Infinity;
+  private _masterMeterRefreshInFlight = false;
   private _transportCommandToken = 0;
   private _lastScheduledClips: BridgeClipInfo[] = [];
 
@@ -276,12 +283,15 @@ export class TauriBackend implements AudioBridge {
 
   getTrackMeter(_trackId: string): MeterData {
     const entry = this._trackEntries.get(_trackId);
-    if (entry?.handle) {
+    if (entry?.handle && this.shouldRefreshTrackMeter(_trackId)) {
       invoke<NativeMeterReading>('audio_get_track_meter', { handle: entry.handle })
         .then((reading) => {
           this._trackMeters.set(_trackId, toMeterData(reading));
         })
-        .catch(() => {});
+        .catch(() => {})
+        .finally(() => {
+          this._trackMeterRefreshInFlight.delete(_trackId);
+        });
     }
     return this._trackMeters.get(_trackId) ?? ZERO_METER;
   }
@@ -299,11 +309,16 @@ export class TauriBackend implements AudioBridge {
   }
 
   getMasterMeter(_stage: 'input' | 'output'): MasterMeterData {
-    invoke<NativeMeterReading>('audio_get_master_meter')
-      .then((reading) => {
-        this._masterMeter = toMasterMeterData(reading);
-      })
-      .catch(() => {});
+    if (this.shouldRefreshMasterMeter()) {
+      invoke<NativeMeterReading>('audio_get_master_meter')
+        .then((reading) => {
+          this._masterMeter = toMasterMeterData(reading);
+        })
+        .catch(() => {})
+        .finally(() => {
+          this._masterMeterRefreshInFlight = false;
+        });
+    }
     return this._masterMeter;
   }
 
@@ -343,13 +358,14 @@ export class TauriBackend implements AudioBridge {
     const token = ++this._transportCommandToken;
     this._lastScheduledClips = clips;
     const nativeClips = this.buildNativeClips(clips);
+    const seekSamplePosition = Math.max(0, Math.round(fromTime * this.sampleRate));
     this._scheduledEndSample = Math.max(0, Math.round(totalDuration * this.sampleRate));
-    this._currentSamplePosition = Math.max(0, Math.round(fromTime * this.sampleRate));
+    this._currentSamplePosition = seekSamplePosition;
 
     void (async () => {
       await invoke('audio_clip_set_schedule', { clips: nativeClips });
       if (token !== this._transportCommandToken) return;
-      await invoke('audio_transport_seek', { samplePosition: this._currentSamplePosition });
+      await invoke('audio_transport_seek', { samplePosition: seekSamplePosition });
       if (token !== this._transportCommandToken) return;
       await invoke('audio_transport_play');
     })().catch(() => {});
@@ -391,6 +407,29 @@ export class TauriBackend implements AudioBridge {
       .filter((clip): clip is NativeClipSource => clip !== null);
   }
 
+  private meterNowMs(): number {
+    return typeof performance !== 'undefined' ? performance.now() : Date.now();
+  }
+
+  private shouldRefreshTrackMeter(trackId: string): boolean {
+    if (this._trackMeterRefreshInFlight.has(trackId)) return false;
+    const now = this.meterNowMs();
+    const last = this._lastTrackMeterRefreshMs.get(trackId) ?? -Infinity;
+    if (now - last < METER_REFRESH_INTERVAL_MS) return false;
+    this._lastTrackMeterRefreshMs.set(trackId, now);
+    this._trackMeterRefreshInFlight.add(trackId);
+    return true;
+  }
+
+  private shouldRefreshMasterMeter(): boolean {
+    if (this._masterMeterRefreshInFlight) return false;
+    const now = this.meterNowMs();
+    if (now - this._lastMasterMeterRefreshMs < METER_REFRESH_INTERVAL_MS) return false;
+    this._lastMasterMeterRefreshMs = now;
+    this._masterMeterRefreshInFlight = true;
+    return true;
+  }
+
   private republishActiveSchedule(): void {
     if (this._scheduledEndSample === null || this._lastScheduledClips.length === 0) return;
     const token = this._transportCommandToken;

src/engine/bridge/__tests__/TauriBackend.test.ts

@@ -24,6 +24,12 @@ function createMockAudioBuffer(samples: number[], sampleRate = 48000): AudioBuff
   } as unknown as AudioBuffer;
 }
 
+function equalPowerPan(pan: number): { left: number; right: number } {
+  const clamped = Math.max(-1, Math.min(1, pan));
+  const angle = ((clamped + 1) * Math.PI) / 4;
+  return { left: Math.cos(angle), right: Math.sin(angle) };
+}
+
 describe('TauriBackend', () => {
   let backend: TauriBackend;
 
@@ -70,22 +76,22 @@ describe('TauriBackend', () => {
 
   it('getTrackMeter returns silent meter', () => {
     const meter = backend.getTrackMeter('any-track');
-    expect(meter.level).toBe(-Infinity);
+    expect(meter.level).toBe(0);
     expect(meter.clipped).toBe(false);
   });
 
-  it('getTrackLevel returns -Infinity', () => {
-    expect(backend.getTrackLevel('any-track')).toBe(-Infinity);
+  it('getTrackLevel returns silence by default', () => {
+    expect(backend.getTrackLevel('any-track')).toBe(0);
   });
 
   it('getMasterMeter returns silent meter', () => {
     const meter = backend.getMasterMeter('output');
-    expect(meter.level).toBe(-Infinity);
+    expect(meter.level).toBe(0);
     expect(meter.clipped).toBe(false);
   });
 
-  it('getMasterLevel returns -Infinity', () => {
-    expect(backend.getMasterLevel('input')).toBe(-Infinity);
+  it('getMasterLevel returns silence by default', () => {
+    expect(backend.getMasterLevel('input')).toBe(0);
   });
 
   it('getTrackSpectrum returns null', () => {
@@ -207,6 +213,7 @@ describe('TauriBackend', () => {
 
   it('schedulePlayback sends clips through native schedule and starts transport', async () => {
     const buffer = createMockAudioBuffer([0.125, 0.25, 0.5, 1]);
+    const centerPan = equalPowerPan(0);
 
     backend.schedulePlayback([
       {
@@ -217,7 +224,7 @@ describe('TauriBackend', () => {
         audioOffset: 0,
         clipDuration: 4 / 48000,
       },
-    ], 1, 2);
+    ], 1, 3);
     await Promise.resolve();
     await Promise.resolve();
     await Promise.resolve();
@@ -228,17 +235,63 @@ describe('TauriBackend', () => {
           startSample: 48000,
           lengthSamples: 4,
           gain: 1,
-          audioData: [0.125, 0.125, 0.25, 0.25, 0.5, 0.5, 1, 1],
+          audioData: [
+            0.125 * centerPan.left,
+            0.125 * centerPan.right,
+            0.25 * centerPan.left,
+            0.25 * centerPan.right,
+            0.5 * centerPan.left,
+            0.5 * centerPan.right,
+            centerPan.left,
+            centerPan.right,
+          ],
         },
       ],
     });
     expect(invokeMock).toHaveBeenCalledWith('audio_transport_seek', { samplePosition: 48000 });
     expect(invokeMock).toHaveBeenCalledWith('audio_transport_play');
   });
 
+  it('uses the scheduled seek sample even if transport events update the cache first', async () => {
+    let positionHandler: ((event: { payload: number }) => void) | null = null;
+    let resolveSchedule!: () => void;
+    invokeMock.mockImplementation((command) => {
+      if (command === 'audio_clip_set_schedule') {
+        return new Promise((resolve) => {
+          resolveSchedule = () => resolve(undefined);
+        });
+      }
+      return Promise.resolve(undefined);
+    });
+    listenMock.mockImplementation(async (_event, handler) => {
+      positionHandler = handler as (event: { payload: number }) => void;
+      return vi.fn();
+    });
+    const buffer = createMockAudioBuffer([1]);
+    backend.setTimeUpdateCallback(() => {});
+
+    backend.schedulePlayback([
+      {
+        clipId: 'clip-1',
+        trackId: 'track-1',
+        startTime: 1,
+        buffer,
+        audioOffset: 0,
+        clipDuration: 1 / 48000,
+      },
+    ], 1, 3);
+    positionHandler?.({ payload: 96000 });
+    resolveSchedule();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(invokeMock).toHaveBeenCalledWith('audio_transport_seek', { samplePosition: 48000 });
+  });
+
   it('applies cached track volume, pan, mute, and solo before native scheduling', async () => {
     const audibleBuffer = createMockAudioBuffer([1, 1]);
     const mutedBuffer = createMockAudioBuffer([1, 1]);
+    const pan = equalPowerPan(-0.5);
     backend.ensureTrack('audible');
     backend.ensureTrack('muted');
     backend.setTrackParams('audible', { volume: 0.5, pan: -0.5, soloed: true });
@@ -272,14 +325,15 @@ describe('TauriBackend', () => {
           startSample: 0,
           lengthSamples: 2,
           gain: 1,
-          audioData: [0.5, 0.25, 0.5, 0.25],
+          audioData: [0.5 * pan.left, 0.5 * pan.right, 0.5 * pan.left, 0.5 * pan.right],
         },
       ],
     });
   });
 
   it('republishes active native schedule when track params change', async () => {
     const buffer = createMockAudioBuffer([1, 1]);
+    const pan = equalPowerPan(0.5);
     invokeMock.mockResolvedValueOnce({ slot: 0, generation: 1 });
     backend.ensureTrack('track-1');
     await Promise.resolve();
@@ -307,7 +361,7 @@ describe('TauriBackend', () => {
           startSample: 0,
           lengthSamples: 2,
           gain: 1,
-          audioData: [0.125, 0.25, 0.125, 0.25],
+          audioData: [0.25 * pan.left, 0.25 * pan.right, 0.25 * pan.left, 0.25 * pan.right],
         },
       ],
     });
@@ -374,6 +428,7 @@ describe('TauriBackend', () => {
 
   it('resamples non-48kHz buffers before sending native clips', async () => {
     const buffer = createMockAudioBuffer([0, 1], 24000);
+    const centerPan = equalPowerPan(0);
 
     backend.schedulePlayback([
       {
@@ -395,7 +450,16 @@ describe('TauriBackend', () => {
           startSample: 0,
           lengthSamples: 4,
           gain: 1,
-          audioData: [0, 0, 0.5, 0.5, 1, 1, 1, 1],
+          audioData: [
+            0,
+            0,
+            0.5 * centerPan.left,
+            0.5 * centerPan.right,
+            centerPan.left,
+            centerPan.right,
+            centerPan.left,
+            centerPan.right,
+          ],
         },
       ],
     });
@@ -412,4 +476,28 @@ describe('TauriBackend', () => {
 
     expect(invokeMock).toHaveBeenCalledWith('audio_get_track_meter', expect.any(Object));
   });
+
+  it('throttles track meter refreshes while a native request is in flight', async () => {
+    invokeMock.mockResolvedValueOnce({ slot: 0, generation: 1 });
+    backend.ensureTrack('track-1');
+    await Promise.resolve();
+    invokeMock.mockClear();
+
+    invokeMock.mockResolvedValue({ rms: 0.2, peak: 0.4, clipped: false });
+    backend.getTrackMeter('track-1');
+    backend.getTrackMeter('track-1');
+
+    expect(invokeMock).toHaveBeenCalledTimes(1);
+    expect(invokeMock).toHaveBeenCalledWith('audio_get_track_meter', expect.any(Object));
+  });
+
+  it('throttles master meter refreshes while a native request is in flight', () => {
+    invokeMock.mockResolvedValue({ rms: 0.2, peak: 0.4, clipped: false });
+
+    backend.getMasterMeter('output');
+    backend.getMasterMeter('input');
+
+    expect(invokeMock).toHaveBeenCalledTimes(1);
+    expect(invokeMock).toHaveBeenCalledWith('audio_get_master_meter');
+  });
 });