react-native-video-trim 7.0.1 → 7.1.1

package/ios/AudioWaveformView.swift

@@ -0,0 +1,75 @@
+import UIKit
+
+/// Custom UIView that draws an audio waveform as a row of vertical rounded-rect bars.
+///
+/// Each bar's height is driven by a normalized amplitude value in [0, 1].
+/// The view recalculates bar count from its own width and maps the amplitudes
+/// array proportionally, so it works correctly regardless of whether the
+/// amplitudes array has more or fewer entries than the visible bar count.
+///
+/// The `backgroundColor` provides the waveform track color; bars are drawn
+/// on top with `barColor`.
+class AudioWaveformView: UIView {
+    var amplitudes: [CGFloat] = [] {
+        didSet { setNeedsDisplay() }
+    }
+
+    var barColor: UIColor = .white {
+        didSet { setNeedsDisplay() }
+    }
+
+    var barWidth: CGFloat = 3 {
+        didSet { setNeedsDisplay() }
+    }
+
+    var barGap: CGFloat = 2 {
+        didSet { setNeedsDisplay() }
+    }
+
+    var barCornerRadius: CGFloat = 1.5 {
+        didSet { setNeedsDisplay() }
+    }
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        isOpaque = false
+        contentMode = .redraw
+    }
+
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        isOpaque = false
+        contentMode = .redraw
+    }
+
+    override func draw(_ rect: CGRect) {
+        guard !amplitudes.isEmpty else { return }
+        guard let ctx = UIGraphicsGetCurrentContext() else { return }
+
+        let totalHeight = rect.height
+        let step = barWidth + barGap
+        let barCount = Int(floor(rect.width / step))
+        guard barCount > 0 else { return }
+
+        // Keep bars from touching the container edges
+        let verticalPadding = barWidth * 1.5
+        let drawableHeight = totalHeight - verticalPadding * 2
+        guard drawableHeight > 0 else { return }
+        let minBarHeight = barWidth
+
+        ctx.setFillColor(barColor.cgColor)
+
+        for i in 0..<barCount {
+            let ampIndex = i * amplitudes.count / barCount
+            let amp = amplitudes[min(ampIndex, amplitudes.count - 1)]
+            let barHeight = max(minBarHeight, amp * drawableHeight)
+            let x = CGFloat(i) * step
+            let y = verticalPadding + (drawableHeight - barHeight) / 2.0
+            let barRect = CGRect(x: x, y: y, width: barWidth, height: barHeight)
+            let path = UIBezierPath(roundedRect: barRect, cornerRadius: barCornerRadius)
+            ctx.addPath(path.cgPath)
+        }
+
+        ctx.fillPath()
+    }
+}

package/ios/CropOverlayView.swift

