Clean up scale types

Author: fulldecent

Sources/FDWaveformView/FDWaveformRenderOperation.swift

@@ -6,27 +6,22 @@ import Accelerate
 import UIKit
 
 /// Format options for FDWaveformRenderOperation
-//MAYBE: Make this public
 struct FDWaveformRenderFormat {
 
   /// The type of waveform to render
-  //TODO: make this public after reconciling FDWaveformView.WaveformType and FDWaveformType
-  var type: FDWaveformType
+  var type: FDWaveformView.WaveformType
 
   /// The color of the waveform
-  internal var wavesColor: UIColor
+  var wavesColor: UIColor
 
   /// The scale factor to apply to the rendered image (usually the current screen's scale)
-  public var scale: CGFloat
+  var scale: CGFloat
 
-  public init() {
-    self.init(
-      type: .linear,
-      wavesColor: .black,
-      scale: UIScreen.main.scale)
-  }
-
-  init(type: FDWaveformType, wavesColor: UIColor, scale: CGFloat) {
+  init(
+    type: FDWaveformView.WaveformType = .linear,
+    wavesColor: UIColor = .black,
+    scale: CGFloat = UIScreen.main.scale
+  ) {
     self.type = type
     self.wavesColor = wavesColor
     self.scale = scale
@@ -39,6 +34,9 @@ final class FDWaveformRenderOperation: Operation {
   /// When samples per pixel falls below this threshold, switch from binned maximums to individual samples
   private let samplesPerPixelThreshold = 2
 
+  /// The noise floor for logarithmic display (in dB)
+  private let noiseFloorDecibels: Float = -50.0
+
   /// The data source used to build the waveform
   let dataSource: FDWaveformDataSource
 
@@ -147,7 +145,7 @@ final class FDWaveformRenderOperation: Operation {
 
       // Apply logarithmic transformation only to amplitude data (not signed samples)
       if !isSignedSamples {
-        format.type.process(normalizedSamples: &amplitudes)
+        applyWaveformType(&amplitudes)
       }
 
       let samples = amplitudes.map { CGFloat($0) }
@@ -162,11 +160,25 @@ final class FDWaveformRenderOperation: Operation {
     }
   }
 
-  /// Read the asset and create a lower resolution set of samples
-  // TODO: Implement sliceAsset if needed for backwards compatibility
-  // This method is no longer used as we now use the dataSource protocol
+  /// Applies the waveform type transformation to the amplitude samples
+  private func applyWaveformType(_ samples: inout [Float]) {
+    switch format.type {
+    case .linear:
+      return
+    case .logarithmic:
+      // Convert normalized [0, 1] samples to dB scale
+      let epsilon: Float = 1e-10
+      for i in 0..<samples.count {
+        let amplitude = max(samples[i], epsilon)
+        var dB = 20.0 * log10(amplitude)
+        dB = max(dB, noiseFloorDecibels)
+        dB = min(dB, 0)
+        // Normalize to [0, 1] where 0 = noiseFloor and 1 = 0 dB
+        samples[i] = (dB - noiseFloorDecibels) / (0 - noiseFloorDecibels)
+      }
+    }
+  }
 
-  // TODO: report progress? (for issue #2)
   func plotWaveformGraph(
     _ samples: [CGFloat], maximumValue max: CGFloat, zeroValue min: CGFloat,
     isSignedSamples: Bool = false

Sources/FDWaveformView/FDWaveformView.swift

@@ -146,9 +146,6 @@ open class FDWaveformView: UIView {
   /// If this number is not available then a re-render will be performed
   private var verticalOverdrawAllowed = 1.0...3.0
 
-  /// The "zero" level (in dB)
-  fileprivate let noiseFloor: CGFloat = -50.0
-
   /// Minimum number of samples that can be displayed (limits maximum zoom)
   private let minimumZoomSamples = 10
 
@@ -203,15 +200,6 @@ open class FDWaveformView: UIView {
     return window?.screen.scale ?? UIScreen.main.scale
   }
 
-  /// Waveform type for rendering waveforms
-  //TODO: make this public after reconciling FDWaveformView.WaveformType and FDWaveformType
-  var waveformRenderType: FDWaveformType {
-    switch waveformType {
-    case .linear: return .linear
-    case .logarithmic: return .logarithmic(noiseFloor: noiseFloor)
-    }
-  }
-
   /// Represents the status of the waveform renderings
   fileprivate enum CacheStatus {
     case dirty
@@ -341,7 +329,7 @@ open class FDWaveformView: UIView {
   func isWaveformRenderOperationDirty(_ renderOperation: FDWaveformRenderOperation?) -> Bool? {
     guard let renderOperation = renderOperation else { return nil }
 
-    if renderOperation.format.type != waveformRenderType {
+    if renderOperation.format.type != waveformType {
       return true
     }
     if renderOperation.format.scale != desiredImageScale {
@@ -460,7 +448,7 @@ open class FDWaveformView: UIView {
     let heightInPixels = frame.height * CGFloat(horizontalOverdrawTarget)
     let imageSize = CGSize(width: widthInPixels, height: heightInPixels)
     let renderFormat = FDWaveformRenderFormat(
-      type: waveformRenderType, wavesColor: .black, scale: desiredImageScale)
+      type: waveformType, wavesColor: .black, scale: desiredImageScale)
 
     let waveformRenderOperation = FDWaveformRenderOperation(
       dataSource: dataSource, totalSamples: totalSamples, imageSize: imageSize,
@@ -488,61 +476,6 @@ open class FDWaveformView: UIView {
   }
 }
 
-//TODO: make this public after reconciling FDWaveformView.WaveformType and FDWaveformType
-enum FDWaveformType: Equatable {
-  /// Waveform is rendered using a linear scale
-  case linear
-
-  /// Waveform is rendered using a logarithmic scale
-  ///   noiseFloor: The "zero" level (in dB)
-  case logarithmic(noiseFloor: CGFloat)
-
-  // See http://stackoverflow.com/questions/24339807/how-to-test-equality-of-swift-enums-with-associated-values
-  public static func == (lhs: FDWaveformType, rhs: FDWaveformType) -> Bool {
-    switch lhs {
-    case .linear:
-      if case .linear = rhs {
-        return true
-      }
-    case .logarithmic(let lhsNoiseFloor):
-      if case .logarithmic(let rhsNoiseFloor) = rhs {
-        return lhsNoiseFloor == rhsNoiseFloor
-      }
-    }
-    return false
-  }
-
-  public var floorValue: CGFloat {
-    switch self {
-    case .linear: return 0
-    case .logarithmic(let noiseFloor): return noiseFloor
-    }
-  }
-
-  func process(normalizedSamples: inout [Float]) {
-    switch self {
-    case .linear:
-      return
-
-    case .logarithmic(let noiseFloor):
-      // Convert normalized [0, 1] samples to dB scale
-      // Formula: dB = 20 * log10(amplitude)
-      // For amplitude in [0, 1]: dB ranges from -infinity to 0
-      // We use a small epsilon to avoid log(0) = -infinity
-      let epsilon: Float = 1e-10
-      for i in 0..<normalizedSamples.count {
-        let amplitude = max(normalizedSamples[i], epsilon)
-        var dB = 20.0 * log10(amplitude)
-        // Clip to [noiseFloor, 0]
-        dB = max(dB, Float(noiseFloor))
-        dB = min(dB, 0)
-        // Normalize to [0, 1] where 0 = noiseFloor and 1 = 0 dB
-        normalizedSamples[i] = (dB - Float(noiseFloor)) / (0 - Float(noiseFloor))
-      }
-    }
-  }
-}
-
 extension FDWaveformView: UIGestureRecognizerDelegate {
   public func gestureRecognizer(
     _ gestureRecognizer: UIGestureRecognizer,
@@ -666,9 +599,9 @@ extension FDWaveformView: UIGestureRecognizerDelegate {
         let clampedDelta = max(maxBackwardDelta, min(maxForwardDelta, wholeSampleDelta))
 
         if clampedDelta != 0 {
-          zoomSamples =
-            (clampedZoomSamples.startIndex + clampedDelta)
-            ..<(clampedZoomSamples.endIndex + clampedDelta)
+          let newStart = clampedZoomSamples.startIndex + clampedDelta
+          let newEnd = clampedZoomSamples.endIndex + clampedDelta
+          zoomSamples = newStart..<newEnd
         }
 
         accumulatedPanDelta -= CGFloat(wholeSampleDelta)

Tests/FDWaveformViewTests/FDWaveformViewTests.swift

@@ -39,26 +39,15 @@ final class FDWaveformViewTests: XCTestCase {
     XCTAssertEqual(waveformView.progressColor, .green)
   }
 
-  func testFDWaveformTypeEquality() throws {
-    // Test FDWaveformType enum equality
-    let linear1 = FDWaveformType.linear
-    let linear2 = FDWaveformType.linear
-    let logarithmic1 = FDWaveformType.logarithmic(noiseFloor: -50.0)
-    let logarithmic2 = FDWaveformType.logarithmic(noiseFloor: -50.0)
-    let logarithmic3 = FDWaveformType.logarithmic(noiseFloor: -60.0)
+  func testWaveformTypeEquality() throws {
+    // Test WaveformType enum equality
+    let linear1 = FDWaveformView.WaveformType.linear
+    let linear2 = FDWaveformView.WaveformType.linear
+    let logarithmic1 = FDWaveformView.WaveformType.logarithmic
+    let logarithmic2 = FDWaveformView.WaveformType.logarithmic
 
     XCTAssertEqual(linear1, linear2)
     XCTAssertEqual(logarithmic1, logarithmic2)
     XCTAssertNotEqual(linear1, logarithmic1)
-    XCTAssertNotEqual(logarithmic1, logarithmic3)
-  }
-
-  func testFDWaveformTypeFloorValue() throws {
-    // Test floor value property
-    let linear = FDWaveformType.linear
-    let logarithmic = FDWaveformType.logarithmic(noiseFloor: -45.0)
-
-    XCTAssertEqual(linear.floorValue, 0)
-    XCTAssertEqual(logarithmic.floorValue, -45.0)
   }
 }