react-native-waveform-player 0.0.1 → 1.0.0

package/ios/WaveformDecoder.swift

@@ -0,0 +1,332 @@
+import AVFoundation
+import Foundation
+
+/// Decode an audio file into per-bar RMS amplitudes for waveform visualisation.
+///
+/// `AVAssetReader` cannot read remote URLs, so for `https://` sources this
+/// class first downloads the file to a temporary location (with a codec-aware
+/// extension — `AVURLAsset` identifies the codec by extension, not MIME).
+///
+/// All callbacks fire on the **main** thread.
+final class WaveformDecoder {
+
+    // MARK: - Public
+
+    /// Begin decoding for `url`, computing exactly `barCount` RMS amplitudes.
+    /// Re-entrant: a fresh `decode()` call cancels any in-flight one.
+    ///
+    /// `progress` is called periodically (~5% then every ~20%) on the main
+    /// thread with a partial amplitudes array — this lets the bars view paint
+    /// in as the decode runs instead of waiting for the full file. `completion`
+    /// is called once with the final, fully-decoded amplitudes.
+    /// All amplitudes are normalised to `[0, 1]`.
+    func decode(
+        url: URL,
+        barCount: Int,
+        progress: @escaping ([CGFloat]) -> Void = { _ in },
+        completion: @escaping ([CGFloat]) -> Void,
+        failure: @escaping (String) -> Void
+    ) {
+        cancel()
+
+        guard barCount > 0 else {
+            completion([])
+            return
+        }
+
+        let token = UUID()
+        currentToken = token
+
+        if url.isFileURL {
+            decodeLocalFile(
+                url: url,
+                barCount: barCount,
+                token: token,
+                progress: progress,
+                completion: completion,
+                failure: failure
+            )
+            return
+        }
+
+        // Remote URL — download first, then decode.
+        let task = URLSession.shared.downloadTask(with: url) { [weak self] tempURL, response, error in
+            guard let self = self else { return }
+            // If a newer decode was kicked off, drop this one silently.
+            if self.currentToken != token { return }
+
+            if let error = error {
+                DispatchQueue.main.async { failure(error.localizedDescription) }
+                return
+            }
+            guard let tempURL = tempURL else {
+                DispatchQueue.main.async { failure("Download failed: empty response") }
+                return
+            }
+
+            let ext = Self.audioFileExtension(from: response, originalURL: url)
+            let dest = FileManager.default.temporaryDirectory
+                .appendingPathComponent("audiowaveform_\(UUID().uuidString).\(ext)")
+            do {
+                try FileManager.default.moveItem(at: tempURL, to: dest)
+            } catch {
+                DispatchQueue.main.async {
+                    failure("Failed to stage downloaded audio: \(error.localizedDescription)")
+                }
+                return
+            }
+            self.tempLocalURL = dest
+
+            self.decodeLocalFile(
+                url: dest,
+                barCount: barCount,
+                token: token,
+                progress: progress,
+                completion: completion,
+                failure: failure
+            )
+        }
+        downloadTask = task
+        task.resume()
+    }
+
+    /// Cancel any in-flight decode + download. Safe to call repeatedly.
+    func cancel() {
+        currentToken = UUID() // Bumping the token invalidates any in-flight closures.
+        downloadTask?.cancel()
+        downloadTask = nil
+        currentReader?.cancelReading()
+        currentReader = nil
+    }
+
+    /// Cleanup the on-disk temp file (if any). Call from `deinit` of the owner.
+    func cleanupTempFile() {
+        if let url = tempLocalURL {
+            try? FileManager.default.removeItem(at: url)
+            tempLocalURL = nil
+        }
+    }
+
+    deinit {
+        cancel()
+        cleanupTempFile()
+    }
+
+    // MARK: - Private
+
+    private var downloadTask: URLSessionDownloadTask?
+    private var currentReader: AVAssetReader?
+    private var tempLocalURL: URL?
+    private var currentToken: UUID = UUID()
+
+    /// Determine the correct audio file extension from the HTTP response.
+    /// Priority: suggested filename -> MIME type -> URL path extension -> "m4a".
+    /// Without this, `AVURLAsset` silently fails to identify the codec when
+    /// the file lives at a generic URL like `download?id=...`.
+    private static func audioFileExtension(from response: URLResponse?, originalURL: URL) -> String {
+        if let suggested = response?.suggestedFilename, !suggested.isEmpty {
+            let ext = (suggested as NSString).pathExtension
+            if !ext.isEmpty { return ext }
+        }
+        if let mimeType = response?.mimeType?.lowercased() {
+            switch mimeType {
+            case "audio/mpeg", "audio/mp3": return "mp3"
+            case "audio/mp4", "audio/x-m4a", "audio/aac": return "m4a"
+            case "audio/wav", "audio/x-wav", "audio/wave": return "wav"
+            case "audio/flac": return "flac"
+            case "audio/ogg", "audio/vorbis": return "ogg"
+            case "audio/aiff", "audio/x-aiff": return "aiff"
+            default: break
+            }
+        }
+        let urlExt = originalURL.pathExtension
+        if !urlExt.isEmpty { return urlExt }
+        return "m4a"
+    }
+
+    private func decodeLocalFile(
+        url: URL,
+        barCount: Int,
+        token: UUID,
+        progress: @escaping ([CGFloat]) -> Void,
+        completion: @escaping ([CGFloat]) -> Void,
+        failure: @escaping (String) -> Void
+    ) {
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            guard let self = self else { return }
+            if self.currentToken != token { return }
+
+            let asset = AVURLAsset(
+                url: url,
+                options: [AVURLAssetPreferPreciseDurationAndTimingKey: true]
+            )
+
+            // `tracks(withMediaType:)` blocks until tracks are loaded for local
+            // file URLs, which is fine on a background queue.
+            guard let track = asset.tracks(withMediaType: .audio).first else {
+                DispatchQueue.main.async {
+                    if self.currentToken == token { failure("Audio track not found") }
+                }
+                return
+            }
+
+            let reader: AVAssetReader
+            do {
+                reader = try AVAssetReader(asset: asset)
+            } catch {
+                DispatchQueue.main.async {
+                    if self.currentToken == token {
+                        failure("Failed to create reader: \(error.localizedDescription)")
+                    }
+                }
+                return
+            }
+
+            let outputSettings: [String: Any] = [
+                AVFormatIDKey: kAudioFormatLinearPCM,
+                AVLinearPCMIsFloatKey: true,
+                AVLinearPCMBitDepthKey: 32,
+                AVNumberOfChannelsKey: 1
+            ]
+            let output = AVAssetReaderTrackOutput(track: track, outputSettings: outputSettings)
+            guard reader.canAdd(output) else {
+                DispatchQueue.main.async {
+                    if self.currentToken == token { failure("Cannot add reader output") }
+                }
+                return
+            }
+            reader.add(output)
+
+            DispatchQueue.main.sync {
+                if self.currentToken == token {
+                    self.currentReader = reader
+                }
+            }
+
+            guard reader.startReading() else {
+                let msg = reader.error?.localizedDescription ?? "Failed to start reading"
+                DispatchQueue.main.async {
+                    if self.currentToken == token { failure(msg) }
+                }
+                return
+            }
+
+            // Bucket-by-time setup: with the asset duration we know each bar's
+            // time window up-front, so we can fill bars as samples stream in
+            // (and emit partial results periodically). Falls back to a 60 s
+            // budget for assets that don't expose a duration — matches the
+            // Android decoder's behaviour.
+            let durationSeconds = CMTimeGetSeconds(track.timeRange.duration)
+            let totalDurationUs: Double = (durationSeconds.isFinite && durationSeconds > 0)
+                ? durationSeconds * 1_000_000
+                : 60_000_000
+            let barDurationUs = totalDurationUs / Double(barCount)
+
+            var sumSquares = [Double](repeating: 0, count: barCount)
+            var sampleCounts = [Int](repeating: 0, count: barCount)
+            var sampleRate: Double = 0
+            var highestFilledBar = -1
+            let firstUpdateThreshold = max(1, barCount / 20)
+            let regularUpdateInterval = max(1, barCount / 5)
+            var lastUpdateBar = -1
+
+            while reader.status == .reading {
+                if self.currentToken != token { break }
+                guard let buffer = output.copyNextSampleBuffer() else { break }
+                guard let block = CMSampleBufferGetDataBuffer(buffer) else { continue }
+                let length = CMBlockBufferGetDataLength(block)
+                let count = length / MemoryLayout<Float>.size
+                guard count > 0 else { continue }
+
+                // Cache sample rate from the first buffer's format description.
+                if sampleRate == 0,
+                   let fmt = CMSampleBufferGetFormatDescription(buffer),
+                   let asbd = CMAudioFormatDescriptionGetStreamBasicDescription(fmt)?.pointee {
+                    sampleRate = asbd.mSampleRate
+                }
+                let effectiveSampleRate = sampleRate > 0 ? sampleRate : 44100
+
+                var data = [Float](repeating: 0, count: count)
+                CMBlockBufferCopyDataBytes(block, atOffset: 0, dataLength: length, destination: &data)
+
+                let pts = CMSampleBufferGetPresentationTimeStamp(buffer)
+                let bufferStartUs = CMTimeGetSeconds(pts) * 1_000_000
+                let usPerSample = 1_000_000 / effectiveSampleRate
+
+                for i in 0..<count {
+                    let sampleTimeUs = bufferStartUs + Double(i) * usPerSample
+                    var barIndex = Int(sampleTimeUs / barDurationUs)
+                    if barIndex < 0 { barIndex = 0 }
+                    if barIndex >= barCount { barIndex = barCount - 1 }
+                    let s = Double(data[i])
+                    sumSquares[barIndex] += s * s
+                    sampleCounts[barIndex] += 1
+                    if barIndex > highestFilledBar { highestFilledBar = barIndex }
+                }
+
+                let interval = lastUpdateBar < 0 ? firstUpdateThreshold : regularUpdateInterval
+                if highestFilledBar - max(0, lastUpdateBar) >= interval {
+                    lastUpdateBar = highestFilledBar
+                    let partial = Self.normaliseAmplitudes(
+                        sumSquares: sumSquares,
+                        sampleCounts: sampleCounts,
+                        barCount: barCount
+                    )
+                    DispatchQueue.main.async {
+                        if self.currentToken == token { progress(partial) }
+                    }
+                }
+            }
+
+            if self.currentToken != token { return }
+
+            let final = Self.normaliseAmplitudes(
+                sumSquares: sumSquares,
+                sampleCounts: sampleCounts,
+                barCount: barCount
+            )
+
+            // Sanity check: did we actually decode anything?
+            if highestFilledBar < 0 {
+                DispatchQueue.main.async {
+                    if self.currentToken == token { failure("No samples decoded") }
+                }
+                return
+            }
+
+            DispatchQueue.main.async {
+                if self.currentToken == token {
+                    self.currentReader = nil
+                    completion(final)
+                }
+            }
+        }
+    }
+
+    /// Compute per-bar RMS from accumulated `sumSquares` + `sampleCounts`,
+    /// then normalise the result to `[0, 1]` using the loudest bar as the
+    /// reference. Bars with zero samples (gaps in the time window) stay at 0.
+    private static func normaliseAmplitudes(
+        sumSquares: [Double],
+        sampleCounts: [Int],
+        barCount: Int
+    ) -> [CGFloat] {
+        var amps = [CGFloat](repeating: 0, count: barCount)
+        var maxAmp: CGFloat = 0
+        for i in 0..<barCount {
+            let n = sampleCounts[i]
+            if n > 0 {
+                let rms = sqrt(sumSquares[i] / Double(n))
+                let value = CGFloat(rms)
+                amps[i] = value
+                if value > maxAmp { maxAmp = value }
+            }
+        }
+        if maxAmp > 0 {
+            for i in 0..<barCount {
+                amps[i] = max(0, min(1, amps[i] / maxAmp))
+            }
+        }
+        return amps
+    }
+}