@@ -26,6 +26,10 @@ class CropOverlayView: UIView {
     var onCropBegan: (() -> Void)?
     var onCropEnded: (() -> Void)?
 
+    var isLightTheme = false {
+        didSet { setNeedsDisplay() }
+    }
+
     private let minCropSize: CGFloat = 60
     private let borderWidth: CGFloat = 1.0
     private let cornerLength: CGFloat = 20
@@ -73,16 +77,8 @@ class CropOverlayView: UIView {
         guard !cropRect.isEmpty, let ctx = UIGraphicsGetCurrentContext() else { return }
         let cr = cropRect
 
-        ctx.saveGState()
-        let fullPath = UIBezierPath(rect: bounds)
-        fullPath.append(UIBezierPath(rect: cr))
-        fullPath.usesEvenOddFillRule = true
-        ctx.addPath(fullPath.cgPath)
-        ctx.setFillColor(UIColor.black.withAlphaComponent(0.55).cgColor)
-        ctx.fillPath(using: .evenOdd)
-        ctx.restoreGState()
-
-        ctx.setStrokeColor(UIColor.white.cgColor)
+        let strokeColor = (isLightTheme ? UIColor.black : UIColor.white).cgColor
+        ctx.setStrokeColor(strokeColor)
         ctx.setLineWidth(borderWidth)
         ctx.stroke(cr)
 
@@ -99,7 +95,7 @@ class CropOverlayView: UIView {
         }
         ctx.strokePath()
 
-        ctx.setStrokeColor(UIColor.white.cgColor)
+        ctx.setStrokeColor(strokeColor)
         ctx.setLineWidth(cornerWidth)
         ctx.setLineCap(.round)
         ctx.setLineJoin(.round)

package/ios/VideoTrim.mm

@@ -155,11 +155,41 @@ RCT_EXPORT_MODULE()
     dict[@"handleIconColor"] = @(handleIconColorOpt.value());
   }
   
+  auto waveformColorOpt = config.waveformColor();
+  if (waveformColorOpt.has_value()) {
+    dict[@"waveformColor"] = @(waveformColorOpt.value());
+  }
+  
+  auto waveformBackgroundColorOpt = config.waveformBackgroundColor();
+  if (waveformBackgroundColorOpt.has_value()) {
+    dict[@"waveformBackgroundColor"] = @(waveformBackgroundColorOpt.value());
+  }
+  
+  auto waveformBarWidthOpt = config.waveformBarWidth();
+  if (waveformBarWidthOpt.has_value()) {
+    dict[@"waveformBarWidth"] = @(waveformBarWidthOpt.value());
+  }
+  
+  auto waveformBarGapOpt = config.waveformBarGap();
+  if (waveformBarGapOpt.has_value()) {
+    dict[@"waveformBarGap"] = @(waveformBarGapOpt.value());
+  }
+  
+  auto waveformBarCornerRadiusOpt = config.waveformBarCornerRadius();
+  if (waveformBarCornerRadiusOpt.has_value()) {
+    dict[@"waveformBarCornerRadius"] = @(waveformBarCornerRadiusOpt.value());
+  }
+  
   auto zoomOnWaitingDurationOpt = config.zoomOnWaitingDuration();
   if (zoomOnWaitingDurationOpt.has_value()) {
     dict[@"zoomOnWaitingDuration"] = @(zoomOnWaitingDurationOpt.value());
   }
   
+  NSString *theme = config.theme();
+  if (theme != nil) {
+    dict[@"theme"] = theme;
+  }
+  
   [self->videoTrim showEditor:filePath withConfig:dict];
 }
 

package/ios/VideoTrim.swift

@@ -13,6 +13,9 @@ public class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDe
   private var vc: VideoTrimmerViewController?
   private var outputFile: URL?
   private var editorConfig: NSDictionary?
+  private var isLightTheme: Bool {
+    return (editorConfig?["theme"] as? String) == "light"
+  }
   
   // MARK: base options
   private var saveToPhoto: Bool {
@@ -289,7 +292,7 @@ public class VideoTrim: RCTEventEmitter, AssetLoaderDelegate, UIDocumentPickerDe
       progressAlert.onDismiss = {
         if self.enableCancelTrimmingDialog {
           let dialogMessage = UIAlertController(title: self.cancelTrimmingDialogTitle, message: self.cancelTrimmingDialogMessage, preferredStyle: .alert)
-          dialogMessage.overrideUserInterfaceStyle = .dark
+          dialogMessage.overrideUserInterfaceStyle = self.isLightTheme ? .light : .dark
           
           // Create OK button with action handler
           let ok = UIAlertAction(title: self.cancelTrimmingDialogConfirmText, style: .destructive, handler: { (action) -> Void in
@@ -879,7 +882,7 @@ extension VideoTrim {
         
         // Create Alert
         let dialogMessage = UIAlertController(title: self.cancelDialogTitle, message: self.cancelDialogMessage, preferredStyle: .alert)
-        dialogMessage.overrideUserInterfaceStyle = .dark
+        dialogMessage.overrideUserInterfaceStyle = self.isLightTheme ? .light : .dark
         
         // Create OK button with action handler
         let ok = UIAlertAction(title: self.cancelDialogConfirmText, style: .destructive, handler: { (action) -> Void in
@@ -911,7 +914,7 @@ extension VideoTrim {
         
         // Create Alert
         let dialogMessage = UIAlertController(title: self.saveDialogTitle, message: self.saveDialogMessage, preferredStyle: .alert)
-        dialogMessage.overrideUserInterfaceStyle = .dark
+        dialogMessage.overrideUserInterfaceStyle = self.isLightTheme ? .light : .dark
         
         // Create OK button with action handler
         let ok = UIAlertAction(title: self.saveDialogConfirmText, style: .default, handler: { (action) -> Void in
@@ -1134,7 +1137,7 @@ extension VideoTrim {
     
     if alertOnFailToLoad {
       let dialogMessage = UIAlertController(title: alertOnFailTitle, message: alertOnFailMessage, preferredStyle: .alert)
-      dialogMessage.overrideUserInterfaceStyle = .dark
+      dialogMessage.overrideUserInterfaceStyle = isLightTheme ? .light : .dark
       
       // Create Cancel button with action handlder
       let ok = UIAlertAction(title: alertOnFailCloseText, style: .default)

package/ios/VideoTrimmer.swift

@@ -133,14 +133,27 @@ import AVFoundation
         }
     }
     
-    // the asset to use
     var asset: AVAsset? {
         didSet {
+            // Clean up *all* async resources unconditionally — even when
+            // asset is set to nil (e.g. editor dismissal triggers this via
+            // VideoTrimmerViewController.viewWillDisappear).
+            generator?.cancelAllCGImageGeneration()
+            currentAssetReader?.cancelReading()
+            currentAssetReader = nil
+            audioDownloadTask?.cancel()
+            audioDownloadTask = nil
+            cleanupLocalAudioFile()
+            localAudioAsset = nil
+            
             if let asset = asset {
+                applyThemeColors()
                 let duration = asset.duration
                 range = CMTimeRange(start: .zero, duration: duration)
                 selectedRange = range
                 lastKnownViewSizeForThumbnailGeneration = .zero
+                lastKnownWaveformSize = .zero
+                lastKnownWaveformRange = .zero
                 setNeedsLayout()
             }
         }
@@ -159,6 +172,35 @@ import AVFoundation
     var maximumDuration: CMTime = .positiveInfinity
     var enableHapticFeedback = true
     var zoomOnWaitingDuration: Double = 5.0 // Default: 5 seconds
+    var isLightTheme = false
+    /// Explicitly set from JS config (`type != "video"`).
+    /// Using a dedicated flag instead of inspecting AVAsset tracks avoids
+    /// false negatives — some audio files (e.g. M4A with album art) report
+    /// a video track, which caused the original `.video` track guard to
+    /// skip waveform generation entirely.
+    var isAudioOnly = false {
+        didSet {
+            lastKnownWaveformSize = .zero
+            setNeedsLayout()
+        }
+    }
+    
+    // MARK: - Waveform customisation (forwarded to AudioWaveformView)
+    var waveformBarColor: UIColor = .white {
+        didSet { waveformView.barColor = waveformBarColor }
+    }
+    var waveformBgColor: UIColor = UIColor(red: 0.204, green: 0.471, blue: 0.965, alpha: 1) {
+        didSet { waveformView.backgroundColor = waveformBgColor }
+    }
+    var waveformBarWidth: CGFloat = 3 {
+        didSet { waveformView.barWidth = waveformBarWidth }
+    }
+    var waveformBarGap: CGFloat = 2 {
+        didSet { waveformView.barGap = waveformBarGap }
+    }
+    var waveformBarCornerRadius: CGFloat = 1.5 {
+        didSet { waveformView.barCornerRadius = waveformBarCornerRadius }
+    }
     
     // the available range of the asset.
     // Will be set to the full duration of the asset when assigning a new asset
@@ -219,14 +261,12 @@ import AVFoundation
     // yes if the user is scrubbing the progress indicator
     private(set) var isScrubbing = false
     
-    // background color for the track
     var trackBackgroundColor = UIColor.black {
         didSet {
             thumbnailWrapperView.backgroundColor = trackBackgroundColor
         }
     }
     
-    // background color for the place where the thumbs rest on when the selectedRange == range
     var thumbRestColor = UIColor.black {
         didSet {
             leadingThumbRest.backgroundColor = thumbRestColor
@@ -271,22 +311,66 @@ import AVFoundation
     private var thumbnails = Array<Thumbnail>()
     private var generator: AVAssetImageGenerator?
     
+    // MARK: - Audio waveform state
+    //
+    // AVAssetReader cannot read from remote URLs, so for remote audio we
+    // download to a temporary local file first (via URLSession.downloadTask).
+    // The local AVURLAsset is reused for zoom re-extractions, and the temp
+    // file is deleted in cleanupLocalAudioFile() on dismiss.
+    private let waveformView = AudioWaveformView()
+    private var lastKnownWaveformSize: CGSize = .zero
+    private var lastKnownWaveformRange: CMTimeRange = .zero
+    private var currentAssetReader: AVAssetReader?
+    /** AVURLAsset pointing to the downloaded local file (nil for local sources). */
+    private var localAudioAsset: AVURLAsset?
+    /** File URL of the temporary download, for deletion on cleanup. */
+    private var localAudioFileURL: URL?
+    private var audioDownloadTask: URLSessionDownloadTask?
+    
     private var impactFeedbackGenerator: UIImpactFeedbackGenerator?
     private var didClampWhilePanning = false
     
     
+    /// Cancel all in-flight async work and delete temporary files.
+    /// This fires both on normal dismiss and on immediate close.
+    deinit {
+        generator?.cancelAllCGImageGeneration()
+        audioDownloadTask?.cancel()
+        currentAssetReader?.cancelReading()
+        cleanupLocalAudioFile()
+    }
+    
     // MARK: - Private
+    private func applyThemeColors() {
+        let bg: UIColor = isLightTheme ? .white : .black
+        let coverAlpha: CGFloat = isLightTheme ? 0.6 : 0.75
+        trackBackgroundColor = bg
+        thumbRestColor = bg
+        thumbnailLeadingCoverView.backgroundColor = UIColor(white: isLightTheme ? 1 : 0, alpha: coverAlpha)
+        thumbnailTrailingCoverView.backgroundColor = UIColor(white: isLightTheme ? 1 : 0, alpha: coverAlpha)
+        shadowView.layer.shadowColor = (isLightTheme ? UIColor.gray : UIColor.black).cgColor
+    }
+    
     private func setup() {
         addSubview(thumbnailClipView)
         thumbnailClipView.addSubview(thumbnailWrapperView)
         thumbnailWrapperView.addSubview(leadingThumbRest)
         thumbnailWrapperView.addSubview(trailingThumbRest)
         thumbnailWrapperView.addSubview(thumbnailTrackView)
+        
+        // Waveform view sits inside the thumbnail track but starts hidden;
+        // it's shown only for audio files once data is available.
+        waveformView.backgroundColor = waveformBgColor
+        waveformView.barColor = waveformBarColor
+        waveformView.barWidth = waveformBarWidth
+        waveformView.barGap = waveformBarGap
+        waveformView.barCornerRadius = waveformBarCornerRadius
+        waveformView.isHidden = true
+        thumbnailTrackView.addSubview(waveformView)
+        
         thumbnailWrapperView.addSubview(thumbnailLeadingCoverView)
         thumbnailWrapperView.addSubview(thumbnailTrailingCoverView)
         
-        progressIndicator.backgroundColor = .white
-        progressIndicator.layer.shadowColor = UIColor.black.cgColor
         progressIndicator.layer.shadowOffset = .zero
         progressIndicator.layer.shadowRadius = 2
         progressIndicator.layer.shadowOpacity = 0.25
@@ -302,13 +386,7 @@ import AVFoundation
         
         thumbnailClipView.clipsToBounds = true
         thumbnailTrackView.clipsToBounds = true
-        thumbnailLeadingCoverView.backgroundColor = UIColor(white: 0, alpha: 0.75)
-        thumbnailTrailingCoverView.backgroundColor = UIColor(white: 0, alpha: 0.75)
-        
-        leadingThumbRest.backgroundColor = thumbRestColor
-        trailingThumbRest.backgroundColor = thumbRestColor
         
-        thumbnailWrapperView.backgroundColor = trackBackgroundColor
         thumbnailWrapperView.layer.cornerRadius = 6
         thumbnailWrapperView.layer.cornerCurve = .continuous
         
@@ -320,11 +398,20 @@ import AVFoundation
         trailingThumbRest.layer.maskedCorners = [.layerMaxXMaxYCorner, .layerMaxXMinYCorner]
         trailingThumbRest.layer.cornerCurve = .continuous
         
-        shadowView.layer.shadowColor = UIColor.black.cgColor
         shadowView.layer.shadowOffset = .zero
         shadowView.layer.shadowRadius = 2
         shadowView.layer.shadowOpacity = 0.25
         
+        // Apply default (dark theme) colors — overridden by applyThemeColors() when asset is set
+        progressIndicator.backgroundColor = .white
+        progressIndicator.layer.shadowColor = UIColor.black.cgColor
+        thumbnailLeadingCoverView.backgroundColor = UIColor(white: 0, alpha: 0.75)
+        thumbnailTrailingCoverView.backgroundColor = UIColor(white: 0, alpha: 0.75)
+        leadingThumbRest.backgroundColor = thumbRestColor
+        trailingThumbRest.backgroundColor = thumbRestColor
+        thumbnailWrapperView.backgroundColor = trackBackgroundColor
+        shadowView.layer.shadowColor = UIColor.black.cgColor
+        
         setupConstraints()
         setupGestures()
     }
@@ -409,6 +496,7 @@ import AVFoundation
         let transform = track.preferredTransform
         let fixedSize = naturalSize.applyingVideoTransform(transform)
         
+        self.generator?.cancelAllCGImageGeneration()
         let generator = AVAssetImageGenerator(asset: asset)
         generator.apertureMode = .cleanAperture
         generator.videoComposition = videoComposition
@@ -462,6 +550,223 @@ import AVFoundation
         }
     }
     
+    /// Called from layoutSubviews whenever the view size or visible time range changes.
+    ///
+    /// For remote URLs, the first call triggers a download; once the local
+    /// file is cached, subsequent calls (e.g. zoom) skip straight to reading.
+    private func regenerateWaveformIfNeeded() {
+        guard isAudioOnly else { return }
+        let size = bounds.size
+        guard size.width > 0 && size.height > 0 else { return }
+        guard lastKnownWaveformSize != size || !CMTimeRangeEqual(lastKnownWaveformRange, visibleRange) else { return }
+        guard let asset = asset else { return }
+        
+        // Remote URL path: download once, then reuse localAudioAsset for reads
+        if let urlAsset = asset as? AVURLAsset, !urlAsset.url.isFileURL {
+            if let localAsset = localAudioAsset {
+                guard let audioTrack = localAsset.tracks(withMediaType: .audio).first else { return }
+                readWaveformSamples(from: localAsset, audioTrack: audioTrack, size: size)
+            } else if audioDownloadTask == nil {
+                downloadAudioForWaveform(from: urlAsset.url)
+            }
+            return
+        }
+        
+        // Local file path: read directly
+        guard let audioTrack = asset.tracks(withMediaType: .audio).first else { return }
+        readWaveformSamples(from: asset, audioTrack: audioTrack, size: size)
+    }
+    
+    /// Download remote audio to a temporary local file so AVAssetReader can read it.
+    ///
+    /// The file extension is inferred from the HTTP response (Content-Disposition,
+    /// MIME type) or the original URL, because AVURLAsset on iOS relies on
+    /// the extension to identify the audio codec — a generic `.tmp` extension
+    /// would cause silent failures.
+    private func downloadAudioForWaveform(from url: URL) {
+        let task = URLSession.shared.downloadTask(with: url) { [weak self] tempURL, response, error in
+            guard let self = self, let tempURL = tempURL else {
+                print("AudioWaveform: Download failed: \(error?.localizedDescription ?? "unknown")")
+                DispatchQueue.main.async { self?.audioDownloadTask = nil }
+                return
+            }
+            
+            let ext = Self.audioFileExtension(from: response, originalURL: url)
+            let destURL = FileManager.default.temporaryDirectory
+                .appendingPathComponent("waveform_\(UUID().uuidString).\(ext)")
+            do {
+                try FileManager.default.moveItem(at: tempURL, to: destURL)
+                let localAsset = AVURLAsset(url: destURL, options: [AVURLAssetPreferPreciseDurationAndTimingKey: true])
+                localAsset.loadValuesAsynchronously(forKeys: ["tracks"]) {
+                    var trackError: NSError?
+                    let status = localAsset.statusOfValue(forKey: "tracks", error: &trackError)
+                    guard status == .loaded else {
+                        print("AudioWaveform: Failed to load tracks from downloaded file: \(trackError?.localizedDescription ?? "unknown")")
+                        try? FileManager.default.removeItem(at: destURL)
+                        DispatchQueue.main.async { self.audioDownloadTask = nil }
+                        return
+                    }
+                    DispatchQueue.main.async {
+                        self.localAudioFileURL = destURL
+                        self.localAudioAsset = localAsset
+                        self.audioDownloadTask = nil
+                        self.lastKnownWaveformSize = .zero
+                        self.setNeedsLayout()
+                    }
+                }
+            } catch {
+                print("AudioWaveform: Failed to move downloaded file: \(error)")
+                DispatchQueue.main.async { self.audioDownloadTask = nil }
+            }
+        }
+        audioDownloadTask = task
+        task.resume()
+    }
+    
+    /// Determine the correct audio file extension from the HTTP response.
+    /// Priority: Content-Disposition → MIME type → URL path extension → "m4a" fallback.
+    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"
+    }
+    
+    /// Decode PCM samples from the given asset's audio track and compute
+    /// per-bar RMS amplitudes normalised to [0, 1].
+    ///
+    /// Runs the heavy decode on a background queue and posts the result
+    /// back to the main thread. The AVAssetReader is stored in
+    /// `currentAssetReader` so it can be cancelled if the editor is closed
+    /// or the view resizes mid-read.
+    private func readWaveformSamples(from asset: AVAsset, audioTrack: AVAssetTrack, size: CGSize) {
+        lastKnownWaveformSize = size
+        lastKnownWaveformRange = visibleRange
+        
+        waveformView.isHidden = false
+        
+        currentAssetReader?.cancelReading()
+        currentAssetReader = nil
+        
+        let timeRange = visibleRange
+        let step = waveformBarWidth + waveformBarGap
+        let barCount = max(1, Int(floor(size.width / step)))
+        
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            guard let self = self else { return }
+            
+            let reader: AVAssetReader
+            do {
+                reader = try AVAssetReader(asset: asset)
+            } catch {
+                print("AudioWaveform: Failed to create AVAssetReader: \(error)")
+                return
+            }
+            
+            reader.timeRange = timeRange
+            
+            let outputSettings: [String: Any] = [
+                AVFormatIDKey: kAudioFormatLinearPCM,
+                AVLinearPCMIsFloatKey: true,
+                AVLinearPCMBitDepthKey: 32,
+                AVNumberOfChannelsKey: 1,
+            ]
+            let output = AVAssetReaderTrackOutput(track: audioTrack, outputSettings: outputSettings)
+            
+            guard reader.canAdd(output) else {
+                print("AudioWaveform: Cannot add output to reader")
+                return
+            }
+            reader.add(output)
+            
+            DispatchQueue.main.sync {
+                self.currentAssetReader = reader
+            }
+            
+            guard reader.startReading() else {
+                print("AudioWaveform: Failed to start reading: \(String(describing: reader.error))")
+                return
+            }
+            
+            var allSamples = [Float]()
+            allSamples.reserveCapacity(barCount * 512)
+            
+            while reader.status == .reading {
+                guard let sampleBuffer = output.copyNextSampleBuffer() else { break }
+                guard let blockBuffer = CMSampleBufferGetDataBuffer(sampleBuffer) else { continue }
+                
+                let length = CMBlockBufferGetDataLength(blockBuffer)
+                let sampleCount = length / MemoryLayout<Float>.size
+                guard sampleCount > 0 else { continue }
+                
+                var data = [Float](repeating: 0, count: sampleCount)
+                CMBlockBufferCopyDataBytes(blockBuffer, atOffset: 0, dataLength: length, destination: &data)
+                allSamples.append(contentsOf: data)
+            }
+            
+            guard !allSamples.isEmpty else {
+                DispatchQueue.main.async {
+                    self.waveformView.amplitudes = []
+                }
+                return
+            }
+            
+            let samplesPerBar = max(1, allSamples.count / barCount)
+            var amplitudes = [CGFloat]()
+            amplitudes.reserveCapacity(barCount)
+            
+            for i in 0..<barCount {
+                let start = i * samplesPerBar
+                let end = min(start + samplesPerBar, allSamples.count)
+                guard start < allSamples.count else {
+                    amplitudes.append(0)
+                    continue
+                }
+                
+                var sumSquares: Float = 0
+                for j in start..<end {
+                    let s = allSamples[j]
+                    sumSquares += s * s
+                }
+                let rms = sqrt(sumSquares / Float(end - start))
+                amplitudes.append(CGFloat(rms))
+            }
+            
+            let maxAmp = amplitudes.max() ?? 1
+            let normalizer: CGFloat = maxAmp > 0 ? 1.0 / maxAmp : 1.0
+            let normalized = amplitudes.map { min($0 * normalizer, 1.0) }
+            
+            DispatchQueue.main.async {
+                self.waveformView.amplitudes = normalized
+            }
+        }
+    }
+    
+    /// Delete the temporary local audio file created by downloadAudioForWaveform.
+    private func cleanupLocalAudioFile() {
+        if let url = localAudioFileURL {
+            try? FileManager.default.removeItem(at: url)
+            localAudioFileURL = nil
+        }
+    }
+    
     private func timeForLocation(_ x: CGFloat) -> CMTime {
         let size = bounds.size
         let inset = thumbView.chevronWidth + horizontalInset
@@ -932,6 +1237,11 @@ import AVFoundation
         }
         
         regenerateThumbnailsIfNeeded()
+        regenerateWaveformIfNeeded()
+        // Inset waveformView by the leading handle's chevron width so its
+        // background doesn't bleed underneath the translucent handle area.
+        let waveformLeft = thumbView.chevronWidth
+        waveformView.frame = CGRect(x: waveformLeft, y: 0, width: max(0, thumbnailTrackView.bounds.width - waveformLeft), height: thumbnailTrackView.bounds.height)
         
         for thumbnail in thumbnails {
             let position = locationForTime(thumbnail.time) - horizontalInset + thumbnailOffset