package/lib/module/AudioWaveformView.js

@@ -0,0 +1,8 @@
+"use strict";
+
+import { forwardRef } from 'react';
+function AudioWaveformViewInner(_props, _ref) {
+  throw new Error("'react-native-waveform-player' is only supported on native platforms.");
+}
+export const AudioWaveformView = /*#__PURE__*/forwardRef(AudioWaveformViewInner);
+//# sourceMappingURL=AudioWaveformView.js.map

package/lib/module/AudioWaveformView.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["forwardRef","AudioWaveformViewInner","_props","_ref","Error","AudioWaveformView"],"sourceRoot":"../../src","sources":["AudioWaveformView.tsx"],"mappings":";;AAAA,SAASA,UAAU,QAA2B,OAAO;AAmFrD,SAASC,sBAAsBA,CAC7BC,MAA8B,EAC9BC,IAAwC,EACjC;EACP,MAAM,IAAIC,KAAK,CACb,uEACF,CAAC;AACH;AAEA,OAAO,MAAMC,iBAAiB,gBAAGL,UAAU,CAGzCC,sBAAsB,CAAC","ignoreList":[]}

package/lib/module/AudioWaveformView.native.js

@@ -0,0 +1,79 @@
+"use strict";
+
+import { forwardRef, useImperativeHandle, useMemo, useRef } from 'react';
+import NativeAudioWaveformView, { Commands } from './AudioWaveformViewNativeComponent';
+import { jsx as _jsx } from "react/jsx-runtime";
+function AudioWaveformViewInner(props, ref) {
+  const nativeRef = useRef(null);
+  const {
+    playing,
+    speed,
+    onLoad,
+    onLoadError,
+    onPlayerStateChange,
+    onTimeUpdate,
+    onSeek,
+    onEnd,
+    ...rest
+  } = props;
+
+  // Translate the React-style controlled props (boolean/number/undefined) into
+  // the Fabric-friendly Int32/Float sentinels: -1 = uncontrolled.
+  const controlledPlaying = useMemo(() => {
+    if (playing === undefined) return -1;
+    return playing ? 1 : 0;
+  }, [playing]);
+  const controlledSpeed = useMemo(() => {
+    if (speed === undefined || !Number.isFinite(speed) || speed < 0) {
+      return -1;
+    }
+    return speed;
+  }, [speed]);
+  useImperativeHandle(ref, () => ({
+    play: () => {
+      if (nativeRef.current) Commands.play(nativeRef.current);
+    },
+    pause: () => {
+      if (nativeRef.current) Commands.pause(nativeRef.current);
+    },
+    toggle: () => {
+      if (nativeRef.current) Commands.toggle(nativeRef.current);
+    },
+    seekTo: positionMs => {
+      if (nativeRef.current) {
+        Commands.seekTo(nativeRef.current, Math.max(0, Math.round(positionMs)));
+      }
+    },
+    setSpeed: s => {
+      if (nativeRef.current) Commands.setSpeed(nativeRef.current, s);
+    }
+  }), []);
+  return /*#__PURE__*/_jsx(NativeAudioWaveformView, {
+    ref: nativeRef,
+    ...rest,
+    controlledPlaying: controlledPlaying,
+    controlledSpeed: controlledSpeed,
+    onLoad: onLoad ? e => onLoad(e.nativeEvent) : undefined,
+    onLoadError: onLoadError ? e => onLoadError(e.nativeEvent) : undefined,
+    onPlayerStateChange: onPlayerStateChange ? e => {
+      const {
+        state,
+        isPlaying,
+        speed: spd,
+        error
+      } = e.nativeEvent;
+      onPlayerStateChange({
+        state: state,
+        isPlaying,
+        speed: spd,
+        error: error && error.length > 0 ? error : undefined
+      });
+    } : undefined,
+    onTimeUpdate: onTimeUpdate ? e => onTimeUpdate(e.nativeEvent) : undefined,
+    onSeek: onSeek ? e => onSeek(e.nativeEvent) : undefined,
+    onEnd: onEnd ? () => onEnd() : undefined
+  });
+}
+export const AudioWaveformView = /*#__PURE__*/forwardRef(AudioWaveformViewInner);
+AudioWaveformView.displayName = 'AudioWaveformView';
+//# sourceMappingURL=AudioWaveformView.native.js.map

package/lib/module/AudioWaveformView.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["forwardRef","useImperativeHandle","useMemo","useRef","NativeAudioWaveformView","Commands","jsx","_jsx","AudioWaveformViewInner","props","ref","nativeRef","playing","speed","onLoad","onLoadError","onPlayerStateChange","onTimeUpdate","onSeek","onEnd","rest","controlledPlaying","undefined","controlledSpeed","Number","isFinite","play","current","pause","toggle","seekTo","positionMs","Math","max","round","setSpeed","s","e","nativeEvent","state","isPlaying","spd","error","length","AudioWaveformView","displayName"],"sourceRoot":"../../src","sources":["AudioWaveformView.native.tsx"],"mappings":"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","ignoreList":[]}

package/lib/module/AudioWaveformViewNativeComponent.ts

@@ -0,0 +1,95 @@
+import {
+  codegenNativeComponent,
+  codegenNativeCommands,
+  type CodegenTypes,
+  type ColorValue,
+  type HostComponent,
+  type ViewProps,
+} from 'react-native';
+
+type Source = Readonly<{ uri: string }>;
+
+type OnLoadEvent = Readonly<{ durationMs: CodegenTypes.Int32 }>;
+type OnLoadErrorEvent = Readonly<{ message: string }>;
+type OnPlayerStateChangeEvent = Readonly<{
+  state: string;
+  isPlaying: boolean;
+  speed: CodegenTypes.Float;
+  error: string;
+}>;
+type OnTimeUpdateEvent = Readonly<{
+  currentTimeMs: CodegenTypes.Int32;
+  durationMs: CodegenTypes.Int32;
+}>;
+type OnSeekEvent = Readonly<{ positionMs: CodegenTypes.Int32 }>;
+type OnEndEvent = Readonly<{}>;
+
+export interface NativeProps extends ViewProps {
+  source: Source;
+  samples?: ReadonlyArray<CodegenTypes.Float>;
+
+  playedBarColor?: ColorValue;
+  unplayedBarColor?: ColorValue;
+
+  barWidth?: CodegenTypes.WithDefault<CodegenTypes.Float, 3.0>;
+  barGap?: CodegenTypes.WithDefault<CodegenTypes.Float, 2.0>;
+  // -1 sentinel = "auto" (barWidth / 2)
+  barRadius?: CodegenTypes.WithDefault<CodegenTypes.Float, -1.0>;
+  // 0 sentinel = "auto from width"
+  barCount?: CodegenTypes.WithDefault<CodegenTypes.Int32, 0>;
+
+  containerBackgroundColor?: ColorValue;
+  containerBorderRadius?: CodegenTypes.WithDefault<CodegenTypes.Float, 16.0>;
+  showBackground?: CodegenTypes.WithDefault<boolean, true>;
+
+  showPlayButton?: CodegenTypes.WithDefault<boolean, true>;
+  playButtonColor?: ColorValue;
+
+  showTime?: CodegenTypes.WithDefault<boolean, true>;
+  timeColor?: ColorValue;
+  timeMode?: CodegenTypes.WithDefault<'count-up' | 'count-down', 'count-up'>;
+
+  showSpeedControl?: CodegenTypes.WithDefault<boolean, true>;
+  speedColor?: ColorValue;
+  speedBackgroundColor?: ColorValue;
+  speeds?: ReadonlyArray<CodegenTypes.Float>;
+  defaultSpeed?: CodegenTypes.WithDefault<CodegenTypes.Float, 1.0>;
+
+  autoPlay?: CodegenTypes.WithDefault<boolean, false>;
+  initialPositionMs?: CodegenTypes.WithDefault<CodegenTypes.Int32, 0>;
+  loop?: CodegenTypes.WithDefault<boolean, false>;
+  playInBackground?: CodegenTypes.WithDefault<boolean, false>;
+  pauseUiUpdatesInBackground?: CodegenTypes.WithDefault<boolean, true>;
+
+  // -1 sentinel = "uncontrolled" — internal state drives playback.
+  controlledPlaying?: CodegenTypes.WithDefault<CodegenTypes.Int32, -1>;
+  // -1 sentinel = "uncontrolled" — internal state drives speed.
+  controlledSpeed?: CodegenTypes.WithDefault<CodegenTypes.Float, -1.0>;
+
+  onLoad?: CodegenTypes.DirectEventHandler<OnLoadEvent>;
+  onLoadError?: CodegenTypes.DirectEventHandler<OnLoadErrorEvent>;
+  onPlayerStateChange?: CodegenTypes.DirectEventHandler<OnPlayerStateChangeEvent>;
+  onTimeUpdate?: CodegenTypes.DirectEventHandler<OnTimeUpdateEvent>;
+  onSeek?: CodegenTypes.DirectEventHandler<OnSeekEvent>;
+  onEnd?: CodegenTypes.DirectEventHandler<OnEndEvent>;
+}
+
+interface NativeCommands {
+  play: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+  pause: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+  toggle: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+  seekTo: (
+    viewRef: React.ElementRef<HostComponent<NativeProps>>,
+    positionMs: CodegenTypes.Int32
+  ) => void;
+  setSpeed: (
+    viewRef: React.ElementRef<HostComponent<NativeProps>>,
+    speed: CodegenTypes.Float
+  ) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['play', 'pause', 'toggle', 'seekTo', 'setSpeed'],
+});
+
+export default codegenNativeComponent<NativeProps>('AudioWaveformView');

package/lib/module/index.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export { AudioWaveformView } from './AudioWaveformView';
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["AudioWaveformView"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,iBAAiB,QAAQ,qBAAqB","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}