nit

* initial work for supporting non-optimised mp4

* Update AppCoordinator.swift

* some refactor and fixed seek for a restructured mp4

* nit

* nit

* nit

* runs swiftlint

* improvements

* improvements

* handles case where we the stream is not seekable for an mp4 file

* better check for mp4, seekable and moov atom

* nit

* fix an issue with seek

* some refactoring

.github/workflows/swift.yml

@@ -14,10 +14,10 @@ jobs:
     name: Test iOS 
     runs-on: macOS-latest
     env: 
-      DEVELOPER_DIR: /Applications/Xcode_12.app/Contents/Developer
+       DEVELOPER_DIR: /Applications/Xcode.app/Contents/Developer
     strategy:
       matrix:
-        destination: ["OS=14.0,name=iPhone 11 Pro"] #, "OS=12.4,name=iPhone XS", "OS=11.4,name=iPhone X", "OS=10.3.1,name=iPhone SE"]
+        destination: ["OS=latest,name=iPhone 13 Pro"]
     steps:
       - uses: actions/checkout@v2
       - name: iOS - ${{ matrix.destination }}

.gitignore

@@ -10,6 +10,7 @@ xcuserdata/
 *.xccheckout
 
 ## compatibility with Xcode 3 and earlier (ignoring not required starting Xcode 4)
+**/.DS_Store
 build/
 DerivedData/
 *.moved-aside
@@ -88,3 +89,5 @@ fastlane/test_output
 # https://github.com/johnno1962/injectionforxcode
 
 iOSInjectionProject/
+/.DS_Store
+/AudioExample/AudioExample/.DS_Store

AudioExample/AudioExample.xcodeproj/project.pbxproj

@@ -7,6 +7,8 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
+		984808A028C0F549001160E6 /* hipjazz.wav in Resources */ = {isa = PBXBuildFile; fileRef = 9848089F28C0F549001160E6 /* hipjazz.wav */; };
+		98C82AE22B8CA16A00AED485 /* bensound-jazzyfrenchy.m4a in Resources */ = {isa = PBXBuildFile; fileRef = 98C82AE12B8CA0F000AED485 /* bensound-jazzyfrenchy.m4a */; };
 		B5220836256051830086FB3A /* AudioPlayerService.swift in Sources */ = {isa = PBXBuildFile; fileRef = B5220835256051830086FB3A /* AudioPlayerService.swift */; };
 		B5220948256074910086FB3A /* MulticastDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = B5220947256074910086FB3A /* MulticastDelegate.swift */; };
 		B52209502561883E0086FB3A /* EqualizerViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = B522094F2561883E0086FB3A /* EqualizerViewController.swift */; };
@@ -42,6 +44,8 @@
 /* End PBXCopyFilesBuildPhase section */
 
 /* Begin PBXFileReference section */
+		9848089F28C0F549001160E6 /* hipjazz.wav */ = {isa = PBXFileReference; lastKnownFileType = audio.wav; path = hipjazz.wav; sourceTree = "<group>"; };
+		98C82AE12B8CA0F000AED485 /* bensound-jazzyfrenchy.m4a */ = {isa = PBXFileReference; lastKnownFileType = file; path = "bensound-jazzyfrenchy.m4a"; sourceTree = "<group>"; };
 		B5220835256051830086FB3A /* AudioPlayerService.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AudioPlayerService.swift; sourceTree = "<group>"; };
 		B5220947256074910086FB3A /* MulticastDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MulticastDelegate.swift; sourceTree = "<group>"; };
 		B522094F2561883E0086FB3A /* EqualizerViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = EqualizerViewController.swift; sourceTree = "<group>"; };
@@ -78,6 +82,8 @@
 		B524D59D2560177C00F5A88F /* Resources */ = {
 			isa = PBXGroup;
 			children = (
+				98C82AE12B8CA0F000AED485 /* bensound-jazzyfrenchy.m4a */,
+				9848089F28C0F549001160E6 /* hipjazz.wav */,
 				B524D59B2560176C00F5A88F /* bensound-jazzyfrenchy.mp3 */,
 				B5AEDBDD2475274D007D8101 /* Assets.xcassets */,
 				B5AEDBDF2475274D007D8101 /* LaunchScreen.storyboard */,
@@ -211,6 +217,8 @@
 				B524D59C2560176C00F5A88F /* bensound-jazzyfrenchy.mp3 in Resources */,
 				B5AEDBE12475274D007D8101 /* LaunchScreen.storyboard in Resources */,
 				B5AEDBDE2475274D007D8101 /* Assets.xcassets in Resources */,
+				98C82AE22B8CA16A00AED485 /* bensound-jazzyfrenchy.m4a in Resources */,
+				984808A028C0F549001160E6 /* hipjazz.wav in Resources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -371,8 +379,8 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
-				CODE_SIGN_STYLE = Automatic;
-				DEVELOPMENT_TEAM = 5Y92JCRVR7;
+				CODE_SIGN_STYLE = Manual;
+				DEVELOPMENT_TEAM = "";
 				INFOPLIST_FILE = AudioExample/Info.plist;
 				IPHONEOS_DEPLOYMENT_TARGET = 13.0;
 				LD_RUNPATH_SEARCH_PATHS = (
@@ -381,6 +389,7 @@
 				);
 				PRODUCT_BUNDLE_IDENTIFIER = com.decimal.AudioExample;
 				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
 				SWIFT_VERSION = 5.0;
 				TARGETED_DEVICE_FAMILY = "1,2";
 			};
@@ -390,8 +399,8 @@
 			isa = XCBuildConfiguration;
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
-				CODE_SIGN_STYLE = Automatic;
-				DEVELOPMENT_TEAM = 5Y92JCRVR7;
+				CODE_SIGN_STYLE = Manual;
+				DEVELOPMENT_TEAM = "";
 				INFOPLIST_FILE = AudioExample/Info.plist;
 				IPHONEOS_DEPLOYMENT_TARGET = 13.0;
 				LD_RUNPATH_SEARCH_PATHS = (
@@ -400,6 +409,7 @@
 				);
 				PRODUCT_BUNDLE_IDENTIFIER = com.decimal.AudioExample;
 				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
 				SWIFT_VERSION = 5.0;
 				TARGETED_DEVICE_FAMILY = "1,2";
 			};

AudioExample/AudioExample.xcodeproj/xcshareddata/xcschemes/AudioExample.xcscheme

@@ -85,18 +85,6 @@
             isEnabled = "NO">
          </EnvironmentVariable>
       </EnvironmentVariables>
-      <AdditionalOptions>
-         <AdditionalOption
-            key = "MallocStackLogging"
-            value = ""
-            isEnabled = "YES">
-         </AdditionalOption>
-         <AdditionalOption
-            key = "PrefersMallocStackLoggingLite"
-            value = ""
-            isEnabled = "YES">
-         </AdditionalOption>
-      </AdditionalOptions>
    </LaunchAction>
    <ProfileAction
       buildConfiguration = "Release"

AudioExample/AudioExample/AppCoordinator.swift

@@ -6,10 +6,10 @@
 //  Copyright © 2020 Dimitrios Chatzieleftheriou. All rights reserved.
 //
 
+import AVFoundation
 import UIKit
 
 final class AppCoordinator {
-
     enum Route {
         case equalizer
     }
@@ -44,8 +44,8 @@ final class AppCoordinator {
 
     private func routeTo(_ route: AppCoordinator.Route) {
         switch route {
-            case .equalizer:
-                showEqualizerControls()
+        case .equalizer:
+            showEqualizerControls()
         }
     }
 

AudioExample/AudioExample/Controllers/EqualizerViewController.swift

@@ -9,7 +9,6 @@
 import UIKit
 
 class EqualizerViewController: UIViewController {
-
     private lazy var enableTextLabel = UILabel()
     private lazy var enableButton = UISwitch()
 
@@ -22,7 +21,8 @@ class EqualizerViewController: UIViewController {
         super.init(nibName: nil, bundle: nil)
     }
 
-    required init?(coder: NSCoder) {
+    @available(*, unavailable)
+    required init?(coder _: NSCoder) {
         fatalError("init(coder:) has not been implemented")
     }
 
@@ -69,7 +69,7 @@ class EqualizerViewController: UIViewController {
                 stackView.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
                 stackView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
                 stackView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
-                stackView.heightAnchor.constraint(equalTo: view.safeAreaLayoutGuide.heightAnchor, multiplier: 0.8)
+                stackView.heightAnchor.constraint(equalTo: view.safeAreaLayoutGuide.heightAnchor, multiplier: 0.8),
             ]
         )
     }
@@ -86,7 +86,7 @@ class EqualizerViewController: UIViewController {
 
     private func buildSliders() -> [UIView] {
         var sliders = [UIView]()
-        for index in 0..<viewModel.numberOfBands() {
+        for index in 0 ..< viewModel.numberOfBands() {
             guard let item = viewModel.band(at: index) else { continue }
             let slider = buildSlider(item: item, index: index)
             sliders.append(slider)

AudioExample/AudioExample/Controllers/EqualizerViewModel.swift

@@ -1,5 +1,5 @@
 //
-//  EqualzerViewModel.swift
+//  EqualizerViewModel.swift
 //  AudioExample
 //
 //  Created by Dimitrios Chatzieleftheriou on 15/11/2020.
@@ -16,7 +16,6 @@ struct EQBand {
 }
 
 final class EqualzerViewModel {
-
     private var bands: [EQBand] = []
 
     private let equalizerService: EqualizerService
@@ -31,7 +30,7 @@ final class EqualzerViewModel {
         bands = equalizerService.bands.map { item in
             var measurement = item.frequency
             var frequency = String(Int(measurement))
-            if item.frequency >= 1_000 {
+            if item.frequency >= 1000 {
                 measurement = item.frequency / 1000
                 frequency = "\(String(Int(measurement)))K"
             }
@@ -43,7 +42,7 @@ final class EqualzerViewModel {
         if enable {
             equalizerService.activate()
         } else {
-            equalizerService.deactive()
+            equalizerService.deactivate()
         }
     }
 

AudioExample/AudioExample/Controllers/PlayerControlsViewModel.swift

@@ -153,7 +153,7 @@ extension PlayerControlsViewModel: AudioPlayerServiceDelegate {
         updateContent?(.updateMetadata(""))
     }
 
-    func errorOccured(error _: AudioPlayerError) {}
+    func errorOccurred(error _: AudioPlayerError) {}
 
     func metadataReceived(metadata: [String: String]) {
         guard !metadata.isEmpty else { return }

AudioExample/AudioExample/Controllers/PlayerViewController.swift

@@ -51,7 +51,7 @@ class PlayerViewController: UIViewController {
                                                            style: .plain,
                                                            target: self,
                                                            action: #selector(showEqualizer))
-        
+
         tableView.translatesAutoresizingMaskIntoConstraints = false
         tableView.delegate = self
         tableView.dataSource = self
@@ -92,12 +92,13 @@ class PlayerViewController: UIViewController {
 
     @objc private func addNowPlaylistItem() {
         let controller = UIAlertController(title: "Add new item", message: "", preferredStyle: .alert)
-        controller.addTextField { (textField) in
+        controller.addTextField { textField in
             textField.placeholder = "Insert url here"
         }
-        let saveAction = UIAlertAction(title: "Save", style: .default) { [viewModel] action in
+        let saveAction = UIAlertAction(title: "Save", style: .default) { [viewModel] _ in
             if let textfield = controller.textFields?.first,
-               let text = textfield.text {
+               let text = textfield.text
+            {
                 viewModel.add(urlString: text)
             }
         }
@@ -105,7 +106,7 @@ class PlayerViewController: UIViewController {
 
         controller.addAction(saveAction)
         controller.addAction(cancelAction)
-        self.present(controller, animated: true, completion: nil)
+        present(controller, animated: true, completion: nil)
     }
 }
 
@@ -120,7 +121,8 @@ extension PlayerViewController: UITableViewDataSource {
             return cell
         }
         cell.textLabel?.text = item.name
-        cell.detailTextLabel?.text = item.queues ? "Queue item" : nil
+        let queuedItem = item.queues ? "Queue item" : nil
+        cell.detailTextLabel?.text = queuedItem ?? item.subtitle
         update(status: item.status, of: cell)
         return cell
     }
@@ -137,7 +139,11 @@ extension PlayerViewController: UITableViewDataSource {
             cell.accessoryView = UIImageView(image: UIImage(systemName: "pause.fill"))
         case .stopped:
             cell.accessoryView = nil
+        case .error:
+            cell.accessoryView = UIImageView(image: UIImage(systemName: "exclamationmark.octagon"))
+            cell.accessoryView?.tintColor = .red
         }
+        guard status != .error else { return }
         cell.accessoryView?.tintColor = .systemTeal
     }
 }
@@ -149,14 +155,13 @@ extension PlayerViewController: UITableViewDelegate {
     }
 }
 
-
 final class PlaylistTableViewCell: UITableViewCell {
-    override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
+    override init(style _: UITableViewCell.CellStyle, reuseIdentifier: String?) {
         super.init(style: .subtitle, reuseIdentifier: reuseIdentifier)
     }
 
     @available(*, unavailable)
-    required init?(coder: NSCoder) {
+    required init?(coder _: NSCoder) {
         fatalError("init(coder:) has not been implemented")
     }
 }

AudioExample/AudioExample/Controllers/PlayerViewModel.swift

@@ -18,14 +18,15 @@ final class PlayerViewModel {
     private let playerService: AudioPlayerService
     private let playlistItemsService: PlaylistItemsService
 
-    private let routeTo: ((AppCoordinator.Route) -> Void)
+    private let routeTo: (AppCoordinator.Route) -> Void
     private var currentPlayingItemIndex: Int?
 
     var reloadContent: ((ReloadAction) -> Void)?
 
     init(playlistItemsService: PlaylistItemsService,
          playerService: AudioPlayerService,
-         routeTo: @escaping (AppCoordinator.Route) -> Void) {
+         routeTo: @escaping (AppCoordinator.Route) -> Void)
+    {
         self.playlistItemsService = playlistItemsService
         self.playerService = playerService
         self.routeTo = routeTo
@@ -47,7 +48,7 @@ final class PlayerViewModel {
             print("malformed url error")
             return
         }
-        playlistItemsService.add(item: PlaylistItem(url: url, name: urlString, status: .stopped, queues: false))
+        playlistItemsService.add(item: PlaylistItem(url: url, name: urlString, subtitle: nil, status: .stopped, queues: false))
         reloadContent?(.all)
     }
 
@@ -91,12 +92,16 @@ extension PlayerViewModel: AudioPlayerServiceDelegate {
         case .stopped:
             playlistItemsService.setStatus(for: item, status: .stopped)
             reloadContent?(.item(IndexPath(item: item, section: 0)))
+        case .error:
+            playlistItemsService.setStatus(for: item, status: .error)
+            reloadContent?(.item(IndexPath(item: item, section: 0)))
         default:
-            break
+            playlistItemsService.setStatus(for: item, status: .stopped)
+            reloadContent?(.all)
         }
     }
 
-    func errorOccured(error _: AudioPlayerError) {
+    func errorOccurred(error _: AudioPlayerError) {
         currentPlayingItemIndex = nil
     }
 

AudioExample/AudioExample/Services/AudioContent.swift

@@ -16,8 +16,11 @@ enum AudioContent: Int, CaseIterable {
     case radiox
     case khruangbin
     case piano
+    case optimized
+    case nonOptimized
+    case remoteWave
     case local
-    case podcast
+    case localWave
 
     var title: String {
         switch self {
@@ -35,10 +38,45 @@ enum AudioContent: Int, CaseIterable {
             return "Khruangbin (mp3 preview)"
         case .piano:
             return "Piano (mp3)"
+        case .remoteWave:
+            return "Sample remote (wave)"
         case .local:
-            return "Local file (mp3)"
-        case .podcast:
-            return "Swift by Sundell. Ep. 50 (mp3)"
+            return "Jazzy Frenchy (local mp3)"
+        case .localWave:
+            return "Local file (local wave)"
+        case .optimized:
+            return "Jazze French (m4a - optimized)"
+        case .nonOptimized:
+            return "Jazze French (m4a - non-optimized)"
+        }
+    }
+
+    var subtitle: String? {
+        switch self {
+        case .offradio:
+            return nil
+        case .enlefko:
+            return nil
+        case .pepper966:
+            return nil
+        case .kosmos:
+            return nil
+        case .radiox:
+            return nil
+        case .khruangbin:
+            return nil
+        case .piano:
+            return nil
+        case .remoteWave:
+            return nil
+        case .local:
+            return "Music by: bensound.com"
+        case .localWave:
+            return "Music by: bensound.com"
+        case .optimized:
+            return "Music by: bensound.com"
+        case .nonOptimized:
+            return "Music by: bensound.com"
         }
     }
 
@@ -49,7 +87,7 @@ enum AudioContent: Int, CaseIterable {
         case .offradio:
             return URL(string: "https://s3.yesstreaming.net:17062/stream")!
         case .pepper966:
-            return URL(string: "https://ample-09.radiojar.com/pepper.m4a?1593699983=&rj-tok=AAABcw_1KyMAIViq2XpI098ZSQ&rj-ttl=5")!
+            return URL(string: "https://n04.radiojar.com/pepper.m4a?1662039818=&rj-tok=AAABgvlUaioALhdOXDt0mgajoA&rj-ttl=5")!
         case .kosmos:
             return URL(string: "https://radiostreaming.ert.gr/ert-kosmos")!
         case .radiox:
@@ -58,11 +96,18 @@ enum AudioContent: Int, CaseIterable {
             return URL(string: "https://p.scdn.co/mp3-preview/cab4b09c23ffc11774d879977131df9d150fcef4?cid=d8a5ed958d274c2e8ee717e6a4b0971d")!
         case .piano:
             return URL(string: "https://www.kozco.com/tech/piano2-CoolEdit.mp3")!
+        case .optimized:
+            return URL(string: "https://github.com/dimitris-c/sample-audio/raw/main/bensound-jazzyfrenchy-optimized.m4a")!
+        case .nonOptimized:
+            return URL(string: "https://github.com/dimitris-c/sample-audio/raw/main/bensound-jazzyfrenchy.m4a")!
         case .local:
-            let path = Bundle.main.path(forResource: "bensound-jazzyfrenchy", ofType: "mp3")!
+            let path = Bundle.main.path(forResource: "bensound-jazzyfrenchy", ofType: "m4a")!
             return URL(fileURLWithPath: path)
-        case .podcast:
-            return URL(string: "https://hwcdn.libsyn.com/p/f/6/e/f6e7cb785cf0f71f/SwiftBySundell50.mp3?c_id=45232967&cs_id=45232967&expiration=1605613140&hwt=f9ff0b2f758c3286cd75322e14ef7a23")!
+        case .localWave:
+            let path = Bundle.main.path(forResource: "hipjazz", ofType: "wav")!
+            return URL(fileURLWithPath: path)
+        case .remoteWave:
+            return URL(string: "https://file-examples.com/wp-content/storage/2017/11/file_example_WAV_5MG.wav")!
         }
     }
 }

AudioExample/AudioExample/Services/AudioPlayerService.swift

@@ -13,7 +13,7 @@ protocol AudioPlayerServiceDelegate: AnyObject {
     func didStartPlaying()
     func didStopPlaying()
     func statusChanged(status: AudioPlayerState)
-    func errorOccured(error: AudioPlayerError)
+    func errorOccurred(error: AudioPlayerError)
     func metadataReceived(metadata: [String: String])
 }
 
@@ -111,7 +111,8 @@ final class AudioPlayerService {
         // Note that a real app might need to observer other AVAudioSession notifications as well
         audioSystemResetObserver = NotificationCenter.default.addObserver(forName: AVAudioSession.mediaServicesWereResetNotification,
                                                                           object: nil,
-                                                                          queue: nil) { [unowned self] _ in
+                                                                          queue: nil)
+        { [unowned self] _ in
             self.configureAudioSession()
             self.recreatePlayer()
         }
@@ -148,27 +149,30 @@ final class AudioPlayerService {
 }
 
 extension AudioPlayerService: AudioPlayerDelegate {
-    func audioPlayerDidStartPlaying(player _: AudioPlayer, with _: AudioEntryId) {
+    func audioPlayerDidStartPlaying(player _: AudioPlayer, with id: AudioEntryId) {
+        print("audioPlayerDidStartPlaying entryId: \(id)")
         delegate.invoke(invocation: { $0.didStartPlaying() })
     }
 
     func audioPlayerDidFinishBuffering(player _: AudioPlayer, with _: AudioEntryId) {}
 
     func audioPlayerStateChanged(player _: AudioPlayer, with newState: AudioPlayerState, previous _: AudioPlayerState) {
+        print("audioPlayerDidStartPlaying newState: \(newState)")
         delegate.invoke(invocation: { $0.statusChanged(status: newState) })
     }
 
     func audioPlayerDidFinishPlaying(player _: AudioPlayer,
-                                     entryId _: AudioEntryId,
-                                     stopReason _: AudioPlayerStopReason,
+                                     entryId id: AudioEntryId,
+                                     stopReason reason: AudioPlayerStopReason,
                                      progress _: Double,
                                      duration _: Double)
     {
+        print("audioPlayerDidFinishPlaying entryId: \(id), reason: \(reason)")
         delegate.invoke(invocation: { $0.didStopPlaying() })
     }
 
     func audioPlayerUnexpectedError(player _: AudioPlayer, error: AudioPlayerError) {
-        delegate.invoke(invocation: { $0.errorOccured(error: error) })
+        delegate.invoke(invocation: { $0.errorOccurred(error: error) })
     }
 
     func audioPlayerDidCancel(player _: AudioPlayer, queuedItems _: [AudioEntryId]) {}

AudioExample/AudioExample/Services/EqualizerService.swift

@@ -10,7 +10,7 @@ import AVFoundation
 
 final class EqualizerService {
     private let playerService: AudioPlayerService
-    private let _freqs = [32, 64, 128, 250, 500, 1_000, 2_000, 4_000, 8_000, 16_000]
+    private let _freqs = [32, 64, 128, 250, 500, 1000, 2000, 4000, 8000, 16000]
     private let eqUnit: AVAudioUnitEQ
 
     var bands: [AVAudioUnitEQFilterParameters] {
@@ -23,7 +23,7 @@ final class EqualizerService {
         self.playerService = playerService
 
         eqUnit = AVAudioUnitEQ(numberOfBands: _freqs.count)
-        for i in 0..<_freqs.count {
+        for i in 0 ..< _freqs.count {
             eqUnit.bands[i].bypass = false
             eqUnit.bands[i].filterType = .parametric
             eqUnit.bands[i].frequency = Float(_freqs[i])
@@ -45,7 +45,7 @@ final class EqualizerService {
         playerService.add(eqUnit)
     }
 
-    func deactive() {
+    func deactivate() {
         isActivated = false
         playerService.remove(eqUnit)
     }

AudioExample/AudioExample/Services/NowPlayingCenter.swift

@@ -9,10 +9,9 @@
 import MediaPlayer
 
 final class NowPlayingCenter {
-
     private let infoCenter: MPNowPlayingInfoCenter
 
-    init(infoCenter: MPNowPlayingInfoCenter = .default()){
+    init(infoCenter: MPNowPlayingInfoCenter = .default()) {
         self.infoCenter = infoCenter
     }
 

AudioExample/AudioExample/Services/PlaylistItemsService.swift

@@ -14,23 +14,27 @@ struct PlaylistItem: Equatable {
         case paused
         case buffering
         case stopped
+        case error
     }
 
     let url: URL
     let name: String
+    let subtitle: String?
     let status: Status
     let queues: Bool
 
     init(content: AudioContent, queues: Bool) {
         name = content.title
+        subtitle = content.subtitle
         url = content.streamUrl
         status = .stopped
         self.queues = queues
     }
 
-    init(url: URL, name: String, status: Status, queues: Bool) {
+    init(url: URL, name: String, subtitle: String?, status: Status, queues: Bool) {
         self.url = url
         self.name = name
+        self.subtitle = subtitle
         self.status = status
         self.queues = queues
     }
@@ -73,14 +77,20 @@ final class PlaylistItemsService {
         guard let item = item(at: index) else {
             return
         }
-        items[index] = PlaylistItem(url: item.url, name: item.name, status: status, queues: item.queues)
+        items[index] = PlaylistItem(
+            url: item.url,
+            name: item.name,
+            subtitle: item.subtitle,
+            status: status,
+            queues: item.queues
+        )
     }
 }
 
 func provideInitialPlaylistItems() -> [PlaylistItem] {
     let allCases = AudioContent.allCases
     let casesForQueueing: [AudioContent] = [.piano, .local, .khruangbin]
-    let allItems = allCases.map { PlaylistItem.init(content: $0 , queues: false) }
-    let casesForQueuingItems = casesForQueueing.map { PlaylistItem.init(content: $0 , queues: true) }
+    let allItems = allCases.map { PlaylistItem(content: $0, queues: false) }
+    let casesForQueuingItems = casesForQueueing.map { PlaylistItem(content: $0, queues: true) }
     return allItems + casesForQueuingItems
 }

AudioStreaming.podspec

@@ -1,13 +1,13 @@
 Pod::Spec.new do |s|
   s.name = 'AudioStreaming'
-  s.version = '0.6.0'
+  s.version = '1.2.0'
   s.license = 'MIT'
   s.summary = 'An AudioPlayer/Streaming library for iOS written in Swift using AVAudioEngine.'
   s.homepage = 'https://github.com/dimitris-c/AudioStreaming'
   s.authors = { 'Dimitris C.' => 'dimmdesign@gmail.com' }
   s.source = { :git => 'https://github.com/dimitris-c/AudioStreaming.git', :tag => s.version }
 
-  s.ios.deployment_target = '12.0'
+  s.ios.deployment_target = '13.0'
 
   s.swift_versions = ['5.1', '5.2', '5.3']
 

AudioStreaming.xcodeproj/project.pbxproj

@@ -7,6 +7,11 @@
 	objects = {
 
 /* Begin PBXBuildFile section */
+		98ABF69E2BAB07A20059C441 /* Mp4Restructure.swift in Sources */ = {isa = PBXBuildFile; fileRef = 98ABF69D2BAB07A20059C441 /* Mp4Restructure.swift */; };
+		98C82AE62B8CA8BC00AED485 /* RemoteMp4Restructure.swift in Sources */ = {isa = PBXBuildFile; fileRef = 98C82AE52B8CA8BC00AED485 /* RemoteMp4Restructure.swift */; };
+		98CC396E28BD651E006C9FF9 /* Atomic.swift in Sources */ = {isa = PBXBuildFile; fileRef = 98CC396D28BD651E006C9FF9 /* Atomic.swift */; };
+		98DC00CC2B961F5E0068900A /* ByteBuffer.swift in Sources */ = {isa = PBXBuildFile; fileRef = 98DC00CB2B961F5E0068900A /* ByteBuffer.swift */; };
+		98DC00CE2B9726380068900A /* ByteBufferTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 98DC00CD2B9726380068900A /* ByteBufferTests.swift */; };
 		B500732024D00BAC00BB4475 /* Logger.swift in Sources */ = {isa = PBXBuildFile; fileRef = B500731F24D00BAC00BB4475 /* Logger.swift */; };
 		B514657F248E3884005C03F7 /* DispatchTimerSource.swift in Sources */ = {isa = PBXBuildFile; fileRef = B514657E248E3884005C03F7 /* DispatchTimerSource.swift */; };
 		B51B9F9A24DBE5BF00BDEAA2 /* AVAudioFormat+Convenience.swift in Sources */ = {isa = PBXBuildFile; fileRef = B51B9F9924DBE5BF00BDEAA2 /* AVAudioFormat+Convenience.swift */; };
@@ -33,7 +38,6 @@
 		B5667A902499018D00D93F85 /* AudioFileStreamProcessor.swift in Sources */ = {isa = PBXBuildFile; fileRef = B5667A8F2499018D00D93F85 /* AudioFileStreamProcessor.swift */; };
 		B5667A922499063D00D93F85 /* AudioPlayerContext.swift in Sources */ = {isa = PBXBuildFile; fileRef = B5667A912499063D00D93F85 /* AudioPlayerContext.swift */; };
 		B5667B3E249BC43100D93F85 /* AudioPlayerRenderProcessor.swift in Sources */ = {isa = PBXBuildFile; fileRef = B5667B3D249BC43000D93F85 /* AudioPlayerRenderProcessor.swift */; };
-		B5737340254DE43E003DFBEC /* measure.swift in Sources */ = {isa = PBXBuildFile; fileRef = B573733F254DE43E003DFBEC /* measure.swift */; };
 		B57829CF2548B32B00C78D36 /* Lock.swift in Sources */ = {isa = PBXBuildFile; fileRef = B57829CE2548B32B00C78D36 /* Lock.swift */; };
 		B58386382544A2C10087A712 /* EntryFrames.swift in Sources */ = {isa = PBXBuildFile; fileRef = B58386372544A2C10087A712 /* EntryFrames.swift */; };
 		B5838640254584A50087A712 /* ProcessedPackets.swift in Sources */ = {isa = PBXBuildFile; fileRef = B583863F254584A50087A712 /* ProcessedPackets.swift */; };
@@ -64,8 +68,7 @@
 		B5EF9557247E9439003E8FF8 /* AudioStreamSource.swift in Sources */ = {isa = PBXBuildFile; fileRef = B5EF9556247E9439003E8FF8 /* AudioStreamSource.swift */; };
 		B5EF955B247EBCB3003E8FF8 /* AudioFileType.swift in Sources */ = {isa = PBXBuildFile; fileRef = B5EF955A247EBCB3003E8FF8 /* AudioFileType.swift */; };
 		B5EF955D247ECBB1003E8FF8 /* RemoteAudioSource.swift in Sources */ = {isa = PBXBuildFile; fileRef = B5EF955C247ECBB1003E8FF8 /* RemoteAudioSource.swift */; };
-		B5F883B62476DADB00D277C1 /* Protected.swift in Sources */ = {isa = PBXBuildFile; fileRef = B5F883B52476DADB00D277C1 /* Protected.swift */; };
-		B5F883BA2477CEFC00D277C1 /* ProtectedTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = B5F883B82477CBF600D277C1 /* ProtectedTests.swift */; };
+		B5F883BA2477CEFC00D277C1 /* AtomicTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = B5F883B82477CBF600D277C1 /* AtomicTests.swift */; };
 		B5F883C32477DC4400D277C1 /* NetworkDataStream.swift in Sources */ = {isa = PBXBuildFile; fileRef = B5F883C22477DC4400D277C1 /* NetworkDataStream.swift */; };
 		B5FB6C0525516507002C0A37 /* AudioConverter+Helpers.swift in Sources */ = {isa = PBXBuildFile; fileRef = B5FB6C0425516507002C0A37 /* AudioConverter+Helpers.swift */; };
 /* End PBXBuildFile section */
@@ -94,6 +97,11 @@
 /* End PBXCopyFilesBuildPhase section */
 
 /* Begin PBXFileReference section */
+		98ABF69D2BAB07A20059C441 /* Mp4Restructure.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Mp4Restructure.swift; sourceTree = "<group>"; };
+		98C82AE52B8CA8BC00AED485 /* RemoteMp4Restructure.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RemoteMp4Restructure.swift; sourceTree = "<group>"; };
+		98CC396D28BD651E006C9FF9 /* Atomic.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Atomic.swift; sourceTree = "<group>"; };
+		98DC00CB2B961F5E0068900A /* ByteBuffer.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ByteBuffer.swift; sourceTree = "<group>"; };
+		98DC00CD2B9726380068900A /* ByteBufferTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ByteBufferTests.swift; sourceTree = "<group>"; };
 		B500731F24D00BAC00BB4475 /* Logger.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Logger.swift; sourceTree = "<group>"; };
 		B514657E248E3884005C03F7 /* DispatchTimerSource.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DispatchTimerSource.swift; sourceTree = "<group>"; };
 		B51B9F9924DBE5BF00BDEAA2 /* AVAudioFormat+Convenience.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "AVAudioFormat+Convenience.swift"; sourceTree = "<group>"; };
@@ -121,7 +129,6 @@
 		B5667A8F2499018D00D93F85 /* AudioFileStreamProcessor.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AudioFileStreamProcessor.swift; sourceTree = "<group>"; };
 		B5667A912499063D00D93F85 /* AudioPlayerContext.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AudioPlayerContext.swift; sourceTree = "<group>"; };
 		B5667B3D249BC43000D93F85 /* AudioPlayerRenderProcessor.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AudioPlayerRenderProcessor.swift; sourceTree = "<group>"; };
-		B573733F254DE43E003DFBEC /* measure.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = measure.swift; sourceTree = "<group>"; };
 		B57829CE2548B32B00C78D36 /* Lock.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Lock.swift; sourceTree = "<group>"; };
 		B580CB1D25628CF4006D7DD8 /* AudioStreaming.podspec */ = {isa = PBXFileReference; lastKnownFileType = text; path = AudioStreaming.podspec; sourceTree = "<group>"; };
 		B580CB1E25628CF4006D7DD8 /* LICENSE */ = {isa = PBXFileReference; lastKnownFileType = text; path = LICENSE; sourceTree = "<group>"; };
@@ -158,8 +165,7 @@
 		B5EF9556247E9439003E8FF8 /* AudioStreamSource.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AudioStreamSource.swift; sourceTree = "<group>"; };
 		B5EF955A247EBCB3003E8FF8 /* AudioFileType.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AudioFileType.swift; sourceTree = "<group>"; };
 		B5EF955C247ECBB1003E8FF8 /* RemoteAudioSource.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RemoteAudioSource.swift; sourceTree = "<group>"; };
-		B5F883B52476DADB00D277C1 /* Protected.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Protected.swift; sourceTree = "<group>"; };
-		B5F883B82477CBF600D277C1 /* ProtectedTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ProtectedTests.swift; sourceTree = "<group>"; };
+		B5F883B82477CBF600D277C1 /* AtomicTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AtomicTests.swift; sourceTree = "<group>"; };
 		B5F883C22477DC4400D277C1 /* NetworkDataStream.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NetworkDataStream.swift; sourceTree = "<group>"; };
 		B5FB6C0425516507002C0A37 /* AudioConverter+Helpers.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "AudioConverter+Helpers.swift"; sourceTree = "<group>"; };
 		B5FFF5FD2549FA02006BBB7C /* AudioExample.xctestplan */ = {isa = PBXFileReference; lastKnownFileType = text; path = AudioExample.xctestplan; sourceTree = "<group>"; };
@@ -184,6 +190,15 @@
 /* End PBXFrameworksBuildPhase section */
 
 /* Begin PBXGroup section */
+		98C82AE42B8CA8AA00AED485 /* Mp4 */ = {
+			isa = PBXGroup;
+			children = (
+				98C82AE52B8CA8BC00AED485 /* RemoteMp4Restructure.swift */,
+				98ABF69D2BAB07A20059C441 /* Mp4Restructure.swift */,
+			);
+			path = Mp4;
+			sourceTree = "<group>";
+		};
 		B5276B70247D4D3D00D2F56A /* Network */ = {
 			isa = PBXGroup;
 			children = (
@@ -302,6 +317,7 @@
 		B58BD7FC255DB653005B756D /* Audio Source */ = {
 			isa = PBXGroup;
 			children = (
+				98C82AE42B8CA8AA00AED485 /* Mp4 */,
 				B5EF9556247E9439003E8FF8 /* AudioStreamSource.swift */,
 				B5EF955C247ECBB1003E8FF8 /* RemoteAudioSource.swift */,
 				B59D0B6E255C904900D6CCE5 /* FileAudioSource.swift */,
@@ -321,11 +337,11 @@
 		B592E13025460883008866FB /* Helpers */ = {
 			isa = PBXGroup;
 			children = (
-				B573733F254DE43E003DFBEC /* measure.swift */,
+				98DC00CB2B961F5E0068900A /* ByteBuffer.swift */,
+				98CC396D28BD651E006C9FF9 /* Atomic.swift */,
 				B514657E248E3884005C03F7 /* DispatchTimerSource.swift */,
 				B57829CE2548B32B00C78D36 /* Lock.swift */,
 				B500731F24D00BAC00BB4475 /* Logger.swift */,
-				B5F883B52476DADB00D277C1 /* Protected.swift */,
 				B54C3E55255F286D00B356F2 /* Retrier.swift */,
 			);
 			path = Helpers;
@@ -431,8 +447,8 @@
 		B5F883B42476DABE00D277C1 /* Core */ = {
 			isa = PBXGroup;
 			children = (
-				B592E11E2545FF33008866FB /* Structures */,
 				B55CE97624813BA10001C498 /* Extensions */,
+				B592E11E2545FF33008866FB /* Structures */,
 				B5276B70247D4D3D00D2F56A /* Network */,
 				B592E13025460883008866FB /* Helpers */,
 			);
@@ -443,10 +459,11 @@
 			isa = PBXGroup;
 			children = (
 				B5EF954A247DA450003E8FF8 /* Network */,
-				B5F883B82477CBF600D277C1 /* ProtectedTests.swift */,
+				B5F883B82477CBF600D277C1 /* AtomicTests.swift */,
 				B51FE0C12488F96A00F2A4D2 /* QueueTests.swift */,
 				B592E12825460146008866FB /* BiMapTests.swift */,
 				B592E133254608B4008866FB /* DispatchTimerSourceTests.swift */,
+				98DC00CD2B9726380068900A /* ByteBufferTests.swift */,
 			);
 			path = Core;
 			sourceTree = "<group>";
@@ -584,7 +601,7 @@
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 			shellPath = /bin/sh;
-			shellScript = "if which swiftlint >/dev/null; then\n  swiftlint\nelse\n  echo \"warning: SwiftLint not installed, download from https://github.com/realm/SwiftLint\"\nfi\n";
+			shellScript = "if [[ \"$(uname -m)\" == arm64 ]]; then\n    export PATH=\"/opt/homebrew/bin:$PATH\"\nfi\n\nif which swiftlint > /dev/null; then\n  swiftlint\nelse\n  echo \"warning: SwiftLint not installed, download from https://github.com/realm/SwiftLint\"\nfi\n";
 		};
 /* End PBXShellScriptBuildPhase section */
 
@@ -599,6 +616,7 @@
 				B5838640254584A50087A712 /* ProcessedPackets.swift in Sources */,
 				B54C3E56255F286D00B356F2 /* Retrier.swift in Sources */,
 				B59DF10424916FD50043C498 /* DispatchQueue+Helpers.swift in Sources */,
+				98CC396E28BD651E006C9FF9 /* Atomic.swift in Sources */,
 				B5B3B7CC248647ED00656828 /* AudioPlayerState.swift in Sources */,
 				B51B9F9A24DBE5BF00BDEAA2 /* AVAudioFormat+Convenience.swift in Sources */,
 				B51FE0C624890CCB00F2A4D2 /* PlayerQueueEntries.swift in Sources */,
@@ -607,7 +625,6 @@
 				B59DF1A32493E90C0043C498 /* AudioFileStream+Helpers.swift in Sources */,
 				B54D876D2490E4A000C361A0 /* UnitDescriptions.swift in Sources */,
 				B514657F248E3884005C03F7 /* DispatchTimerSource.swift in Sources */,
-				B5737340254DE43E003DFBEC /* measure.swift in Sources */,
 				B55CEABC24853CD20001C498 /* AudioPlayer.swift in Sources */,
 				B5667B3E249BC43100D93F85 /* AudioPlayerRenderProcessor.swift in Sources */,
 				B5276B6F247D21A000D2F56A /* NetworkingClient.swift in Sources */,
@@ -617,6 +634,7 @@
 				B5D4A41025D948EF00E1450C /* IcycastHeadersProcessor.swift in Sources */,
 				B5667A902499018D00D93F85 /* AudioFileStreamProcessor.swift in Sources */,
 				B59D0B6F255C904900D6CCE5 /* FileAudioSource.swift in Sources */,
+				98DC00CC2B961F5E0068900A /* ByteBuffer.swift in Sources */,
 				B5EF9555247E9393003E8FF8 /* AudioEntry.swift in Sources */,
 				B5B36E432655A32200DC96F5 /* FrameFilterProcessor.swift in Sources */,
 				B51FE0C02488F67C00F2A4D2 /* Queue.swift in Sources */,
@@ -633,12 +651,13 @@
 				B55CE96E248058B60001C498 /* MetadataParser.swift in Sources */,
 				B5838644254584BE0087A712 /* AudioStreamState.swift in Sources */,
 				B500732024D00BAC00BB4475 /* Logger.swift in Sources */,
+				98C82AE62B8CA8BC00AED485 /* RemoteMp4Restructure.swift in Sources */,
 				B5276B74247D4D9F00D2F56A /* NetworkSessionDelegate.swift in Sources */,
 				B55F77D624DACE140057F431 /* BufferContext.swift in Sources */,
 				B5838648254584D90087A712 /* SeekRequest.swift in Sources */,
 				B5D82E65255DD562009EDAA4 /* NetStatusService.swift in Sources */,
 				B55CE97824813BCA0001C498 /* UnsafeMutablePointer+Helpers.swift in Sources */,
-				B5F883B62476DADB00D277C1 /* Protected.swift in Sources */,
+				98ABF69E2BAB07A20059C441 /* Mp4Restructure.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -651,10 +670,11 @@
 				B51FE0C824892D1600F2A4D2 /* PlayerQueueEntriesTest.swift in Sources */,
 				B55CEABA248530C00001C498 /* MetadataParser.swift in Sources */,
 				B51FE0C22488F96A00F2A4D2 /* QueueTests.swift in Sources */,
-				B5F883BA2477CEFC00D277C1 /* ProtectedTests.swift in Sources */,
+				B5F883BA2477CEFC00D277C1 /* AtomicTests.swift in Sources */,
 				B592E134254608B4008866FB /* DispatchTimerSourceTests.swift in Sources */,
 				B55CEAB82485172D0001C498 /* HTTPHeaderParserTests.swift in Sources */,
 				B592E12925460146008866FB /* BiMapTests.swift in Sources */,
+				98DC00CE2B9726380068900A /* ByteBufferTests.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -721,8 +741,8 @@
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 12.0;
-				MARKETING_VERSION = 0.1.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 13.0;
+				MARKETING_VERSION = 1.1.0;
 				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
 				MTL_FAST_MATH = YES;
 				ONLY_ACTIVE_ARCH = YES;
@@ -780,8 +800,8 @@
 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
 				GCC_WARN_UNUSED_FUNCTION = YES;
 				GCC_WARN_UNUSED_VARIABLE = YES;
-				IPHONEOS_DEPLOYMENT_TARGET = 12.0;
-				MARKETING_VERSION = 0.1.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 13.0;
+				MARKETING_VERSION = 1.1.0;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				MTL_FAST_MATH = YES;
 				SDKROOT = iphoneos;
@@ -805,13 +825,13 @@
 				DYLIB_INSTALL_NAME_BASE = "@rpath";
 				INFOPLIST_FILE = AudioStreaming/Info.plist;
 				INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks";
-				IPHONEOS_DEPLOYMENT_TARGET = 12.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 13.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
 					"@loader_path/Frameworks",
 				);
-				MARKETING_VERSION = 0.6.0;
+				MARKETING_VERSION = 1.2.0;
 				OTHER_LDFLAGS = "-ObjC";
 				PRODUCT_BUNDLE_IDENTIFIER = com.decimal.AudioStreaming;
 				PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)";
@@ -836,13 +856,13 @@
 				DYLIB_INSTALL_NAME_BASE = "@rpath";
 				INFOPLIST_FILE = AudioStreaming/Info.plist;
 				INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks";
-				IPHONEOS_DEPLOYMENT_TARGET = 12.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 13.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
 					"@loader_path/Frameworks",
 				);
-				MARKETING_VERSION = 0.6.0;
+				MARKETING_VERSION = 1.2.0;
 				OTHER_LDFLAGS = "-ObjC";
 				PRODUCT_BUNDLE_IDENTIFIER = com.decimal.AudioStreaming;
 				PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)";
@@ -861,6 +881,7 @@
 				CLANG_ENABLE_MODULES = YES;
 				CODE_SIGN_STYLE = Automatic;
 				INFOPLIST_FILE = AudioStreamingTests/Info.plist;
+				IPHONEOS_DEPLOYMENT_TARGET = 13.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@@ -881,6 +902,7 @@
 				CLANG_ENABLE_MODULES = YES;
 				CODE_SIGN_STYLE = Automatic;
 				INFOPLIST_FILE = AudioStreamingTests/Info.plist;
+				IPHONEOS_DEPLOYMENT_TARGET = 13.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",

AudioStreaming/Core/Extensions/AVAudioFormat+Convenience.swift

@@ -5,11 +5,11 @@
 
 import AVFoundation
 
-extension AVAudioFormat {
+public extension AVAudioFormat {
     /// The underlying audio stream description.
     ///
     /// This exposes the `pointee` value of the `UsafePointer<AudioStreamBasicDescription>`
-    public var basicStreamDescription: AudioStreamBasicDescription {
+    var basicStreamDescription: AudioStreamBasicDescription {
         return streamDescription.pointee
     }
 }

AudioStreaming/Core/Extensions/AudioFileStream+Helpers.swift

@@ -8,11 +8,13 @@ import AVFoundation
 @discardableResult
 func fileStreamGetProperty<Value>(value: inout Value, fileStream streamId: AudioFileStreamID, propertyId: AudioFileStreamPropertyID) -> OSStatus {
     var (size, _) = fileStreamGetPropertyInfo(fileStream: streamId, propertyId: propertyId)
-    let status = AudioFileStreamGetProperty(streamId, propertyId, &size, &value)
-    guard status == noErr else {
+    return withUnsafeMutablePointer(to: &value) { pointer in
+        let status = AudioFileStreamGetProperty(streamId, propertyId, &size, pointer)
+        guard status == noErr else {
+            return status
+        }
         return status
     }
-    return status
 }
 
 func fileStreamGetPropertyInfo(fileStream streamId: AudioFileStreamID, propertyId: AudioFileStreamPropertyID) -> (size: UInt32, status: OSStatus) {
@@ -112,3 +114,50 @@ public enum AudioFileStreamError: CustomDebugStringConvertible {
         }
     }
 }
+
+public extension AudioFileStreamPropertyID {
+    var description: String {
+        switch self {
+        case kAudioFileStreamProperty_ReadyToProducePackets:
+            return "Ready to produce packets"
+        case kAudioFileStreamProperty_FileFormat:
+            return "File format"
+        case kAudioFileStreamProperty_DataFormat:
+            return "Data format"
+        case kAudioFileStreamProperty_AudioDataByteCount:
+            return "Byte count"
+        case kAudioFileStreamProperty_AudioDataPacketCount:
+            return "Packet count"
+        case kAudioFileStreamProperty_DataOffset:
+            return "Data offset"
+        case kAudioFileStreamProperty_BitRate:
+            return "Bit rate"
+        case kAudioFileStreamProperty_FormatList:
+            return "Format list"
+        case kAudioFileStreamProperty_MagicCookieData:
+            return "Magic cookie"
+        case kAudioFileStreamProperty_MaximumPacketSize:
+            return "Max packet size"
+        case kAudioFileStreamProperty_ChannelLayout:
+            return "Channel layout"
+        case kAudioFileStreamProperty_PacketToFrame:
+            return "Packet to frame"
+        case kAudioFileStreamProperty_FrameToPacket:
+            return "Frame to packet"
+        case kAudioFileStreamProperty_PacketToByte:
+            return "Packet to byte"
+        case kAudioFileStreamProperty_ByteToPacket:
+            return "Byte to packet"
+        case kAudioFileStreamProperty_PacketTableInfo:
+            return "Packet table"
+        case kAudioFileStreamProperty_PacketSizeUpperBound:
+            return "Packet size upper bound"
+        case kAudioFileStreamProperty_AverageBytesPerPacket:
+            return "Average bytes per packet"
+        case kAudioFileStreamProperty_InfoDictionary:
+            return "Info dictionary"
+        default:
+            return "Unknown"
+        }
+    }
+}

AudioStreaming/Core/Helpers/Atomic.swift

@@ -13,10 +13,10 @@ final class Atomic<Value> {
         _value = value
     }
 
-    var value: Value { lock.around { _value } }
+    var value: Value { lock.withLock { _value } }
 
     func write(_ transform: (inout Value) -> Void) {
-        lock.around { transform(&self._value) }
+        lock.withLock { transform(&self._value) }
     }
 }
 

AudioStreaming/Core/Helpers/ByteBuffer.swift

@@ -0,0 +1,187 @@
+//
+//  Created by Dimitrios Chatzieleftheriou on 4/03/2024.
+//  Copyright © 2024 Decimal. All rights reserved.
+//
+
+import Foundation
+
+// Struct representing a buffer for handling binary data
+struct ByteBuffer {
+    // Custom errors for ByteBuffer
+    enum Error: Swift.Error {
+        case eof // End of file
+        case parse // Parsing error
+    }
+
+    // Data storage for the buffer
+    private(set) var storage = Data()
+
+    // Current offset in the buffer
+    var offset: Int = 0
+
+    // Calculated property for the number of bytes available for reading
+    var bytesAvailable: Int {
+        storage.count - offset
+    }
+
+    // Calculated property for the length of the buffer
+    var length: Int {
+        get {
+            storage.count
+        }
+        set {
+            // Adjusting the length of the buffer
+            switch true {
+            case storage.count < newValue:
+                storage.append(Data(count: newValue - storage.count))
+            case newValue < storage.count:
+                storage = storage.subdata(in: 0 ..< newValue)
+            default:
+                break
+            }
+        }
+    }
+
+    // Subscript for accessing individual bytes in the buffer
+    subscript(i: Int) -> UInt8 {
+        get { storage[i] }
+        set { storage[i] = newValue }
+    }
+
+    // Initialize the buffer with given data
+    init(data: Data) {
+        storage = data
+        offset = 0
+    }
+
+    // Initialize the buffer with a specified size, filling it with zeros
+    init(size: Int) {
+        storage = Data(repeating: 0x00, count: size)
+        offset = 0
+    }
+
+    // Clear the buffer (reset offset to zero)
+    @discardableResult
+    mutating func clear() -> Self {
+        offset = 0
+        return self
+    }
+
+    // Rewind the buffer (reset offset to zero)
+    mutating func rewind() {
+        offset = 0
+    }
+
+    // Read a specified number of bytes from the buffer
+    mutating func readBytes(_ length: Int) throws -> Data {
+        guard length <= bytesAvailable else {
+            throw ByteBuffer.Error.eof
+        }
+        offset += length
+        return storage.subdata(in: offset - length ..< offset)
+    }
+
+    // Write data into the buffer
+    @discardableResult
+    mutating func writeBytes(_ value: Data) -> Self {
+        // If the offset is at the end, append the value to the data
+        if offset == storage.count {
+            storage.append(value)
+            offset = storage.count
+            return self
+        }
+        // Otherwise, write the value into the buffer at the current offset
+        let length: Int = min(storage.count, value.count)
+        storage[offset ..< offset + length] = value[0 ..< length]
+        // If the value is longer than the remaining space, append the rest to the data
+        if length == storage.count {
+            storage.append(value[length ..< value.count])
+        }
+        offset += value.count
+        return self
+    }
+
+    // Write integer value into the buffer
+    @discardableResult
+    mutating func put<T: FixedWidthInteger>(_ value: T) -> ByteBuffer {
+        writeBytes(value.data)
+    }
+
+    // Write float value into the buffer
+    @discardableResult
+    mutating func put(_ value: Float) -> ByteBuffer {
+        writeBytes(Data(value.data.reversed()))
+    }
+
+    // Write double value into the buffer
+    @discardableResult
+    mutating func put(_ value: Double) -> ByteBuffer {
+        writeBytes(Data(value.data.reversed()))
+    }
+
+    // Read an integer value from the buffer
+    mutating func getInteger<T: FixedWidthInteger>() throws -> T {
+        let sizeOfInteger = MemoryLayout<T>.size
+        guard sizeOfInteger <= bytesAvailable else {
+            throw ByteBuffer.Error.eof
+        }
+        offset += sizeOfInteger
+        return T(data: storage[offset - sizeOfInteger ..< offset]).bigEndian
+    }
+
+    // Read an integer value from a specific index in the buffer
+    func getInteger<T: FixedWidthInteger>(_ index: Int) throws -> T {
+        let sizeOfInteger = MemoryLayout<T>.size
+        guard sizeOfInteger + index <= length else {
+            throw ByteBuffer.Error.eof
+        }
+        return T(data: storage[index ..< index + sizeOfInteger]).bigEndian
+    }
+
+    // Read a float value from the buffer
+    mutating func getFloat() throws -> Float {
+        let sizeOfFloat = MemoryLayout<UInt32>.size
+        guard sizeOfFloat <= bytesAvailable else {
+            throw ByteBuffer.Error.eof
+        }
+        offset += sizeOfFloat
+        return Float(data: Data(storage.subdata(in: offset - sizeOfFloat ..< offset).reversed()))
+    }
+
+    // Read a double value from the buffer
+    mutating func getDouble() throws -> Double {
+        let sizeOfDouble = MemoryLayout<UInt64>.size
+        guard sizeOfDouble <= bytesAvailable else {
+            throw ByteBuffer.Error.eof
+        }
+        offset += sizeOfDouble
+        return Double(data: Data(storage.subdata(in: offset - sizeOfDouble ..< offset).reversed()))
+    }
+}
+
+// Extension to provide conformance to ExpressibleByIntegerLiteral for easy conversion between integers and Data
+extension ExpressibleByIntegerLiteral {
+    // Convert integer to Data
+    var data: Data {
+        return withUnsafePointer(to: self) { pointer in
+            Data(bytes: pointer, count: MemoryLayout<Self>.size)
+        }
+    }
+
+    // Initialize from Data
+    init(data: Data) {
+        let diff: Int = MemoryLayout<Self>.size - data.count
+        if diff > 0 {
+            var buffer = Data(repeating: 0, count: diff)
+            buffer.append(data)
+            self = buffer.withUnsafeBytes { $0.baseAddress!.assumingMemoryBound(to: Self.self).pointee }
+            return
+        }
+        self = data.withUnsafeBytes { $0.baseAddress!.assumingMemoryBound(to: Self.self).pointee }
+    }
+
+    // Initialize from Data slice
+    init(data: Slice<Data>) {
+        self.init(data: Data(data))
+    }
+}

AudioStreaming/Core/Helpers/DispatchTimerSource.swift

@@ -11,10 +11,10 @@ import Foundation
 final class DispatchTimerSource {
     private var handler: (() -> Void)?
     private let timer: DispatchSourceTimer
-    internal var state: SourceState = .suspended
+    var state: SourceState = .suspended
 
     /// The state of the timer
-    internal enum SourceState {
+    enum SourceState {
         case activated
         case suspended
     }

AudioStreaming/Core/Helpers/Lock.swift

@@ -8,46 +8,53 @@ import Foundation
 protocol Lock {
     func lock()
     func unlock()
-}
 
-extension Lock {
     // Execute a closure while acquiring a lock and returns the closure value
-    @inline(__always)
-    func around<Value>(_ closure: () -> Value) -> Value {
-        lock(); defer { unlock() }
-        return closure()
-    }
+    func withLock<Result>(body: () throws -> Result) rethrows -> Result
 
     // Execute a closure while acquiring a lock
-    @inline(__always)
-    func around(_ closure: () -> Void) {
-        lock(); defer { unlock() }
-        closure()
-    }
+    func withLock(body: () -> Void)
 }
 
 /// A wrapper for `os_unfair_lock`
 /// - Tag: UnfairLock
 final class UnfairLock: Lock {
-    private let unfairLock: os_unfair_lock_t
+    @usableFromInline let unfairLock: UnsafeMutablePointer<os_unfair_lock>
 
-    internal init() {
+    init() {
         unfairLock = .allocate(capacity: 1)
         unfairLock.initialize(to: os_unfair_lock())
     }
 
     deinit {
-        unfairLock.deinitialize(count: 1)
         unfairLock.deallocate()
     }
 
+    @inlinable
     @inline(__always)
-    internal func lock() {
+    func withLock<Result>(body: () throws -> Result) rethrows -> Result {
+        os_unfair_lock_lock(unfairLock)
+        defer { os_unfair_lock_unlock(unfairLock) }
+        return try body()
+    }
+
+    @inlinable
+    @inline(__always)
+    func withLock(body: () -> Void) {
+        os_unfair_lock_lock(unfairLock)
+        defer { os_unfair_lock_unlock(unfairLock) }
+        body()
+    }
+
+    @inlinable
+    @inline(__always)
+    func lock() {
         os_unfair_lock_lock(unfairLock)
     }
 
+    @inlinable
     @inline(__always)
-    internal func unlock() {
+    func unlock() {
         os_unfair_lock_unlock(unfairLock)
     }
 }

AudioStreaming/Core/Helpers/Logger.swift

@@ -8,7 +8,7 @@ import os
 
 private let loggingSubsystem = "audio.streaming.log"
 
-internal enum Logger {
+enum Logger {
     private static let audioRendering = OSLog(subsystem: loggingSubsystem, category: "audio.rendering")
     private static let networking = OSLog(subsystem: loggingSubsystem, category: "audio.networking")
     private static let generic = OSLog(subsystem: loggingSubsystem, category: "audio.streaming.generic")
@@ -31,7 +31,7 @@ internal enum Logger {
     }
 
     static func error(_ message: StaticString, category: Category, args: CVarArg...) {
-        proccess(message, category: category, type: .error, args: args)
+        process(message, category: category, type: .error, args: args)
     }
 
     static func error(_ message: StaticString, category: Category) {
@@ -39,14 +39,14 @@ internal enum Logger {
     }
 
     static func debug(_ message: StaticString, category: Category, args: CVarArg...) {
-        proccess(message, category: category, type: .debug, args: args)
+        process(message, category: category, type: .debug, args: args)
     }
 
     static func debug(_ message: StaticString, category: Category) {
         debug(message, category: category, args: [])
     }
 
-    private static func proccess(_ message: StaticString, category: Category, type: OSLogType, args: CVarArg...) {
+    private static func process(_ message: StaticString, category: Category, type: OSLogType, args: CVarArg...) {
         guard isEnabled else { return }
         os_log(message, log: category.toOSLog(), type: type, args)
     }

AudioStreaming/Core/Helpers/Protected.swift

@@ -1,24 +0,0 @@
-//
-//  Created by Dimitrios Chatzieleftheriou on 21/05/2020.
-//  Copyright © 2020 Decimal. All rights reserved.
-//
-
-internal final class Protected<Value> {
-    var value: Value { lock.around { _value } }
-
-    private let lock = UnfairLock()
-    private var _value: Value
-
-    init(_ value: Value) {
-        _value = value
-    }
-
-    func read<Element>(_ closure: (Value) -> Element) -> Element {
-        lock.around { closure(self._value) }
-    }
-
-    @discardableResult
-    func write<Element>(_ closure: (inout Value) -> Element) -> Element {
-        lock.around { closure(&self._value) }
-    }
-}

AudioStreaming/Core/Helpers/Retrier.swift

@@ -13,7 +13,7 @@ final class Retrier {
     private let maxInterval: Int
     private let timeoutTimer: DispatchTimerSource
 
-    /// Initiliazes a new object with the given parameters
+    /// Initializes a new object with the given parameters
     /// - Parameters:
     ///   - interval: The Mach absolute time at which to execute the dispatch source's event handler.
     ///   - maxInterval: The maximum interval in which the internal timer will retry the callback.
@@ -38,6 +38,7 @@ final class Retrier {
 
     /// Cancels retrying
     func cancel() {
+        interval = .seconds(1)
         timeoutTimer.removeHandler()
         timeoutTimer.suspend()
     }

AudioStreaming/Core/Helpers/measure.swift

@@ -1,15 +0,0 @@
-//
-//  measure.swift
-//  AudioStreaming
-//
-//  Created by Dimitrios Chatzieleftheriou on 31/10/2020.
-//  Copyright © 2020 Decimal. All rights reserved.
-//
-
-import Foundation
-
-func measure(name: String = "", block: () -> Void) {
-    let started = ProcessInfo.processInfo.systemUptime
-    block()
-    print("diff for \(name): \(String(format: "%.6f", ProcessInfo.processInfo.systemUptime - started))")
-}

AudioStreaming/Core/Network/NetStatusService.swift

@@ -9,12 +9,14 @@ import Network
 enum NetConnectionType: Equatable {
     case cellular(connected: Bool)
     case wifi(connected: Bool)
+    case other(connected: Bool)
     case undetermined
 
     var isConnected: Bool {
         switch self {
         case let .cellular(connected),
-             let .wifi(connected):
+             let .wifi(connected),
+             let .other(connected):
             return connected
         default:
             return false
@@ -39,15 +41,13 @@ final class NetStatusService: NetStatusProvider {
         network.currentPath.toNetConnectionType()
     }
 
-    private var currentConnectionType: NetConnectionType = .undetermined
-
     private let network: NWPathMonitor
 
     private let monitorQueue: DispatchQueue
 
     init(network: NWPathMonitor) {
         self.network = network
-        monitorQueue = DispatchQueue(label: "net.path.queue", qos: .background)
+        monitorQueue = DispatchQueue(label: "net.path.queue", qos: .utility)
     }
 
     deinit {
@@ -59,20 +59,15 @@ final class NetStatusService: NetStatusProvider {
     /// - parameter connectionChange: A callback block to listen to changes of the network type, this skips duplicates.
     /// - Note:  The callback will be executed on the main thread.
     func start(connectionChange: @escaping (NetConnectionType) -> Void) {
-        network.pathUpdateHandler = { [weak self] path in
-            guard let self = self else { return }
-            let connecionType = path.toNetConnectionType()
-            if self.currentConnectionType != connecionType {
-                connectionChange(self.connectionType)
-                self.currentConnectionType = self.connectionType
-            }
+        network.pathUpdateHandler = { path in
+            let connectionType = path.toNetConnectionType()
+            connectionChange(connectionType)
         }
         startIfNeeded()
     }
 
     func stop() {
         network.cancel()
-        network.pathUpdateHandler = nil
     }
 
     func startIfNeeded() {
@@ -85,12 +80,17 @@ extension NWPath {
     func toNetConnectionType() -> NetConnectionType {
         let isCellular = usesInterfaceType(.cellular)
         let isWifi = usesInterfaceType(.wifi)
+        let isOther = usesInterfaceType(.loopback)
+            || usesInterfaceType(.other)
+            || usesInterfaceType(.wiredEthernet)
         let isConnected = status == .satisfied
 
         if isCellular {
             return .cellular(connected: isConnected)
         } else if isWifi {
             return .wifi(connected: isConnected)
+        } else if isOther {
+            return .other(connected: isConnected)
         }
 
         return .undetermined

AudioStreaming/Core/Network/NetworkDataStream.swift

@@ -5,7 +5,7 @@
 
 import Foundation
 
-internal final class NetworkDataStream {
+final class NetworkDataStream {
     typealias StreamResult = Result<Response, Error>
     typealias StreamCompletion = (_ event: NetworkDataStream.ResponseEvent) -> Void
 
@@ -52,7 +52,7 @@ internal final class NetworkDataStream {
         task?.response as? HTTPURLResponse
     }
 
-    internal init(id: UUID, underlyingQueue: DispatchQueue) {
+    init(id: UUID, underlyingQueue: DispatchQueue) {
         self.id = id
         self.underlyingQueue = underlyingQueue
         state = .initialised
@@ -94,7 +94,7 @@ internal final class NetworkDataStream {
 
     // MARK: Internal
 
-    internal func didReceive(response: HTTPURLResponse?) {
+    func didReceive(response: HTTPURLResponse?) {
         underlyingQueue.async { [weak self] in
             guard let self = self else { return }
             guard let streamCallback = self.streamCallback else { return }
@@ -102,7 +102,7 @@ internal final class NetworkDataStream {
         }
     }
 
-    internal func didReceive(data: Data, response: HTTPURLResponse?) {
+    func didReceive(data: Data, response: HTTPURLResponse?) {
         underlyingQueue.async { [weak self] in
             guard let self = self else { return }
             guard let streamCallback = self.streamCallback else { return }
@@ -111,7 +111,7 @@ internal final class NetworkDataStream {
         }
     }
 
-    internal func didComplete(with error: Error?, response: HTTPURLResponse?) {
+    func didComplete(with error: Error?, response: HTTPURLResponse?) {
         underlyingQueue.async { [weak self] in
             guard let self = self else { return }
             guard let stream = self.streamCallback else { return }

AudioStreaming/Core/Network/NetworkSessionDelegate.swift

@@ -5,10 +5,10 @@
 
 import Foundation
 
-internal final class NetworkSessionDelegate: NSObject, URLSessionDataDelegate {
+final class NetworkSessionDelegate: NSObject, URLSessionDataDelegate {
     weak var taskProvider: StreamTaskProvider?
 
-    internal func stream(for task: URLSessionTask) -> NetworkDataStream? {
+    func stream(for task: URLSessionTask) -> NetworkDataStream? {
         guard let taskProvider = taskProvider else {
             assertionFailure("couldn't found taskProvider")
             return nil
@@ -16,22 +16,22 @@ internal final class NetworkSessionDelegate: NSObject, URLSessionDataDelegate {
         return taskProvider.dataStream(for: task)
     }
 
-    internal func urlSession(_: URLSession,
-                             dataTask: URLSessionDataTask,
-                             didReceive data: Data)
+    func urlSession(_: URLSession,
+                    dataTask: URLSessionDataTask,
+                    didReceive data: Data)
     {
-        guard let stream = self.stream(for: dataTask) else {
+        guard let stream = stream(for: dataTask) else {
             return
         }
         stream.didReceive(data: data,
                           response: dataTask.response as? HTTPURLResponse)
     }
 
-    internal func urlSession(_: URLSession,
-                             task: URLSessionTask,
-                             didCompleteWithError error: Error?)
+    func urlSession(_: URLSession,
+                    task: URLSessionTask,
+                    didCompleteWithError error: Error?)
     {
-        guard let stream = self.stream(for: task) else {
+        guard let stream = stream(for: task) else {
             return
         }
         stream.didComplete(with: error, response: task.response as? HTTPURLResponse)
@@ -42,7 +42,7 @@ internal final class NetworkSessionDelegate: NSObject, URLSessionDataDelegate {
                     didReceive response: URLResponse,
                     completionHandler: @escaping (URLSession.ResponseDisposition) -> Void)
     {
-        guard let stream = self.stream(for: dataTask) else {
+        guard let stream = stream(for: dataTask) else {
             return
         }
         stream.didReceive(response: response as? HTTPURLResponse)

AudioStreaming/Core/Network/NetworkingClient.swift

@@ -13,12 +13,15 @@ enum DataStreamError: Error {
 public enum NetworkError: Error, Equatable {
     case failure(Error)
     case serverError
+    case missingData
     public static func == (lhs: NetworkError, rhs: NetworkError) -> Bool {
         switch (lhs, rhs) {
         case (.failure, failure):
             return true
         case (.serverError, .serverError):
             return true
+        case (.missingData, .missingData):
+            return true
         default:
             return false
         }
@@ -41,7 +44,7 @@ extension URLSessionConfiguration {
     }
 }
 
-internal final class NetworkingClient {
+final class NetworkingClient {
     let session: URLSession
     weak var delegate: NetworkSessionDelegate?
     let networkQueue: DispatchQueue
@@ -49,9 +52,9 @@ internal final class NetworkingClient {
     var tasksLock = UnfairLock()
     var tasks = BiMap<URLSessionTask, NetworkDataStream>()
 
-    internal init(configuration: URLSessionConfiguration = .networkingConfiguration,
-                  delegate: NetworkSessionDelegate = NetworkSessionDelegate(),
-                  networkQueue: DispatchQueue = DispatchQueue(label: "audio.streaming.session.network.queue"))
+    init(configuration: URLSessionConfiguration = .networkingConfiguration,
+         delegate: NetworkSessionDelegate = NetworkSessionDelegate(),
+         networkQueue: DispatchQueue = DispatchQueue(label: "audio.streaming.session.network.queue"))
     {
         let delegateQueue = operationQueue(underlyingQueue: networkQueue)
         let session = URLSession(configuration: configuration, delegate: delegate, delegateQueue: delegateQueue)
@@ -67,22 +70,38 @@ internal final class NetworkingClient {
 
     /// Creates a data stream for the given `URLRequest`
     /// - parameter request: A `URLRequest` to be used for the data stream
-    internal func stream(request: URLRequest) -> NetworkDataStream {
+    func stream(request: URLRequest) -> NetworkDataStream {
         let stream = NetworkDataStream(id: UUID(), underlyingQueue: networkQueue)
         setupRequest(stream, request: request)
         return stream
     }
 
-    internal func remove(task: NetworkDataStream) {
-        tasksLock.lock(); defer { tasksLock.unlock() }
-        if !tasks.isEmpty {
-            tasks[task] = nil
+    func remove(task: NetworkDataStream) {
+        tasksLock.withLock {
+            if !tasks.isEmpty {
+                tasks[task] = nil
+            }
         }
     }
 
+    @discardableResult
+    func task(request: URLRequest, completion: @escaping (Result<Data, Error>) -> Void) -> URLSessionDataTask {
+        let task = session.dataTask(with: request) { data, _, error in
+            if let error {
+                completion(Result<Data, Error>.failure(error))
+                return
+            }
+            if let data {
+                completion(Result<Data, Error>.success(data))
+            }
+        }
+        task.resume()
+        return task
+    }
+
     // MARK: Private
 
-    /// Schedules the given `NetworkDataStream` to be performed immediatelly
+    /// Schedules the given `NetworkDataStream` to be performed immediately
     /// - parameter stream: The `NetworkDataStream` object to be performed
     /// - parameter request: The `URLRequest` for the `stream`
     private func setupRequest(_ stream: NetworkDataStream, request: URLRequest) {
@@ -96,14 +115,16 @@ internal final class NetworkingClient {
 // MARK: StreamTaskProvider conformance
 
 extension NetworkingClient: StreamTaskProvider {
-    internal func dataStream(for request: URLSessionTask) -> NetworkDataStream? {
-        tasksLock.lock(); defer { tasksLock.unlock() }
-        return tasks[request] ?? nil
+    func dataStream(for request: URLSessionTask) -> NetworkDataStream? {
+        tasksLock.withLock {
+            tasks[request] ?? nil
+        }
     }
 
-    internal func sessionTask(for stream: NetworkDataStream) -> URLSessionTask? {
-        tasksLock.lock(); defer { tasksLock.unlock() }
-        return tasks[stream] ?? nil
+    func sessionTask(for stream: NetworkDataStream) -> URLSessionTask? {
+        tasksLock.withLock {
+            tasks[stream] ?? nil
+        }
     }
 }
 

AudioStreaming/Core/Structures/BiMap.swift

@@ -5,7 +5,7 @@
 
 import Foundation
 
-/// A convenient type that holds tasks in a two-way manner, such as `URLSessionTask` to `NetworkDataStream` and reverved
+/// A convenient type that holds tasks in a two-way manner, such as `URLSessionTask` to `NetworkDataStream` and reversed
 struct BiMap<Left, Right> where Left: Hashable, Right: Hashable {
     private var leftToRight: [Left: Right] = [:]
     private var rightToLeft: [Right: Left] = [:]

AudioStreaming/Streaming/Audio Entry/AudioEntry.swift

@@ -7,11 +7,11 @@ import AudioToolbox
 import AVFoundation
 
 public struct AudioEntryId: Equatable {
-    internal var unique = UUID()
+    var unique = UUID()
     public var id: String
 }
 
-internal class AudioEntry {
+class AudioEntry {
     private let estimationMinPackets = 2
     private let estimationMinPacketsPreferred = 64
 
@@ -22,9 +22,7 @@ internal class AudioEntry {
     let id: AudioEntryId
 
     /// The sample rate from the `audioStreamFormat`
-    var sampleRate: Float {
-        Float(audioStreamFormat.mSampleRate)
-    }
+    var sampleRate: Float
 
     var audioFileHint: AudioFileTypeID {
         source.audioFileHint
@@ -49,11 +47,9 @@ internal class AudioEntry {
     private(set) var framesState: EntryFramesState
     private(set) var processedPacketsState: ProcessedPacketsState
 
-    var packetDuration: Double {
-        return Double(audioStreamFormat.mFramesPerPacket) / Double(sampleRate)
-    }
+    var packetDuration: Double
 
-    private var avaragePacketByteSize: Double {
+    private var averagePacketByteSize: Double {
         let packets = processedPacketsState
         guard !packets.isEmpty else { return 0 }
         return Double(packets.sizeTotal / packets.count)
@@ -72,6 +68,8 @@ internal class AudioEntry {
         processedPacketsState = ProcessedPacketsState()
         framesState = EntryFramesState()
         audioStreamState = AudioStreamState()
+        sampleRate = 0
+        packetDuration = 0
     }
 
     func close() {
@@ -94,7 +92,9 @@ internal class AudioEntry {
 
     func reset() {
         lock.lock(); defer { lock.unlock() }
-        framesState = EntryFramesState()
+        framesState.played = 0
+        framesState.queued = 0
+        framesState.lastFrameQueued = -1
     }
 
     func has(same source: CoreAudioStreamSource) -> Bool {
@@ -109,7 +109,7 @@ internal class AudioEntry {
             if packetsCount > estimationMinPacketsPreferred ||
                 (audioStreamFormat.mBytesPerFrame == 0 && packetsCount > estimationMinPackets)
             {
-                return avaragePacketByteSize / packetDuration * 8
+                return averagePacketByteSize / packetDuration * 8
             }
         }
         return (Double(audioStreamFormat.mBytesPerFrame) * audioStreamFormat.mSampleRate) * 8
@@ -151,12 +151,12 @@ extension AudioEntry: AudioStreamSourceDelegate {
         delegate?.dataAvailable(source: source, data: data)
     }
 
-    func errorOccured(source: CoreAudioStreamSource, error: Error) {
-        delegate?.errorOccured(source: source, error: error)
+    func errorOccurred(source: CoreAudioStreamSource, error: Error) {
+        delegate?.errorOccurred(source: source, error: error)
     }
 
-    func endOfFileOccured(source: CoreAudioStreamSource) {
-        delegate?.endOfFileOccured(source: source)
+    func endOfFileOccurred(source: CoreAudioStreamSource) {
+        delegate?.endOfFileOccurred(source: source)
     }
 
     func metadataReceived(data: [String: String]) {

AudioStreaming/Streaming/Audio Entry/Models/SeekRequest.swift

@@ -8,6 +8,6 @@ import Foundation
 final class SeekRequest {
     let lock = UnfairLock()
     var requested: Bool = false
-    var version = Protected<Int>(0)
+    var version = Atomic<Int>(0)
     var time: Double = 0
 }

AudioStreaming/Streaming/Audio Source/AudioStreamSource.swift

@@ -10,9 +10,9 @@ protocol AudioStreamSourceDelegate: AnyObject {
     /// Indicates that there's data available
     func dataAvailable(source: CoreAudioStreamSource, data: Data)
     /// Indicates an error occurred
-    func errorOccured(source: CoreAudioStreamSource, error: Error)
+    func errorOccurred(source: CoreAudioStreamSource, error: Error)
     /// Indicates end of file has occurred
-    func endOfFileOccured(source: CoreAudioStreamSource)
+    func endOfFileOccurred(source: CoreAudioStreamSource)
     /// Indicates metadata read from stream
     func metadataReceived(data: [String: String])
 }

AudioStreaming/Streaming/Audio Source/FileAudioSource.swift

@@ -3,6 +3,7 @@
 //  Copyright © 2020 Decimal. All rights reserved.
 //
 
+import Foundation
 import AVFoundation
 
 final class FileAudioSource: NSObject, CoreAudioStreamSource {
@@ -17,6 +18,12 @@ final class FileAudioSource: NSObject, CoreAudioStreamSource {
         audioFileType(fileExtension: url.pathExtension)
     }
 
+    private var isMp4: Bool {
+        audioFileHint == kAudioFileM4AType || audioFileHint == kAudioFileMPEG4Type
+    }
+
+    private var mp4IsAlreadyOptimized: Bool = false
+
     private var seekOffset: Int
 
     private let url: URL
@@ -26,6 +33,8 @@ final class FileAudioSource: NSObject, CoreAudioStreamSource {
     private var buffer: UnsafeMutablePointer<UInt8>
     private var inputStream: InputStream?
 
+    private var mp4Restructure: Mp4Restructure
+
     init(url: URL,
          fileManager: FileManager = .default,
          underlyingQueue: DispatchQueue,
@@ -35,6 +44,7 @@ final class FileAudioSource: NSObject, CoreAudioStreamSource {
         self.underlyingQueue = underlyingQueue
         self.fileManager = fileManager
         self.readSize = readSize
+        self.mp4Restructure = Mp4Restructure()
         buffer = UnsafeMutablePointer.uint8pointer(of: readSize)
         seekOffset = 0
         position = 0
@@ -43,6 +53,7 @@ final class FileAudioSource: NSObject, CoreAudioStreamSource {
 
     deinit {
         buffer.deallocate()
+        mp4Restructure.clear()
     }
 
     func close() {
@@ -54,12 +65,8 @@ final class FileAudioSource: NSObject, CoreAudioStreamSource {
         inputStream.delegate = nil
     }
 
-    func suspend() {
-        guard let inputStream = inputStream else {
-            return
-        }
-        CFReadStreamSetDispatchQueue(inputStream, nil)
-    }
+    // no-op
+    func suspend() {}
 
     func resume() {
         guard let inputStream = inputStream else {
@@ -69,40 +76,38 @@ final class FileAudioSource: NSObject, CoreAudioStreamSource {
     }
 
     func seek(at offset: Int) {
-        close()
-
         do {
             try performOpen(seek: offset)
         } catch {
-            delegate?.errorOccured(source: self, error: error)
+            delegate?.errorOccurred(source: self, error: error)
         }
     }
 
     private func performOpen(seek seekOffset: Int) throws {
-        guard let inputStream = InputStream(url: url) else {
-            throw AudioSystemError.playerStartError
-        }
-        self.inputStream = inputStream
-
         var reopened = false
-        let streamStatus = inputStream.streamStatus
-        if streamStatus == .notOpen || streamStatus == .error {
+        let status = inputStream?.streamStatus ?? .closed
+        if status == .atEnd || status == .closed || status == .error {
             reopened = true
             close()
-            open(inputStream: inputStream)
+            try open()
         }
 
-        let attributes = try fileManager.attributesOfItem(atPath: url.path)
-        length = (attributes[.size] as? Int) ?? 0
+        var offset = seekOffset
+        if isMp4, mp4Restructure.dataOptimized {
+            offset = mp4Restructure.seekAdjusted(offset: seekOffset)
+        }
 
-        if inputStream.setProperty(seekOffset, forKey: .fileCurrentOffsetKey) {
-            position = seekOffset
+        if inputStream?.setProperty(offset, forKey: .fileCurrentOffsetKey) == true {
+            position = offset
         } else {
             position = 0
         }
+
         if !reopened {
-            if inputStream.hasBytesAvailable {
-                dataAvailable()
+            underlyingQueue.async { [weak self] in
+                if self?.inputStream?.hasBytesAvailable == true {
+                    self?.dataAvailable()
+                }
             }
         }
     }
@@ -112,17 +117,62 @@ final class FileAudioSource: NSObject, CoreAudioStreamSource {
         let read = inputStream.read(buffer, maxLength: readSize)
         if read > 0 {
             let data = Data(bytes: buffer, count: read)
-            delegate?.dataAvailable(source: self, data: data)
+            if isMp4, !mp4IsAlreadyOptimized {
+                if !mp4Restructure.dataOptimized {
+                    do {
+                        if let mp4OptimizeInfo = try mp4Restructure.checkIsOptimized(data: data) {
+                            try performMp4Restructure(inputStream: inputStream, mp4OptimizeInfo: mp4OptimizeInfo)
+                        } else {
+                            mp4IsAlreadyOptimized = true
+                            delegate?.dataAvailable(source: self, data: data)
+                        }
+                    } catch {
+                        delegate?.errorOccurred(source: self, error: error)
+                    }
+                } else {
+                    delegate?.dataAvailable(source: self, data: data)
+                }
+            } else {
+                delegate?.dataAvailable(source: self, data: data)
+            }
             position += read
         } else {
             position += getCurrentOffsetFromStream()
         }
     }
 
-    private func open(inputStream: InputStream) {
+    func performMp4Restructure(inputStream: InputStream, mp4OptimizeInfo: Mp4OptimizeInfo) throws {
+        let offsetAccepted = inputStream.setProperty(mp4OptimizeInfo.moovOffset, forKey: .fileCurrentOffsetKey)
+        if offsetAccepted {
+            let moovDataBuffer = UnsafeMutablePointer.uint8pointer(of: mp4OptimizeInfo.moovSize)
+            defer { moovDataBuffer.deallocate() }
+            let moovRead = inputStream.read(moovDataBuffer, maxLength: mp4OptimizeInfo.moovSize)
+            if moovRead > 0 {
+                let data = Data(bytes: moovDataBuffer, count: moovRead)
+                let moovData = try mp4Restructure.restructureMoov(data: data)
+                delegate?.dataAvailable(source: self, data: moovData.initialData)
+                if !inputStream.setProperty(moovData.mdatOffset, forKey: .fileCurrentOffsetKey) {
+                    delegate?.errorOccurred(source: self, error: AudioSystemError.playerStartError)
+                }
+            } else {
+                delegate?.errorOccurred(source: self, error: AudioSystemError.playerStartError)
+            }
+        } else {
+            delegate?.errorOccurred(source: self, error: inputStream.streamError ?? AudioSystemError.playerStartError)
+        }
+    }
+
+    private func open() throws {
+        guard let inputStream = InputStream(url: url) else {
+            throw AudioSystemError.playerStartError
+        }
+        self.inputStream = inputStream
         CFReadStreamSetDispatchQueue(inputStream, underlyingQueue)
         inputStream.delegate = self
         inputStream.open()
+
+        let attributes = try fileManager.attributesOfItem(atPath: url.path)
+        length = (attributes[.size] as? Int) ?? 0
     }
 
     private func getCurrentOffsetFromStream() -> Int {
@@ -139,11 +189,9 @@ extension FileAudioSource: StreamDelegate {
         case .hasBytesAvailable:
             dataAvailable()
         case .endEncountered:
-            delegate?.endOfFileOccured(source: self)
+            delegate?.endOfFileOccurred(source: self)
         case .errorOccurred:
-            delegate?.errorOccured(source: self, error: AudioPlayerError.codecError)
-        case .endEncountered:
-            delegate?.endOfFileOccured(source: self)
+            delegate?.errorOccurred(source: self, error: AudioPlayerError.codecError)
         default:
             break
         }

AudioStreaming/Streaming/Audio Source/Mp4/Mp4Restructure.swift

@@ -0,0 +1,280 @@
+//
+//  Created by Dimitrios Chatzieleftheriou on 20/03/2024.
+//  Copyright © 2020 Decimal. All rights reserved.
+//
+
+import Foundation
+
+struct MP4Atom: Equatable, CustomDebugStringConvertible {
+    let type: Int
+    let size: Int
+    let offset: Int
+    var data: Data?
+
+    var isFreeSpaceAtom: Bool {
+        type == Atoms.free || type == Atoms.skip || type == Atoms.wide
+    }
+
+    var debugDescription: String {
+        "[Atom][size: \(size))][type: \(Atoms.integerToFourCC(type) ?? "")][offset: \(offset)]"
+    }
+}
+
+struct Mp4OptimizeInfo: Equatable {
+    let moovOffset: Int
+    let moovSize: Int
+}
+
+/// These are some atoms, helpful for audio mp4
+enum Atoms {
+    static var ftyp: Int { fourCcToInt("ftyp") }
+    static var moov: Int { fourCcToInt("moov") }
+    static var mdat: Int { fourCcToInt("mdat") }
+    static var free: Int { fourCcToInt("free") }
+    static var skip: Int { fourCcToInt("skip") }
+    static var wide: Int { fourCcToInt("wide") }
+
+    static var cmov: Int { fourCcToInt("cmov") }
+    static var stco: Int { fourCcToInt("stco") }
+    static var co64: Int { fourCcToInt("c064") }
+
+    static var atomPreampleSize: Int = 8
+
+    static func fourCcToInt(_ fourCc: String) -> Int {
+        let data = fourCc.data(using: .ascii)!
+        return Int(bigEndian: Int(data: data))
+    }
+
+    static func integerToFourCC(_ value: Int) -> String? {
+        guard value >= 0, value <= 0xFFFF_FFFF else {
+            return nil // Integer value out of range
+        }
+
+        var bytes: [UInt8] = []
+        bytes.append(UInt8((value >> 24) & 0xFF))
+        bytes.append(UInt8((value >> 16) & 0xFF))
+        bytes.append(UInt8((value >> 8) & 0xFF))
+        bytes.append(UInt8(value & 0xFF))
+
+        let data = Data(bytes)
+        return String(data: data, encoding: .ascii)
+    }
+}
+
+enum Mp4RestructureError: Error {
+    case unableToRestructureData
+    case missingMoovData
+    case invalidMoovAtom
+    case invalidAtomSize
+    case invalidAtomType
+    case invalidOffset
+    case missingMdatAtom
+    case missingMoovAtom
+    case compressedAtomNotSupported
+    case nonOptimizedMp4AndServerCannotSeek
+    case networkError(Error)
+}
+
+final class Mp4Restructure {
+
+    private var atomOffset: Int = 0
+    private var atoms: [MP4Atom] = []
+    private var ftyp: MP4Atom?
+    private var foundMoov = false
+    private var foundMdat = false
+
+    private(set) var dataOptimized: Bool = false
+
+    private var moovAtomSize: Int = 0
+
+    func clear() {
+        atomOffset = 0
+        atoms = []
+        ftyp = nil
+        foundMdat = false
+        foundMoov = false
+    }
+
+    /// Adjust the seekOffset of subtracting the moovAtomSize
+    /// - Parameter offset: A byte offset
+    /// - Returns: An adjusted byte offset
+    func seekAdjusted(offset: Int) -> Int {
+        offset - moovAtomSize
+    }
+
+    func restructureMoov(data: Data) throws -> (initialData: Data, mdatOffset: Int) {
+        let (atomData, moovSize) = try doRestructureMoov(data: data)
+        moovAtomSize = moovSize
+        guard let mdatIndex = atoms.firstIndex(where: { $0.type == Atoms.mdat }) else {
+            throw Mp4RestructureError.missingMdatAtom
+        }
+        let mdatAtom = atoms[mdatIndex]
+        let atoms = Array(atoms[..<mdatIndex])
+        let dataOfAtomsBefore = atoms.filter { $0.data != nil }.compactMap(\.data)
+        let accumulatedInitialData = dataOfAtomsBefore.reduce(into: Data()) { partialResult, data in
+            partialResult.append(data)
+        }
+        let initialData = accumulatedInitialData + atomData
+        let mdatOffset: Int
+        if let ftyp = ftyp {
+            mdatOffset = ftyp.offset + ftyp.size
+        } else {
+            let freeSpaceAtoms = atoms.filter(\.isFreeSpaceAtom)
+            let freeSpaceSize = freeSpaceAtoms.reduce(into: 0) { partialResult, atom in
+                partialResult += atom.size
+            }
+            mdatOffset = mdatAtom.offset - freeSpaceSize
+        }
+        dataOptimized = true
+        return (initialData, mdatOffset)
+    }
+
+    /// Returns `nil` if the data is optimized otherwise `Mp4OptimizeInfo`
+    func checkIsOptimized(data: Data) throws -> Mp4OptimizeInfo? {
+        while atomOffset < UInt64(data.count) {
+            var atomSize = try Int(getInteger(data: data, offset: atomOffset) as UInt32)
+            let atomType = try Int(getInteger(data: data, offset: atomOffset + 4) as UInt32)
+            switch atomType {
+            case Atoms.ftyp:
+                let ftypData = data[Int(atomOffset) ..< atomSize]
+                let ftyp = MP4Atom(type: atomType, size: atomSize, offset: atomOffset, data: ftypData)
+                self.ftyp = ftyp
+                atoms.append(ftyp)
+            case Atoms.mdat:
+                // ref: https://developer.apple.com/documentation/quicktime-file-format/movie_data_atom
+                // This atom can be quite large, and may exceed 2^32 bytes, in which case the size field will be set to 1, 
+                // and the header will contain a 64-bit extended size field.
+                if atomSize == 1 {
+                    atomSize = Int(try getInteger(data: data, offset: atomOffset + 8) as UInt64)
+                }
+                let mdat = MP4Atom(type: atomType, size: atomSize, offset: atomOffset)
+                atoms.append(mdat)
+                foundMdat = true
+            case Atoms.moov:
+                let moov = MP4Atom(type: atomType, size: atomSize, offset: atomOffset)
+                atoms.append(moov)
+                foundMoov = true
+            default:
+                let atom = MP4Atom(type: atomType, size: atomSize, offset: atomOffset)
+                atoms.append(atom)
+            }
+            if ftyp != nil {
+                if foundMoov && !foundMdat {
+                    Logger.debug("🕵️ detected an optimized mp4", category: .generic)
+                    return nil
+                } else if !foundMoov && foundMdat {
+                    Logger.debug("🕵️ detected an non-optimized mp4", category: .generic)
+                    let possibleMoovOffset = Int(atomOffset) + atomSize
+                    return Mp4OptimizeInfo(moovOffset: possibleMoovOffset, moovSize: atomSize)
+                }
+            }
+            atomOffset += atomSize
+        }
+        return nil
+    }
+
+    /// logic taken from qt-faststart.c over at ffmpeg
+    /// https://github.com/FFmpeg/FFmpeg/blob/b47b2c5b912558b639c8542993e1256f9c69e675/tools/qt-faststart.c
+    private func doRestructureMoov(data: Data) throws -> (Data, Int) {
+        var moovAtomSize: Int = 0
+        var moovAtomType: Int = 0
+        var originalData = ByteBuffer(data: data)
+        var offset: Int = 0
+        // do search for moov within the new data
+        while offset < originalData.length {
+            moovAtomSize = Int(try originalData.getInteger() as UInt32)
+            moovAtomType = Int(try originalData.getInteger() as UInt32)
+
+            if moovAtomType == Atoms.moov {
+                break
+            }
+            offset += moovAtomSize
+        }
+
+        // error if we couldn't find an moov type
+        guard moovAtomType == Atoms.moov else {
+            throw Mp4RestructureError.missingMoovAtom
+        }
+
+        originalData.offset = offset
+        var moovAtom = ByteBuffer(size: moovAtomSize)
+        let slicedData: Data = try originalData.readBytes(moovAtom.length)
+        moovAtom.writeBytes(slicedData)
+        moovAtom.rewind()
+
+        if try Int(moovAtom.getInteger(12) as UInt32) == Atoms.cmov {
+            Logger.debug("Compressed moov atom not supported", category: .generic)
+            throw Mp4RestructureError.compressedAtomNotSupported
+        }
+
+        var atomType: Int
+        var atomSize: Int
+
+        // crawl through the atom and restructure offsets
+        while moovAtom.bytesAvailable >= 8 {
+            let atomHead = moovAtom.offset
+            atomType = try Int(moovAtom.getInteger(atomHead + 4) as UInt32)
+
+            if !(atomType == Atoms.stco || atomType == Atoms.co64) {
+                moovAtom.offset += 1
+                continue
+            }
+
+            atomSize = try Int(moovAtom.getInteger(atomHead) as UInt32)
+            if atomSize > moovAtom.bytesAvailable {
+                Logger.debug("aborting due to a bad size on an atom", category: .generic)
+                throw Mp4RestructureError.unableToRestructureData
+            }
+            // we need to skip the offset by `12` which come from the bytes of [size/4][type/4][version/1][flags/3]
+            // more info https://developer.apple.com/documentation/quicktime-file-format/chunk_offset_atom
+            moovAtom.offset = atomHead + 12
+            if moovAtom.bytesAvailable < 4 {
+                Logger.debug("aborting due to a malformed atom", category: .generic)
+                throw Mp4RestructureError.unableToRestructureData
+            }
+
+            // the next integer determines the `Number of entries`
+            // https://developer.apple.com/documentation/quicktime-file-format/chunk_offset_atom/number_of_entries
+            let numberOfOffsetEntries = try Int(moovAtom.getInteger() as UInt32)
+            if atomType == Atoms.stco {
+                Logger.debug("🏗️ patching stco atom...", category: .generic)
+                if moovAtom.bytesAvailable < numberOfOffsetEntries * 4 {
+                    Logger.debug("aborting due to bad atom..", category: .generic)
+                    throw Mp4RestructureError.unableToRestructureData
+                }
+
+                for _ in 0 ..< numberOfOffsetEntries {
+                    let currentOffset = try Int(moovAtom.getInteger(moovAtom.offset) as UInt32)
+                    // adjust the offset by adding the size of moov atom
+                    let adjustOffset = currentOffset + moovAtomSize
+
+                    if currentOffset < 0, adjustOffset >= 0 {
+                        throw Mp4RestructureError.unableToRestructureData
+                    }
+                    moovAtom.put(UInt32(adjustOffset).bigEndian)
+                }
+            } else if atomType == Atoms.co64 {
+                Logger.debug("🏗️ patching co64 atom...", category: .generic)
+                if moovAtom.bytesAvailable < numberOfOffsetEntries * 8 {
+                    Logger.debug("aborting due to bad atom..", category: .generic)
+                    throw Mp4RestructureError.unableToRestructureData
+                }
+                for _ in 0 ..< numberOfOffsetEntries {
+                    let currentOffset: Int = try moovAtom.getInteger(moovAtom.offset)
+                    // adjust the offset by adding the size of moov atom
+                    moovAtom.put(currentOffset + moovAtomSize)
+                }
+            }
+        }
+        return (moovAtom.storage, moovAtomSize)
+    }
+
+    func getInteger<T: FixedWidthInteger>(data: Data, offset: Int) throws -> T {
+        let sizeOfInteger = MemoryLayout<T>.size
+        guard sizeOfInteger <= data.count else {
+            throw ByteBuffer.Error.eof
+        }
+        let _offset = offset + sizeOfInteger
+        return T(data: data[_offset - sizeOfInteger ..< _offset]).bigEndian
+    }
+}

AudioStreaming/Streaming/Audio Source/Mp4/RemoteMp4Restructure.swift

@@ -0,0 +1,146 @@
+//
+//  Created by Dimitrios Chatzieleftheriou on 10/03/2024.
+//  Copyright © 2020 Decimal. All rights reserved.
+//
+
+import Foundation
+
+final class RemoteMp4Restructure {
+    struct RestructuredData {
+        var initialData: Data
+        var mdatOffset: Int
+    }
+
+    private var audioData: Data
+
+    private var atomOffset: Int = 0
+    private var atoms: [MP4Atom] = []
+    private var ftyp: MP4Atom?
+    private var foundMoov = false
+    private var foundMdat = false
+
+    private var task: NetworkDataStream?
+
+    private(set) var dataOptimized: Bool = false
+
+    private var moovAtomSize: Int = 0
+
+    private let url: URL
+    private let networking: NetworkingClient
+
+    private let mp4Restructure: Mp4Restructure
+
+    init(url: URL, networking: NetworkingClient, restructure: Mp4Restructure = Mp4Restructure()) {
+        self.url = url
+        self.networking = networking
+        self.audioData = Data()
+        self.mp4Restructure = restructure
+    }
+
+    func clear() {
+        mp4Restructure.clear()
+        audioData = Data()
+        task?.cancel()
+        task = nil
+    }
+
+    /// Adjust the seekOffset of subtracting the moovAtomSize
+    /// - Parameter offset: A byte offset
+    /// - Returns: An adjusted byte offset
+    func seekAdjusted(offset: Int) -> Int {
+        mp4Restructure.seekAdjusted(offset: offset)
+    }
+
+    ///
+    /// Gather audio and parse along the way, if moov atom is found, continue as usual
+    /// if mdat is found before moov:
+    ///  - Get mdat size and make a byte request Range: bytes=mdatAtomSize- for possible moov atom
+    ///  - once the request is complete search for an moov atom and restructure it
+    ///  - finally, make a byte request Range: bytes=mdatOffset- to get the mdat
+    /// Atoms needs to be as following for the AudioFileStreamParse to work
+    /// [ftyp][moov][mdat]
+    ///
+    func optimizeIfNeeded(completion: @escaping (Result<RestructuredData?, Error>) -> Void) {
+        task = networking.stream(request: urlForPartialContent(with: url, offset: 0))
+            .responseStream { [weak self] event in
+                guard let self else { return }
+                switch event {
+                case .response:
+                    break
+                case let .stream(.success(response)):
+                    guard let data = response.data else {
+                        self.audioData = Data()
+                        completion(.failure(Mp4RestructureError.unableToRestructureData))
+                        return
+                    }
+                    self.audioData.append(data)
+                    do {
+                        let value = try self.mp4Restructure.checkIsOptimized(data: self.audioData)
+                        if let value {
+                            guard response.response?.statusCode == 206 else {
+                                Logger.error("⛔️ mp4 error: no moov before mdat and the stream is not seekable", category: .networking)
+                                completion(.failure(Mp4RestructureError.nonOptimizedMp4AndServerCannotSeek))
+                                return
+                            }
+                            // stop request, fetch moov and restructure
+                            self.audioData = Data()
+                            self.task?.cancel()
+                            self.task = nil
+                            self.fetchAndRestructureMoovAtom(offset: value.moovOffset) { result in
+                                switch result {
+                                case let .success(value):
+                                    let data = value.data
+                                    let offset = value.offset
+                                    self.dataOptimized = true
+                                    completion(.success(RestructuredData(initialData: data, mdatOffset: offset)))
+                                case let .failure(error):
+                                    completion(.failure(Mp4RestructureError.networkError(error)))
+                                }
+                            }
+                        } else {
+                            self.audioData = Data()
+                            self.task?.cancel()
+                            self.task = nil
+                            completion(.success(nil))
+                        }
+                    } catch {
+                        completion(.failure(Mp4RestructureError.invalidAtomSize))
+                    }
+                case let .stream(.failure(error)):
+                    completion(.failure(Mp4RestructureError.networkError(error)))
+                case .complete:
+                    break
+                }
+            }
+        task?.resume()
+    }
+
+    func fetchAndRestructureMoovAtom(offset: Int, completion: @escaping (Result<(data: Data, offset: Int), Error>) -> Void) {
+        networking.task(request: urlForPartialContent(with: url, offset: offset)) { [weak self] result in
+            guard let self else { return }
+            switch result {
+            case let .success(data):
+                do {
+                    let (initialData, mdatOffset) = try self.mp4Restructure.restructureMoov(data: data)
+                    completion(.success((initialData, mdatOffset)))
+                } catch {
+                    completion(.failure(error))
+                }
+            case let .failure(failure):
+                completion(.failure(Mp4RestructureError.networkError(failure)))
+            }
+        }
+    }
+
+    private func urlForPartialContent(with url: URL, offset: Int) -> URLRequest {
+        var urlRequest = URLRequest(url: url)
+        urlRequest.networkServiceType = .avStreaming
+        urlRequest.cachePolicy = .reloadIgnoringLocalCacheData
+        urlRequest.timeoutInterval = 60
+
+        urlRequest.addValue("*/*", forHTTPHeaderField: "Accept")
+        urlRequest.addValue("identity", forHTTPHeaderField: "Accept-Encoding")
+        urlRequest.addValue("bytes=\(offset)-", forHTTPHeaderField: "Range")
+        return urlRequest
+    }
+}

AudioStreaming/Streaming/Audio Source/RemoteAudioSource.swift

@@ -8,6 +8,10 @@ import AVFoundation
 import Foundation
 import Network
 
+enum RemoteAudioSourceError: Error {
+    case mp4NotSeekable
+}
+
 public class RemoteAudioSource: AudioStreamSource {
     weak var delegate: AudioStreamSourceDelegate?
 
@@ -31,23 +35,25 @@ public class RemoteAudioSource: AudioStreamSource {
     private var seekOffset: Int
     private var supportsSeek: Bool
 
-    internal var metadataStreamProcessor: MetadataStreamSource
+    var metadataStreamProcessor: MetadataStreamSource
 
     private var shouldTryParsingIcycastHeaders: Bool = false
     private let icycastHeadersProcessor: IcycastHeadersProcessor
 
-    internal var audioFileHint: AudioFileTypeID {
+    var audioFileHint: AudioFileTypeID {
         guard let output = parsedHeaderOutput, output.typeId != 0 else {
             return audioFileType(fileExtension: url.pathExtension)
         }
         return output.typeId
     }
 
-    internal let underlyingQueue: DispatchQueue
-    internal let streamOperationQueue: OperationQueue
-    internal let netStatusService: NetStatusProvider
-    internal var waitingForNetwork = false
-    internal let retrierTimeout: Retrier
+    private let mp4Restructure: RemoteMp4Restructure
+
+    let underlyingQueue: DispatchQueue
+    let streamOperationQueue: OperationQueue
+    let netStatusService: NetStatusProvider
+    var waitingForNetwork = false
+    let retrierTimeout: Retrier
 
     init(networking: NetworkingClient,
          metadataStreamSource: MetadataStreamSource,
@@ -74,6 +80,7 @@ public class RemoteAudioSource: AudioStreamSource {
         streamOperationQueue.isSuspended = true
         streamOperationQueue.name = "remote.audio.source.data.stream.queue"
         retrierTimeout = retrier
+        mp4Restructure = RemoteMp4Restructure(url: url, networking: networkingClient)
         startNetworkService()
     }
 
@@ -86,12 +93,12 @@ public class RemoteAudioSource: AudioStreamSource {
         let metadataProcessor = MetadataStreamProcessor(parser: metadataParser.eraseToAnyParser())
         let netStatusProvider = NetStatusService(network: NWPathMonitor())
         let icyheaderProcessor = IcycastHeadersProcessor()
-        let retrierTimout = Retrier(interval: .seconds(1), maxInterval: 5, underlyingQueue: nil)
+        let retrierTimeout = Retrier(interval: .seconds(1), maxInterval: 5, underlyingQueue: nil)
         self.init(networking: networking,
                   metadataStreamSource: metadataProcessor,
                   icycastHeadersProcessor: icyheaderProcessor,
                   netStatusProvider: netStatusProvider,
-                  retrier: retrierTimout,
+                  retrier: retrierTimeout,
                   url: url,
                   underlyingQueue: underlyingQueue,
                   httpHeaders: httpHeaders)
@@ -109,8 +116,7 @@ public class RemoteAudioSource: AudioStreamSource {
 
     func close() {
         retrierTimeout.cancel()
-        netStatusService.stop()
-        streamOperationQueue.isSuspended = true
+        streamOperationQueue.isSuspended = false
         streamOperationQueue.cancelAllOperations()
         if let streamTask = streamRequest {
             streamTask.cancel()
@@ -129,6 +135,7 @@ public class RemoteAudioSource: AudioStreamSource {
             return
         }
 
+        mp4Restructure.clear()
         retrierTimeout.cancel()
         metadataStreamProcessor.reset()
         icycastHeadersProcessor.reset()
@@ -138,12 +145,10 @@ public class RemoteAudioSource: AudioStreamSource {
     }
 
     func suspend() {
-        streamRequest?.suspend()
         streamOperationQueue.isSuspended = true
     }
 
     func resume() {
-        streamRequest?.resume()
         streamOperationQueue.isSuspended = false
     }
 
@@ -154,26 +159,79 @@ public class RemoteAudioSource: AudioStreamSource {
             guard let self = self else { return }
             guard connection.isConnected else { return }
             if self.waitingForNetwork {
+                self.seek(at: self.supportsSeek ? self.position : 0)
                 self.waitingForNetwork = false
-                self.seek(at: self.position)
             }
         }
     }
 
     private func performOpen(seek seekOffset: Int) {
-        let urlRequest = buildUrlRequest(with: url, seekIfNeeded: seekOffset)
+        if seekOffset == 0 {
+            initialRequest { [weak self] in
+                guard let self else { return }
+                if self.parsedHeaderOutput?.isMp4 == true {
+                    self.handleMp4Files()
+                } else {
+                    self.doPerfomOpen(seek: 0)
+                }
+            }
+        } else {
+            if mp4Restructure.dataOptimized {
+                let adjustedOffset = mp4Restructure.seekAdjusted(offset: seekOffset)
+                doPerfomOpen(seek: adjustedOffset)
+            } else {
+                doPerfomOpen(seek: seekOffset)
+            }
+        }
+    }
 
-        let request = networkingClient.stream(request: urlRequest)
+    private func doPerfomOpen(seek seekOffset: Int) {
+        let urlRequest = buildUrlRequest(with: url, seekIfNeeded: seekOffset)
+        streamRequest = networkingClient.stream(request: urlRequest)
             .responseStream { [weak self] event in
                 guard let self = self else { return }
                 self.handleResponse(event: event)
             }
             .resume()
 
-        streamRequest = request
         metadataStreamProcessor.delegate = self
     }
 
+    private func initialRequest(completion: @escaping () -> Void) {
+        let urlRequest = fetchUrlForPartialContent(with: url)
+        let task: NetworkDataStream = networkingClient.stream(request: urlRequest)
+        task.responseStream { [weak self] event in
+            switch event {
+            case let .response(urlResponse):
+                self?.parseResponseHeader(response: urlResponse)
+                task.cancel()
+                completion()
+            default:
+                break
+            }
+        }.resume()
+    }
+
+    private func handleMp4Files() {
+        mp4Restructure.optimizeIfNeeded { [weak self] result in
+            guard let self else { return }
+            switch result {
+            case let .success(value):
+                if let value {
+                    self.addStreamOperation {
+                        let audioCount = self.processAudio(data: value.initialData)
+                        self.relativePosition += audioCount
+                    }
+                    self.doPerfomOpen(seek: value.mdatOffset)
+                } else {
+                    self.doPerfomOpen(seek: 0)
+                }
+            case let .failure(failure):
+                self.delegate?.errorOccurred(source: self, error: failure)
+            }
+        }
+    }
+
     // MARK: - Network Handle Methods
 
     private func handleResponse(event: NetworkDataStream.ResponseEvent) {
@@ -181,65 +239,67 @@ public class RemoteAudioSource: AudioStreamSource {
         case let .response(urlResponse):
             parseResponseHeader(response: urlResponse)
             streamOperationQueue.isSuspended = false
-        case let .stream(event):
-            handleStreamEvent(event: event)
+        case let .stream(.success(response)):
+            handleSuccessfulStreamEvent(response: response)
+        case let .stream(.failure(error)):
+            handleFailedStreamEvent(error: error)
         case let .complete(event):
             if let error = event.error {
-                delegate?.errorOccured(source: self, error: error)
+                delegate?.errorOccurred(source: self, error: error)
             } else {
                 addCompletionOperation { [weak self] in
                     guard let self = self else { return }
-                    self.delegate?.endOfFileOccured(source: self)
+                    self.delegate?.endOfFileOccurred(source: self)
                 }
             }
         }
     }
 
-    private func handleStreamEvent(event: NetworkDataStream.StreamResult) {
-        switch event {
-        case let .success(value):
-            if let audioData = value.data {
-                addStreamOperation { [weak self] in
-                    guard let self = self else { return }
-                    if self.shouldTryParsingIcycastHeaders {
-                        let (header, extractedAudio) = self.icycastHeadersProcessor.proccess(data: audioData)
-                        if let header = header {
-                            self.shouldTryParsingIcycastHeaders = false
-                            let parser = IcycastHeaderParser()
-                            self.parsedHeaderOutput = parser.parse(input: header)
-                            if let metadataStep = self.parsedHeaderOutput?.metadataStep {
-                                self.metadataStreamProcessor.metadataAvailable(step: metadataStep)
-                            }
-
-                            let audioCount = self.processAudio(data: extractedAudio)
-                            self.relativePosition += audioCount
-                            return
-                        }
+    private func handleSuccessfulStreamEvent(response: NetworkDataStream.Response) {
+        guard let audioData = response.data else {
+            delegate?.errorOccurred(source: self, error: NetworkError.missingData)
+            return
+        }
+        addStreamOperation { [weak self] in
+            guard let self = self else { return }
+            if self.shouldTryParsingIcycastHeaders {
+                let (header, extractedAudio) = self.icycastHeadersProcessor.process(data: audioData)
+                if let header = header {
+                    self.shouldTryParsingIcycastHeaders = false
+                    let parser = IcycastHeaderParser()
+                    self.parsedHeaderOutput = parser.parse(input: header)
+                    if let metadataStep = self.parsedHeaderOutput?.metadataStep {
+                        self.metadataStreamProcessor.metadataAvailable(step: metadataStep)
                     }
-                    let audioCount = self.processAudio(data: audioData)
-                    self.relativePosition += audioCount
                 }
-            }
-        case .failure:
-            if !netStatusService.isConnected {
-                waitingForNetwork = true
+                let audioCount = self.processAudio(data: extractedAudio)
+                self.relativePosition += audioCount
                 return
             }
-            waitingForNetwork = false
-            retryOnError()
+            let audioCount = self.processAudio(data: audioData)
+            self.relativePosition += audioCount
         }
     }
 
+    private func handleFailedStreamEvent(error _: Error) {
+        if !netStatusService.isConnected {
+            waitingForNetwork = true
+            return
+        }
+        waitingForNetwork = false
+        retryOnError()
+    }
+
     /// Processing audio data, extracting metadata if needed.
     /// - Parameter data: The audio to be processed
     /// - Returns: An `Int` value representing the amount of audio data bytes.
     private func processAudio(data: Data) -> Int {
-        if self.metadataStreamProcessor.canProccessMetadata {
-            let extractedAudioData = self.metadataStreamProcessor.proccessMetadata(data: data)
-            self.delegate?.dataAvailable(source: self, data: extractedAudioData)
+        if metadataStreamProcessor.canProcessMetadata {
+            let extractedAudioData = metadataStreamProcessor.processMetadata(data: data)
+            delegate?.dataAvailable(source: self, data: extractedAudioData)
             return extractedAudioData.count
         } else {
-            self.delegate?.dataAvailable(source: self, data: data)
+            delegate?.dataAvailable(source: self, data: data)
             return data.count
         }
     }
@@ -256,11 +316,13 @@ public class RemoteAudioSource: AudioStreamSource {
             return
         }
 
-        if let acceptRanges = parser.value(forHTTPHeaderField: HeaderField.acceptRanges, in: response) {
+        if httpStatusCode == 206 {
+            supportsSeek = true
+        } else if let acceptRanges = parser.value(forHTTPHeaderField: HeaderField.acceptRanges, in: response) {
             supportsSeek = acceptRanges != "none"
         }
 
-        // check to see if we have metadata to proccess
+        // check to see if we have metadata to process
         if let metadataStep = parsedHeaderOutput?.metadataStep {
             metadataStreamProcessor.metadataAvailable(step: metadataStep)
         }
@@ -271,9 +333,12 @@ public class RemoteAudioSource: AudioStreamSource {
         // check for error
         if statusCode == 416 { // range not satisfied error
             if length >= 0 { seekOffset = length }
-            delegate?.endOfFileOccured(source: self)
+            delegate?.endOfFileOccurred(source: self)
         } else if statusCode >= 300 {
-            delegate?.errorOccured(source: self, error: NetworkError.serverError)
+            delegate?.errorOccurred(
+                source: self,
+                error: NetworkError.serverError
+            )
         }
     }
 
@@ -290,16 +355,32 @@ public class RemoteAudioSource: AudioStreamSource {
         urlRequest.addValue("1", forHTTPHeaderField: "Icy-MetaData")
         urlRequest.addValue("identity", forHTTPHeaderField: "Accept-Encoding")
 
-        if supportsSeek && seekOffset > 0 {
+        if supportsSeek, seekOffset > 0 {
             urlRequest.addValue("bytes=\(seekOffset)-", forHTTPHeaderField: "Range")
         }
         return urlRequest
     }
 
+    private func fetchUrlForPartialContent(with url: URL) -> URLRequest {
+        var urlRequest = URLRequest(url: url)
+        urlRequest.networkServiceType = .avStreaming
+        urlRequest.cachePolicy = .reloadIgnoringLocalCacheData
+        urlRequest.timeoutInterval = 60
+
+        for header in additionalRequestHeaders {
+            urlRequest.addValue(header.value, forHTTPHeaderField: header.key)
+        }
+        urlRequest.addValue("*/*", forHTTPHeaderField: "Accept")
+        urlRequest.addValue("1", forHTTPHeaderField: "Icy-MetaData")
+        urlRequest.addValue("identity", forHTTPHeaderField: "Accept-Encoding")
+        urlRequest.addValue("bytes=0-1", forHTTPHeaderField: "Range")
+        return urlRequest
+    }
+
     private func retryOnError() {
         retrierTimeout.retry { [weak self] in
             guard let self = self else { return }
-            self.seek(at: self.position)
+            self.seek(at: self.supportsSeek ? self.position : 0)
         }
     }
 
@@ -310,6 +391,7 @@ public class RemoteAudioSource: AudioStreamSource {
     /// - Parameter block: A closure to be executed
     private func addStreamOperation(_ block: @escaping () -> Void) {
         let operation = BlockOperation(block: block)
+        operation.qualityOfService = .userInitiated
         streamOperationQueue.addOperation(operation)
     }
 

AudioStreaming/Streaming/AudioPlayer/AudioPlayer.swift

@@ -100,15 +100,13 @@ open class AudioPlayer {
     }
 
     /// An `AVAudioFormat` object for the canonical audio stream
-    private var outputAudioFormat: AVAudioFormat = {
-        AVAudioFormat(commonFormat: .pcmFormatFloat32, sampleRate: 44100.0, channels: 2, interleaved: true)!
-    }()
+    private var outputAudioFormat: AVAudioFormat = .init(commonFormat: .pcmFormatFloat32, sampleRate: 44100.0, channels: 2, interleaved: true)!
 
     /// Keeps track of the player's state before being paused.
     private var stateBeforePaused: InternalState = .initial
 
     /// The underlying `AVAudioEngine` object
-    private let audioEngine = AVAudioEngine()
+    private let audioEngine: AVAudioEngine
     /// An `AVAudioUnit` object that represents the audio player
     private(set) var player = AVAudioUnit()
     /// An `AVAudioUnitTimePitch` that controls the playback rate of the audio engine
@@ -125,7 +123,6 @@ open class AudioPlayer {
     private let playerRenderProcessor: AudioPlayerRenderProcessor
     private let frameFilterProcessor: FrameFilterProcessor
 
-    private let audioReadSource: DispatchTimerSource
     private let serializationQueue: DispatchQueue
     private let sourceQueue: DispatchQueue
 
@@ -135,29 +132,38 @@ open class AudioPlayer {
 
     public init(configuration: AudioPlayerConfiguration = .default) {
         self.configuration = configuration.normalizeValues()
-
+        let engine = AVAudioEngine()
+        audioEngine = engine
         rendererContext = AudioRendererContext(configuration: configuration, outputAudioFormat: outputAudioFormat)
         playerContext = AudioPlayerContext()
         entriesQueue = PlayerQueueEntries()
 
         serializationQueue = DispatchQueue(label: "streaming.core.queue", qos: .userInitiated)
-        sourceQueue = DispatchQueue(label: "source.queue", qos: .userInitiated)
-        audioReadSource = DispatchTimerSource(interval: .milliseconds(200), queue: sourceQueue)
+        sourceQueue = DispatchQueue(label: "source.queue", qos: .default)
 
-        entryProvider = AudioEntryProvider(networkingClient: NetworkingClient(),
-                                           underlyingQueue: sourceQueue,
-                                           outputAudioFormat: outputAudioFormat)
+        entryProvider = AudioEntryProvider(
+            networkingClient: NetworkingClient(),
+            underlyingQueue: sourceQueue,
+            outputAudioFormat: outputAudioFormat
+        )
 
-        fileStreamProcessor = AudioFileStreamProcessor(playerContext: playerContext,
-                                                       rendererContext: rendererContext,
-                                                       outputAudioFormat: outputAudioFormat.basicStreamDescription)
+        fileStreamProcessor = AudioFileStreamProcessor(
+            playerContext: playerContext,
+            rendererContext: rendererContext,
+            outputAudioFormat: outputAudioFormat.basicStreamDescription
+        )
 
-        frameFilterProcessor = FrameFilterProcessor(mixerNode: audioEngine.mainMixerNode)
-
-        playerRenderProcessor = AudioPlayerRenderProcessor(playerContext: playerContext,
-                                                           rendererContext: rendererContext,
-                                                           outputAudioFormat: outputAudioFormat.basicStreamDescription)
+        playerRenderProcessor = AudioPlayerRenderProcessor(
+            playerContext: playerContext,
+            rendererContext: rendererContext,
+            outputAudioFormat: outputAudioFormat.basicStreamDescription
+        )
 
+        frameFilterProcessor = FrameFilterProcessor(
+            mixerNodeProvider: {
+                engine.mainMixerNode
+            }
+        )
         configPlayerContext()
         configPlayerNode()
         setupEngine()
@@ -166,7 +172,6 @@ open class AudioPlayer {
     deinit {
         playerContext.audioPlayingEntry?.close()
         clearQueue()
-        stopReadProccessFromSource()
         rendererContext.clean()
     }
 
@@ -195,14 +200,13 @@ open class AudioPlayer {
             do {
                 try self.startEngineIfNeeded()
             } catch {
-                self.raiseUnxpected(error: .audioSystemError(.engineFailure))
+                self.raiseUnexpected(error: .audioSystemError(.engineFailure))
             }
         }
 
         sourceQueue.async { [weak self] in
             guard let self = self else { return }
             self.processSource()
-            self.startReadProcessFromSourceIfNeeded()
         }
     }
 
@@ -258,7 +262,6 @@ open class AudioPlayer {
     public func stop() {
         guard playerContext.internalState != .stopped else { return }
 
-        stopReadProccessFromSource()
         serializationQueue.sync {
             stopEngine(reason: .userAction)
         }
@@ -289,7 +292,6 @@ open class AudioPlayer {
             serializationQueue.sync {
                 pauseEngine()
             }
-            stopReadProccessFromSource()
             playerContext.audioPlayingEntry?.suspend()
             sourceQueue.async { [weak self] in
                 self?.processSource()
@@ -315,11 +317,10 @@ open class AudioPlayer {
             }
             startPlayer(resetBuffers: false)
         }
-        startReadProcessFromSourceIfNeeded()
     }
 
     /// Seeks the audio to the specified time.
-    /// - Parameter time: A `Double` value specifing the time of the requested seek in seconds
+    /// - Parameter time: A `Double` value specifying the time of the requested seek in seconds
     public func seek(to time: Double) {
         guard let playingEntry = playerContext.audioPlayingEntry else {
             return
@@ -353,7 +354,7 @@ open class AudioPlayer {
     /// - Note: The nodes will be added after the default rate node
     /// - Parameter node: An array of `AVAudioNode` instances
     public func attach(nodes: [AVAudioNode]) {
-        nodes.forEach { node in
+        for node in nodes {
             customAttachedNodes.append(node)
         }
         nodes.forEach(audioEngine.attach)
@@ -375,7 +376,7 @@ open class AudioPlayer {
     /// Detaches the given `AVAudioNode`s from the engine
     /// - Parameter node: An array of `AVAudioNode` instances
     public func detachCustomAttachedNodes() {
-        customAttachedNodes.forEach { node in
+        for node in customAttachedNodes {
             audioEngine.detach(node)
         }
         attachAndConnectDefaultNodes()
@@ -409,7 +410,7 @@ open class AudioPlayer {
             audioEngine.prepare()
             try audioEngine.start()
         } catch {
-            Logger.error("⚠️ error setuping audio engine: %@", category: .generic, args: error.localizedDescription)
+            Logger.error("⚠️ error setting up audio engine: %@", category: .generic, args: error.localizedDescription)
         }
     }
 
@@ -424,7 +425,7 @@ open class AudioPlayer {
                 self.playerRenderProcessor.attachCallback(on: unit, audioFormat: self.outputAudioFormat)
             case let .failure(error):
                 assertionFailure("couldn't create player unit: \(error)")
-                self.raiseUnxpected(error: .audioSystemError(.playerNotFound))
+                self.raiseUnexpected(error: .audioSystemError(.playerNotFound))
             }
         }
     }
@@ -452,12 +453,12 @@ open class AudioPlayer {
         fileStreamProcessor.fileStreamCallback = { [weak self] effect in
             guard let self = self else { return }
             switch effect {
-            case .proccessSource:
+            case .processSource:
                 self.sourceQueue.async {
                     self.processSource()
                 }
             case let .raiseError(error):
-                self.raiseUnxpected(error: error)
+                self.raiseUnexpected(error: error)
             }
         }
     }
@@ -477,7 +478,7 @@ open class AudioPlayer {
             if let first = customAttachedNodes.first {
                 audioEngine.connect(rateNode, to: first, format: nil)
             }
-            for index in 0..<customAttachedNodes.count - 1 {
+            for index in 0 ..< customAttachedNodes.count - 1 {
                 let current = customAttachedNodes[index]
                 let next = customAttachedNodes[index + 1]
                 let format = current.inputFormat(forBus: 0)
@@ -513,6 +514,7 @@ open class AudioPlayer {
     /// Pauses the audio engine and stops the player's hardware
     private func pauseEngine() {
         guard isEngineRunning else { return }
+        audioEngine.reset()
         audioEngine.pause()
         player.auAudioUnit.stopHardware()
         Logger.debug("engine paused ⏸", category: .generic)
@@ -530,24 +532,7 @@ open class AudioPlayer {
         Logger.debug("engine stopped 🛑", category: .generic)
     }
 
-    /// Starts the timer of `audioReadSource` for proccesing the source read stream
-    ///
-    /// This calls `processSource` method every `500 ms`
-    private func startReadProcessFromSourceIfNeeded() {
-        guard audioReadSource.state != .activated else { return }
-        audioReadSource.add { [weak self] in
-            self?.processSource()
-        }
-        audioReadSource.activate()
-    }
-
-    /// Stops and removes the handler from the timer, @see `audioReadSource`
-    private func stopReadProccessFromSource() {
-        audioReadSource.suspend()
-        audioReadSource.removeHandler()
-    }
-
-    /// Starts the audio player, reseting the buffers if requested
+    /// Starts the audio player, resetting the buffers if requested
     ///
     /// - parameter resetBuffers: A `Bool` value indicating if the buffers should be reset, prior starting the player.
     private func startPlayer(resetBuffers: Bool) {
@@ -560,7 +545,7 @@ open class AudioPlayer {
             try player.auAudioUnit.startHardware()
         } catch {
             stopEngine(reason: .error)
-            raiseUnxpected(error: .audioSystemError(.playerStartError))
+            raiseUnexpected(error: .audioSystemError(.playerStartError))
         }
     }
 
@@ -568,7 +553,6 @@ open class AudioPlayer {
     private func processSource() {
         dispatchPrecondition(condition: .onQueue(sourceQueue))
 
-        guard !playerContext.disposedRequested else { return }
         guard playerContext.internalState != .paused else { return }
 
         if playerContext.internalState == .pendingNext {
@@ -577,8 +561,8 @@ open class AudioPlayer {
             setCurrentReading(entry: entry, startPlaying: true, shouldClearQueue: true)
             rendererContext.resetBuffers()
         } else if let playingEntry = playerContext.audioPlayingEntry,
-            playingEntry.seekRequest.requested,
-            playingEntry != playerContext.audioReadingEntry
+                  playingEntry.seekRequest.requested,
+                  playingEntry != playerContext.audioReadingEntry
         {
             playingEntry.audioStreamState.processedDataFormat = false
             playingEntry.reset()
@@ -605,7 +589,6 @@ open class AudioPlayer {
                 setCurrentReading(entry: entry, startPlaying: shouldStartPlaying, shouldClearQueue: false)
             } else if playerContext.audioPlayingEntry == nil {
                 if playerContext.internalState != .stopped {
-                    stopReadProccessFromSource()
                     stopEngine(reason: .eof)
                 }
             }
@@ -621,7 +604,7 @@ open class AudioPlayer {
             playingEntry.seekRequest.lock.unlock()
 
             if originalSeekToTimeRequested, playerContext.audioReadingEntry === playingEntry {
-                proccessSeekTime()
+                processSeekTime()
 
                 let version = playingEntry.seekRequest.version.value
                 if currSeekVersion == version {
@@ -633,7 +616,7 @@ open class AudioPlayer {
         }
     }
 
-    private func proccessSeekTime() {
+    private func processSeekTime() {
         assert(playerContext.audioReadingEntry === playerContext.audioPlayingEntry,
                "reading and playing entry must be the same")
         fileStreamProcessor.processSeek()
@@ -671,44 +654,41 @@ open class AudioPlayer {
     }
 
     private func processFinishPlaying(entry: AudioEntry?, with nextEntry: AudioEntry?) {
-        let playingEntry = playerContext.entriesLock.around { playerContext.audioPlayingEntry }
+        let playingEntry = playerContext.entriesLock.withLock { playerContext.audioPlayingEntry }
         guard entry == playingEntry else { return }
 
         let isPlayingSameItemProbablySeek = playerContext.audioPlayingEntry === nextEntry
 
-        let notifyDelegateEntryFinishedPlaying: (AudioEntry?, Bool) -> Void = { [weak self] entry, _ in
-            guard let self = self else { return }
-            if let entry = entry, !isPlayingSameItemProbablySeek {
-                let entryId = entry.id
-                let progressInFrames = entry.progressInFrames()
-                let progress = Double(progressInFrames) / self.outputAudioFormat.basicStreamDescription.mSampleRate
-                let duration = entry.duration()
-
-                asyncOnMain {
-                    self.delegate?.audioPlayerDidFinishPlaying(player: self,
-                                                               entryId: entryId,
-                                                               stopReason: self.stopReason,
-                                                               progress: progress,
-                                                               duration: duration)
-                }
-            }
-        }
-
         if let nextEntry = nextEntry {
             if !isPlayingSameItemProbablySeek {
-                nextEntry.lock.around {
+                nextEntry.lock.withLock {
                     nextEntry.seekTime = 0
                 }
-                nextEntry.seekRequest.lock.around {
+                nextEntry.seekRequest.lock.withLock {
                     nextEntry.seekRequest.requested = false
                 }
             }
             playerContext.entriesLock.lock()
             playerContext.audioPlayingEntry = nextEntry
+            let playingQueueEntryId = playerContext.audioPlayingEntry?.id ?? AudioEntryId(id: "")
             playerContext.entriesLock.unlock()
-            let playingQueueEntryId = playingEntry?.id ?? AudioEntryId(id: "")
 
-            notifyDelegateEntryFinishedPlaying(entry, isPlayingSameItemProbablySeek)
+            if let entry = entry, !isPlayingSameItemProbablySeek {
+                let entryId = entry.id
+                let progressInFrames = entry.progressInFrames()
+                let progress = Double(progressInFrames) / outputAudioFormat.basicStreamDescription.mSampleRate
+                let duration = entry.duration()
+                asyncOnMain { [weak self] in
+                    guard let self else { return }
+                    self.delegate?.audioPlayerDidFinishPlaying(
+                        player: self,
+                        entryId: entryId,
+                        stopReason: self.stopReason,
+                        progress: progress,
+                        duration: duration
+                    )
+                }
+            }
             if !isPlayingSameItemProbablySeek {
                 playerContext.setInternalState(to: .waitingForData)
 
@@ -718,10 +698,29 @@ open class AudioPlayer {
                 }
             }
         } else {
-            notifyDelegateEntryFinishedPlaying(entry, isPlayingSameItemProbablySeek)
             playerContext.entriesLock.lock()
             playerContext.audioPlayingEntry = nil
             playerContext.entriesLock.unlock()
+            if let entry = entry, !isPlayingSameItemProbablySeek {
+                let entryId = entry.id
+                let progressInFrames = entry.progressInFrames()
+                let progress = Double(progressInFrames) / outputAudioFormat.basicStreamDescription.mSampleRate
+                let duration = entry.duration()
+
+                sourceQueue.async { [weak self] in
+                    guard let self else { return }
+                    self.processSource()
+                    asyncOnMain {
+                        self.delegate?.audioPlayerDidFinishPlaying(
+                            player: self,
+                            entryId: entryId,
+                            stopReason: self.stopReason,
+                            progress: progress,
+                            duration: duration
+                        )
+                    }
+                }
+            }
         }
         sourceQueue.async { [weak self] in
             self?.processSource()
@@ -748,9 +747,8 @@ open class AudioPlayer {
         }
     }
 
-    private func raiseUnxpected(error: AudioPlayerError) {
+    private func raiseUnexpected(error: AudioPlayerError) {
         playerContext.setInternalState(to: .error)
-        // todo raise on main thread from playback thread
         asyncOnMain { [weak self] in
             guard let self = self else { return }
             self.delegate?.audioPlayerUnexpectedError(player: self, error: error)
@@ -769,7 +767,7 @@ extension AudioPlayer: AudioStreamSourceDelegate {
             let openFileStreamStatus = fileStreamProcessor.openFileStream(with: source.audioFileHint)
             guard openFileStreamStatus == noErr else {
                 let streamError = AudioFileStreamError(status: openFileStreamStatus)
-                raiseUnxpected(error: .audioSystemError(.fileStreamError(streamError)))
+                raiseUnexpected(error: .audioSystemError(.fileStreamError(streamError)))
                 return
             }
         }
@@ -779,7 +777,7 @@ extension AudioPlayer: AudioStreamSourceDelegate {
             guard streamBytesStatus == noErr else {
                 if let playingEntry = playerContext.audioPlayingEntry, playingEntry.has(same: source) {
                     let streamBytesError = AudioFileStreamError(status: streamBytesStatus)
-                    raiseUnxpected(error: .streamParseBytesFailure(streamBytesError))
+                    raiseUnexpected(error: .streamParseBytesFailure(streamBytesError))
                 }
                 return
             }
@@ -790,12 +788,12 @@ extension AudioPlayer: AudioStreamSourceDelegate {
         }
     }
 
-    func errorOccured(source: CoreAudioStreamSource, error: Error) {
+    func errorOccurred(source: CoreAudioStreamSource, error: Error) {
         guard let entry = playerContext.audioReadingEntry, entry.has(same: source) else { return }
-        raiseUnxpected(error: .networkError(.failure(error)))
+        raiseUnexpected(error: .networkError(.failure(error)))
     }
 
-    func endOfFileOccured(source: CoreAudioStreamSource) {
+    func endOfFileOccurred(source: CoreAudioStreamSource) {
         let hasSameSource = playerContext.audioReadingEntry?.has(same: source) ?? false
         guard playerContext.audioReadingEntry == nil || hasSameSource else {
             source.delegate = nil
@@ -826,7 +824,10 @@ extension AudioPlayer: AudioStreamSourceDelegate {
         playerContext.audioReadingEntry = nil
         playerContext.entriesLock.unlock()
 
-        processSource()
+        sourceQueue.async { [weak self] in
+            guard let self = self else { return }
+            self.processSource()
+        }
     }
 
     func metadataReceived(data: [String: String]) {

AudioStreaming/Streaming/AudioPlayer/AudioPlayerConfiguration.swift

@@ -13,11 +13,11 @@ public struct AudioPlayerConfiguration: Equatable {
     /// Number of seconds of audio required to before playback first starts.
     /// - note: Must be larger that `bufferSizeInSeconds`
     let secondsRequiredToStartPlaying: Double
-    /// Number of seconds of audio required after seek occcurs.
+    /// Number of seconds of audio required after seek occurs.
     let gracePeriodAfterSeekInSeconds: Double
-    /// Number of seconds of audio required to before playback resumes after a buffer underun
+    /// Number of seconds of audio required to before playback resumes after a buffer underrun
     /// - note: Must be larger that `bufferSizeInSeconds`
-    let secondsRequiredToStartPlayingAfterBufferUnderun: Int
+    let secondsRequiredToStartPlayingAfterBufferUnderrun: Int
 
     /// Enables the internal logs
     let enableLogs: Bool
@@ -26,7 +26,7 @@ public struct AudioPlayerConfiguration: Equatable {
                                                            bufferSizeInSeconds: 10,
                                                            secondsRequiredToStartPlaying: 1,
                                                            gracePeriodAfterSeekInSeconds: 0.5,
-                                                           secondsRequiredToStartPlayingAfterBufferUnderun: 1,
+                                                           secondsRequiredToStartPlayingAfterBufferUnderrun: 1,
                                                            enableLogs: false)
     /// Initializes the configuration for the `AudioPlayer`
     ///
@@ -35,22 +35,22 @@ public struct AudioPlayerConfiguration: Equatable {
     /// - parameter flushQueueOnSeek: All pending items will be flushed when seeking a track if this is set to `true`
     /// - parameter bufferSizeInSeconds: The size of the decompressed buffer.
     /// - parameter secondsRequiredToStartPlaying: Number of seconds of audio required to before playback first starts.
-    /// - parameter gracePeriodAfterSeekInSeconds: Number of seconds of audio required after seek occcurs.
-    /// - parameter secondsRequiredToStartPlayingAfterBufferUnderun: Number of seconds of audio required to before playback resumes after a buffer underun
+    /// - parameter gracePeriodAfterSeekInSeconds: Number of seconds of audio required after seek occurs.
+    /// - parameter secondsRequiredToStartPlayingAfterBufferUnderrun: Number of seconds of audio required to before playback resumes after a buffer underrun
     /// - parameter enableLogs: Enables the internal logs
     ///
     public init(flushQueueOnSeek: Bool = true,
                 bufferSizeInSeconds: Double = 10,
                 secondsRequiredToStartPlaying: Double = 1,
                 gracePeriodAfterSeekInSeconds: Double = 0.5,
-                secondsRequiredToStartPlayingAfterBufferUnderun: Int = 1,
+                secondsRequiredToStartPlayingAfterBufferUnderrun: Int = 1,
                 enableLogs: Bool = false)
     {
         self.flushQueueOnSeek = flushQueueOnSeek
         self.bufferSizeInSeconds = bufferSizeInSeconds
         self.secondsRequiredToStartPlaying = secondsRequiredToStartPlaying
         self.gracePeriodAfterSeekInSeconds = gracePeriodAfterSeekInSeconds
-        self.secondsRequiredToStartPlayingAfterBufferUnderun = secondsRequiredToStartPlayingAfterBufferUnderun
+        self.secondsRequiredToStartPlayingAfterBufferUnderrun = secondsRequiredToStartPlayingAfterBufferUnderrun
         self.enableLogs = enableLogs
     }
 
@@ -70,15 +70,15 @@ public struct AudioPlayerConfiguration: Equatable {
             ? defaults.gracePeriodAfterSeekInSeconds
             : self.gracePeriodAfterSeekInSeconds
 
-        let secondsRequiredToStartPlayingAfterBufferUnderun = self.secondsRequiredToStartPlayingAfterBufferUnderun == 0
-            ? defaults.secondsRequiredToStartPlayingAfterBufferUnderun
-            : self.secondsRequiredToStartPlayingAfterBufferUnderun
+        let secondsRequiredToStartPlayingAfterBufferUnderrun = self.secondsRequiredToStartPlayingAfterBufferUnderrun == 0
+            ? defaults.secondsRequiredToStartPlayingAfterBufferUnderrun
+            : self.secondsRequiredToStartPlayingAfterBufferUnderrun
 
         return AudioPlayerConfiguration(flushQueueOnSeek: flushQueueOnSeek,
                                         bufferSizeInSeconds: bufferSizeInSeconds,
                                         secondsRequiredToStartPlaying: secondsRequiredToStartPlaying,
                                         gracePeriodAfterSeekInSeconds: gracePeriodAfterSeekInSeconds,
-                                        secondsRequiredToStartPlayingAfterBufferUnderun: secondsRequiredToStartPlayingAfterBufferUnderun,
+                                        secondsRequiredToStartPlayingAfterBufferUnderrun: secondsRequiredToStartPlayingAfterBufferUnderrun,
                                         enableLogs: enableLogs)
     }
 }

AudioStreaming/Streaming/AudioPlayer/AudioPlayerContext.swift

@@ -5,31 +5,32 @@
 
 import Foundation
 
-internal final class AudioPlayerContext {
-    var stopReason = Protected<AudioPlayerStopReason>(.none)
+final class AudioPlayerContext {
+    var stopReason: Atomic<AudioPlayerStopReason>
 
-    var state = Protected<AudioPlayerState>(.ready)
+    var state: Atomic<AudioPlayerState>
     var stateChanged: ((_ oldState: AudioPlayerState, _ newState: AudioPlayerState) -> Void)?
 
-    var muted = Protected<Bool>(false)
+    var muted: Atomic<Bool>
 
     var internalState: AudioPlayer.InternalState {
         playerInternalState.value
     }
 
-    let entriesLock = UnfairLock()
+    let entriesLock: UnfairLock
     var audioReadingEntry: AudioEntry?
     var audioPlayingEntry: AudioEntry?
 
-    var disposedRequested: Bool
-
     /// This is the player's internal state to use
     /// - NOTE: Do not use directly instead use the `internalState` to set and get the property
     /// or the `setInternalState(to:when:)`method
-    private var playerInternalState = Protected<AudioPlayer.InternalState>(.initial)
+    private var playerInternalState = Atomic<AudioPlayer.InternalState>(.initial)
 
     init() {
-        disposedRequested = false
+        stopReason = Atomic<AudioPlayerStopReason>(.none)
+        state = Atomic<AudioPlayerState>(.ready)
+        muted = Atomic<Bool>(false)
+        entriesLock = UnfairLock()
     }
 
     /// Sets the internal state if given the `inState` will be evaluated before assignment occurs.
@@ -37,11 +38,13 @@ internal final class AudioPlayerContext {
     /// - parameter state: The new `PlayerInternalState`
     /// - parameter inState: If the `inState` expression is not nil, the internalState will be set if the evaluated expression is `true`
     /// - NOTE: This sets the underlying `__playerInternalState` variable
-    internal func setInternalState(to state: AudioPlayer.InternalState,
-                                   when inState: ((AudioPlayer.InternalState) -> Bool)? = nil)
+    func setInternalState(to state: AudioPlayer.InternalState,
+                          when inState: ((AudioPlayer.InternalState) -> Bool)? = nil)
     {
         let newValues = playerStateAndStopReason(for: state)
-        stopReason.write { $0 = newValues.stopReason }
+        if let stopReason = newValues.stopReason {
+            self.stopReason.write { $0 = stopReason }
+        }
         guard state != internalState else { return }
         if let inState = inState, !inState(internalState) {
             return

AudioStreaming/Streaming/AudioPlayer/AudioPlayerDelegate.swift

@@ -22,7 +22,7 @@ public protocol AudioPlayerDelegate: AnyObject {
                                      stopReason: AudioPlayerStopReason,
                                      progress: Double,
                                      duration: Double)
-    /// Tells the delegate when an unexpected error occured.
+    /// Tells the delegate when an unexpected error occurred.
     /// - note: Probably a good time to recreate the player when this occurs
     func audioPlayerUnexpectedError(player: AudioPlayer, error: AudioPlayerError)
 

AudioStreaming/Streaming/AudioPlayer/AudioPlayerState.swift

@@ -30,26 +30,26 @@ extension AudioPlayer {
 /// Helper method that returns `AudioPlayerState` and `StopReason` based on the given `InternalState`
 /// - Parameter internalState: A value of `InternalState`
 /// - Returns: A tuple of `(AudioPlayerState, AudioPlayerStopReason)`
-func playerStateAndStopReason(for internalState: AudioPlayer.InternalState) -> (state: AudioPlayerState,
-                                                                                stopReason: AudioPlayerStopReason)
-{
+func playerStateAndStopReason(
+    for internalState: AudioPlayer.InternalState
+) -> (state: AudioPlayerState, stopReason: AudioPlayerStopReason?) {
     switch internalState {
     case .initial:
-        return (.ready, .none)
+        return (.ready, AudioPlayerStopReason.none)
     case .running, .playing, .waitingForDataAfterSeek:
-        return (.playing, .none)
+        return (.playing, AudioPlayerStopReason.none)
     case .pendingNext, .rebuffering, .waitingForData:
-        return (.bufferring, .none)
+        return (.bufferring, AudioPlayerStopReason.none)
     case .stopped:
-        return (.stopped, .userAction)
+        return (.stopped, nil)
     case .paused:
-        return (.paused, .none)
+        return (.paused, AudioPlayerStopReason.none)
     case .disposed:
         return (.disposed, .userAction)
     case .error:
-        return (.error, .error)
+        return (.error, AudioPlayerStopReason.error)
     default:
-        return (.ready, .none)
+        return (.ready, AudioPlayerStopReason.none)
     }
 }
 

AudioStreaming/Streaming/AudioPlayer/AudioRendererContext.swift

@@ -6,10 +6,10 @@
 import AVFoundation
 import CoreAudio
 
-internal var maxFramesPerSlice: AVAudioFrameCount = 8192
+var maxFramesPerSlice: AVAudioFrameCount = 8192
 
 final class AudioRendererContext {
-    var waiting = Protected<Bool>(false)
+    var waiting = Atomic<Bool>(false)
 
     let lock = UnfairLock()
 
@@ -20,13 +20,11 @@ final class AudioRendererContext {
 
     let packetsSemaphore = DispatchSemaphore(value: 0)
 
-    var discontinuous: Bool = false
-
     let framesRequiredToStartPlaying: UInt32
     let framesRequiredAfterRebuffering: UInt32
     let framesRequiredForDataAfterSeekPlaying: UInt32
 
-    var waitingForDataAfterSeekFrameCount = Protected<Int32>(0)
+    var waitingForDataAfterSeekFrameCount = Atomic<Int32>(0)
 
     private let configuration: AudioPlayerConfiguration
 
@@ -36,7 +34,7 @@ final class AudioRendererContext {
         let canonicalStream = outputAudioFormat.basicStreamDescription
 
         framesRequiredToStartPlaying = UInt32(canonicalStream.mSampleRate) * UInt32(configuration.secondsRequiredToStartPlaying)
-        framesRequiredAfterRebuffering = UInt32(canonicalStream.mSampleRate) * UInt32(configuration.secondsRequiredToStartPlayingAfterBufferUnderun)
+        framesRequiredAfterRebuffering = UInt32(canonicalStream.mSampleRate) * UInt32(configuration.secondsRequiredToStartPlayingAfterBufferUnderrun)
         framesRequiredForDataAfterSeekPlaying = UInt32(canonicalStream.mSampleRate) * UInt32(configuration.gracePeriodAfterSeekInSeconds)
 
         let dataByteSize = Int(canonicalStream.mSampleRate * configuration.bufferSizeInSeconds) * Int(canonicalStream.mBytesPerFrame)
@@ -77,8 +75,8 @@ private func allocateBufferList(dataByteSize: Int) -> UnsafeMutablePointer<Audio
     let _bufferList = AudioBufferList.allocate(maximumBuffers: 1)
 
     _bufferList[0].mDataByteSize = UInt32(dataByteSize)
-    let alingment = MemoryLayout<UInt8>.alignment
-    let mData = UnsafeMutableRawPointer.allocate(byteCount: dataByteSize, alignment: alingment)
+    let alignment = MemoryLayout<UInt8>.alignment
+    let mData = UnsafeMutableRawPointer.allocate(byteCount: dataByteSize, alignment: alignment)
     _bufferList[0].mData = mData
     _bufferList[0].mNumberChannels = 2
 

AudioStreaming/Streaming/AudioPlayer/Processors/AudioFileStreamProcessor.swift

@@ -9,7 +9,7 @@ import AVFoundation
 
 enum AudioConvertStatus: Int32 {
     case done = 100
-    case proccessed = 0
+    case processed = 0
 }
 
 struct AudioConvertInfo {
@@ -20,11 +20,11 @@ struct AudioConvertInfo {
 }
 
 enum FileStreamProcessorEffect {
-    case proccessSource
+    case processSource
     case raiseError(AudioPlayerError)
 }
 
-/// An object that handles the proccessing of AudioFileStream, its packets etc.
+/// An object that handles the processing of AudioFileStream, its packets etc.
 final class AudioFileStreamProcessor {
     private let maxCompressedPacketForBitrate = 4096
 
@@ -34,12 +34,13 @@ final class AudioFileStreamProcessor {
     private let rendererContext: AudioRendererContext
     private let outputAudioFormat: AudioStreamBasicDescription
 
-    internal var audioFileStream: AudioFileStreamID?
-    internal var audioConverter: AudioConverterRef?
-    internal var discontinuous: Bool = false
-    internal var inputFormat = AudioStreamBasicDescription()
-    internal var fileFormat: String = ""
-    internal let fa4mFormat = "fa4m"
+    var audioFileStream: AudioFileStreamID?
+    var audioConverter: AudioConverterRef?
+    var discontinuous: Bool = false
+    var inputFormat = AudioStreamBasicDescription()
+
+    var currentFileFormat: String = ""
+    let fileFormatsForDelayedConverterCreation: Set = ["fa4m", "f4pm"]
 
     var isFileStreamOpen: Bool {
         audioFileStream != nil
@@ -115,26 +116,19 @@ final class AudioFileStreamProcessor {
         readingEntry.lock.unlock()
 
         let bitrate = readingEntry.calculatedBitrate()
-        if readingEntry.processedPacketsState.count > 0, bitrate > 0 {
+        if readingEntry.packetDuration > 0, bitrate > 0 {
             var ioFlags = AudioFileStreamSeekFlags(rawValue: 0)
             var packetsAlignedByteOffset: Int64 = 0
             let seekPacket = Int64(floor(readingEntry.seekRequest.time / readingEntry.packetDuration))
 
             let seekStatus = AudioFileStreamSeek(stream, seekPacket, &packetsAlignedByteOffset, &ioFlags)
-            guard seekStatus == noErr else {
-                let streamError = AudioFileStreamError(status: seekStatus)
-                Logger.error("seek failed %@", category: .generic, args: streamError.debugDescription)
-                return
-            }
-
             let dataOffset = Int64(readingEntry.audioStreamState.dataOffset)
-            if !ioFlags.contains(.offsetIsEstimated) {
-                seekByteOffset = packetsAlignedByteOffset + dataOffset
-                let delta = Double((seekByteOffset - dataOffset) - packetsAlignedByteOffset) / bitrate * 8
-
+            if seekStatus == noErr, !ioFlags.contains(.offsetIsEstimated) {
+                let delta = Double((seekByteOffset - dataOffset) - packetsAlignedByteOffset) / (bitrate * 8)
                 readingEntry.lock.lock()
                 readingEntry.seekTime -= delta
                 readingEntry.lock.unlock()
+                seekByteOffset = packetsAlignedByteOffset + dataOffset
             }
         }
 
@@ -165,7 +159,7 @@ final class AudioFileStreamProcessor {
 
         var classDesc = AudioClassDescription()
         var outputFormat = toFormat
-        if getHardwareCodecClassDescripition(formatId: inputFormat.mFormatID, classDesc: &classDesc) {
+        if getHardwareCodecClassDescription(formatId: inputFormat.mFormatID, classDesc: &classDesc) {
             AudioConverterNewSpecific(&inputFormat, &outputFormat, 1, &classDesc, &audioConverter)
         }
 
@@ -178,11 +172,12 @@ final class AudioFileStreamProcessor {
             }
         }
         self.inputFormat = inputFormat
+        assignMagicCookieToConverterIfNeeded()
+    }
 
+    private func assignMagicCookieToConverterIfNeeded() {
         // magic cookie info
-        let fileHint = playerContext.audioReadingEntry?.audioFileHint
-        let isProperFormat = fileHint != kAudioFileAAC_ADTSType && fileHint != kAudioFileM4AType && fileHint != kAudioFileMPEG4Type
-        if let fileStream = audioFileStream, isProperFormat {
+        if let fileStream = audioFileStream {
             var cookieSize: UInt32 = 0
             guard AudioFileStreamGetPropertyInfo(fileStream, kAudioFileStreamProperty_MagicCookieData, &cookieSize, nil) == noErr else {
                 return
@@ -193,7 +188,7 @@ final class AudioFileStreamProcessor {
             }
             guard let converter = audioConverter else {
                 fileStreamCallback?(.raiseError(.audioSystemError(.fileStreamError(.unknownError))))
-                 return
+                return
             }
             guard AudioConverterSetProperty(converter, kAudioConverterDecompressionMagicCookie, cookieSize, cookie) == noErr else {
                 fileStreamCallback?(.raiseError(.audioSystemError(.fileStreamError(.unknownError))))
@@ -229,17 +224,19 @@ final class AudioFileStreamProcessor {
         case kAudioFileStreamProperty_AudioDataByteCount:
             processDataByteCount(fileStream: fileStream)
         case kAudioFileStreamProperty_AudioDataPacketCount:
-            proccessAudioDataPacketCount(fileStream: fileStream)
+            processAudioDataPacketCount(fileStream: fileStream)
         case kAudioFileStreamProperty_ReadyToProducePackets:
-            // check converter for discontious stream
+            // check converter for discontinuous stream
             processReadyToProducePackets(fileStream: fileStream)
+            processPacketUpperBoundAndMaxPacketSize(fileStream: fileStream)
         case kAudioFileStreamProperty_FormatList:
             processFormatList(fileStream: fileStream)
-        default: break
+        default:
+            break
         }
     }
 
-    // MARK: AudioFileStream properties Proccessing
+    // MARK: AudioFileStream properties Processing
 
     private func processDataOffset(fileStream: AudioFileStreamID) {
         var offset: UInt64 = 0
@@ -263,7 +260,7 @@ final class AudioFileStreamProcessor {
         var size = UInt32(4)
         AudioFileStreamGetProperty(fileStream, kAudioFileStreamProperty_FileFormat, &size, &fileFormat)
         if let stringFileFormat = String(data: Data(fileFormat), encoding: .utf8) {
-            self.fileFormat = stringFileFormat
+            currentFileFormat = stringFileFormat
         }
     }
 
@@ -277,6 +274,9 @@ final class AudioFileStreamProcessor {
                 entry.audioStreamFormat = audioStreamFormat
             }
 
+            entry.sampleRate = Float(audioStreamFormat.mSampleRate)
+            entry.packetDuration = Double(audioStreamFormat.mFramesPerPacket) / Double(entry.sampleRate)
+
             var packetBufferSize: UInt32 = 0
             var status = fileStreamGetProperty(value: &packetBufferSize,
                                                fileStream: fileStream,
@@ -289,16 +289,35 @@ final class AudioFileStreamProcessor {
                     packetBufferSize = 2048 // default value
                 }
             }
-            entry.lock.around {
+            entry.lock.withLock {
                 entry.processedPacketsState.bufferSize = packetBufferSize
             }
 
-            if fileFormat != fa4mFormat {
+            if !fileFormatsForDelayedConverterCreation.contains(currentFileFormat) {
                 createAudioConverter(from: entry.audioStreamFormat, to: outputAudioFormat)
             }
         }
     }
 
+    private func processPacketUpperBoundAndMaxPacketSize(fileStream: AudioFileStreamID) {
+        guard let entry = playerContext.audioReadingEntry else { return }
+        var packetBufferSize: UInt32 = 0
+        var status = fileStreamGetProperty(value: &packetBufferSize,
+                                           fileStream: fileStream,
+                                           propertyId: kAudioFileStreamProperty_PacketSizeUpperBound)
+        if status != 0 || packetBufferSize == 0 {
+            status = fileStreamGetProperty(value: &packetBufferSize,
+                                           fileStream: fileStream,
+                                           propertyId: kAudioFileStreamProperty_MaximumPacketSize)
+            if status != 0 || packetBufferSize == 0 {
+                packetBufferSize = 2048 // default value
+            }
+        }
+        entry.lock.withLock {
+            entry.processedPacketsState.bufferSize = packetBufferSize
+        }
+    }
+
     private func processDataByteCount(fileStream: AudioFileStreamID) {
         guard let entry = playerContext.audioReadingEntry else { return }
         var audioDataByteCount: UInt64 = 0
@@ -306,7 +325,7 @@ final class AudioFileStreamProcessor {
         entry.audioStreamState.dataByteCount = audioDataByteCount
     }
 
-    private func proccessAudioDataPacketCount(fileStream: AudioFileStreamID) {
+    private func processAudioDataPacketCount(fileStream: AudioFileStreamID) {
         guard let entry = playerContext.audioReadingEntry else { return }
         var audioDataPacketCount: UInt64 = 0
         fileStreamGetProperty(value: &audioDataPacketCount, fileStream: fileStream, propertyId: kAudioFileStreamProperty_AudioDataPacketCount)
@@ -331,7 +350,7 @@ final class AudioFileStreamProcessor {
             i += step
         }
 
-        if fileFormat == fa4mFormat {
+        if fileFormatsForDelayedConverterCreation.contains(currentFileFormat) {
             if let inputStreamFormat = playerContext.audioReadingEntry?.audioStreamFormat {
                 createAudioConverter(from: inputStreamFormat, to: outputAudioFormat)
             }
@@ -346,12 +365,12 @@ final class AudioFileStreamProcessor {
                              inPacketDescriptions: UnsafeMutablePointer<AudioStreamPacketDescription>?)
     {
         guard let entry = playerContext.audioReadingEntry else { return }
-        guard entry.audioStreamState.processedDataFormat, !playerContext.disposedRequested else { return }
+        guard entry.audioStreamState.processedDataFormat else { return }
 
         if let playingEntry = playerContext.audioPlayingEntry,
            playingEntry.seekRequest.requested, playingEntry.calculatedBitrate() > 0
         {
-            fileStreamCallback?(.proccessSource)
+            fileStreamCallback?(.processSource)
             if rendererContext.waiting.value {
                 rendererContext.packetsSemaphore.signal()
             }
@@ -375,11 +394,11 @@ final class AudioFileStreamProcessor {
             convertInfo.audioBuffer.mNumberChannels = playingAudioStreamFormat.mChannelsPerFrame
         }
 
-        updateProccessedPackets(inPacketDescriptions: inPacketDescriptions,
-                                inNumberPackets: inNumberPackets)
+        updateProcessedPackets(inPacketDescriptions: inPacketDescriptions,
+                               inNumberPackets: inNumberPackets)
 
         var status: OSStatus = noErr
-        packetProccess: while status == noErr {
+        packetProcess: while status == noErr {
             rendererContext.lock.lock()
             let bufferContext = rendererContext.bufferContext
             var used = bufferContext.frameUsedCount
@@ -401,8 +420,7 @@ final class AudioFileStreamProcessor {
                     if framesLeftInBuffer > 0 {
                         break
                     }
-                    if playerContext.disposedRequested
-                        || playerContext.internalState == .disposed
+                    if playerContext.internalState == .disposed
                         || playerContext.internalState == .pendingNext
                         || playerContext.internalState == .stopped
                     {
@@ -412,7 +430,7 @@ final class AudioFileStreamProcessor {
                     if let playingEntry = playerContext.audioPlayingEntry,
                        playingEntry.seekRequest.requested, playingEntry.calculatedBitrate() > 0
                     {
-                        fileStreamCallback?(.proccessSource)
+                        fileStreamCallback?(.processSource)
                         if rendererContext.waiting.value {
                             rendererContext.packetsSemaphore.signal()
                         }
@@ -457,7 +475,7 @@ final class AudioFileStreamProcessor {
                 framesToDecode = start
                 if framesToDecode == 0 {
                     fillUsedFrames(framesCount: framesAdded)
-                    continue packetProccess
+                    continue packetProcess
                 }
                 prefillLocalBufferList(bufferList: localBufferList,
                                        dataOffset: 0,
@@ -475,9 +493,9 @@ final class AudioFileStreamProcessor {
                 if status == AudioConvertStatus.done.rawValue {
                     fillUsedFrames(framesCount: framesAdded)
                     return
-                } else if status == AudioConvertStatus.proccessed.rawValue {
+                } else if status == AudioConvertStatus.processed.rawValue {
                     fillUsedFrames(framesCount: framesAdded)
-                    continue packetProccess
+                    continue packetProcess
                 } else if status != 0 {
                     fileStreamCallback?(.raiseError(.codecError))
                     return
@@ -502,9 +520,9 @@ final class AudioFileStreamProcessor {
                 if status == AudioConvertStatus.done.rawValue {
                     fillUsedFrames(framesCount: framesAdded)
                     return
-                } else if status == AudioConvertStatus.proccessed.rawValue {
+                } else if status == AudioConvertStatus.processed.rawValue {
                     fillUsedFrames(framesCount: framesAdded)
-                    continue packetProccess
+                    continue packetProcess
                 } else if status != 0 {
                     fileStreamCallback?(.raiseError(.codecError))
                     return
@@ -545,8 +563,8 @@ final class AudioFileStreamProcessor {
     }
 
     @inline(__always)
-    private func updateProccessedPackets(inPacketDescriptions: UnsafeMutablePointer<AudioStreamPacketDescription>?,
-                                         inNumberPackets: UInt32)
+    private func updateProcessedPackets(inPacketDescriptions: UnsafeMutablePointer<AudioStreamPacketDescription>?,
+                                        inNumberPackets: UInt32)
     {
         guard let inPacketDescriptions = inPacketDescriptions else { return }
         guard let readingEntry = playerContext.audioReadingEntry else { return }
@@ -618,12 +636,12 @@ private func _converterCallback(inAudioConverter _: AudioConverterRef,
     ioNumberDataPackets.pointee = convertInfo.pointee.numberOfPackets
     convertInfo.pointee.done = true
 
-    return AudioConvertStatus.proccessed.rawValue
+    return AudioConvertStatus.processed.rawValue
 }
 
 // MARK: HardwareCodedClass method
 
-private func getHardwareCodecClassDescripition(formatId: UInt32, classDesc: UnsafeMutablePointer<AudioClassDescription>) -> Bool {
+private func getHardwareCodecClassDescription(formatId: UInt32, classDesc: UnsafeMutablePointer<AudioClassDescription>) -> Bool {
     #if os(iOS)
         var size: UInt32 = 0
         let formatIdSize = UInt32(MemoryLayout.size(ofValue: formatId))

AudioStreaming/Streaming/AudioPlayer/Processors/AudioPlayerRenderProcessor.swift

@@ -90,7 +90,7 @@ final class AudioPlayerRenderProcessor: NSObject {
                     waitForBuffer = true
                 }
             } else if state == .waitingForDataAfterSeek {
-                var requiredFramesToStart: Int = 1024
+                var requiredFramesToStart = 1024
                 if framesState.lastFrameQueued >= 0 {
                     requiredFramesToStart = min(requiredFramesToStart, framesState.lastFrameQueued - framesState.queued)
                 }
@@ -179,9 +179,9 @@ final class AudioPlayerRenderProcessor: NSObject {
 
         if totalFramesCopied < inNumberFrames {
             let delta = inNumberFrames - totalFramesCopied
-            writeSilence(outputBuffer: &bufferList.mBuffers,
-                         outputBufferSize: Int(delta * frameSizeInBytes),
-                         offset: Int(totalFramesCopied * frameSizeInBytes))
+            if let mData = bufferList.mBuffers.mData {
+                memset(mData + Int(totalFramesCopied * frameSizeInBytes), 0, Int(delta * frameSizeInBytes))
+            }
 
             if playingEntry != nil || AudioPlayer.InternalState.waiting.contains(state) {
                 if playerContext.internalState != .rebuffering {
@@ -198,7 +198,6 @@ final class AudioPlayerRenderProcessor: NSObject {
                                 state.contains(.running) && state != .playing
                             }
                         }
-                        rendererContext.waitingForDataAfterSeekFrameCount.write { $0 = 0 }
                     }
                 } else {
                     rendererContext.waitingForDataAfterSeekFrameCount.write { $0 = 0 }
@@ -211,7 +210,7 @@ final class AudioPlayerRenderProcessor: NSObject {
         }
         currentPlayingEntry.lock.lock()
 
-        var extraFramesPlayedNotAssigned: Int = 0
+        var extraFramesPlayedNotAssigned = 0
         var framesPlayedForCurrent = Int(totalFramesCopied)
 
         if currentPlayingEntry.framesState.lastFrameQueued >= 0 {
@@ -328,7 +327,5 @@ final class AudioPlayerRenderProcessor: NSObject {
     {
         guard let mData = outputBuffer.mData else { return }
         memset(mData + offset, 0, outputBufferSize)
-        outputBuffer.mDataByteSize = UInt32(outputBufferSize)
-        outputBuffer.mNumberChannels = outputAudioFormat.mChannelsPerFrame
     }
 }

AudioStreaming/Streaming/AudioPlayer/Processors/FrameFilterProcessor.swift

@@ -33,7 +33,6 @@ public struct FilterEntry: Equatable {
 }
 
 public protocol FrameFiltering {
-
     /// A Boolean value indicating whether there are filter entries
     var hasEntries: Bool { get }
 
@@ -50,21 +49,21 @@ public protocol FrameFiltering {
     /// Adds a filter entry with the given parameters
     /// - Parameters:
     ///   - named: The name of the entry to be added
-    ///   - filter: The block for the filter hanlding
+    ///   - filter: The block for the filter handling
     func add(entry named: String, filter: @escaping FilterCallback)
 
     /// Adds a filter entry with the given parameters
     /// - Parameters:
     ///   - name: The name for the new entry
     ///   - filterName: The name of a previously added filters
-    ///   - filter: The block for the filter hanlding
+    ///   - filter: The block for the filter handling
     func add(entry named: String, after filterName: String, filter: @escaping FilterCallback)
 
     /// Removes a filter entry
     /// - Parameter entry: An instance of `FilterEntry` to be removed
     func remove(entry: FilterEntry)
 
-    /// Attemps to remove a filter entry by its name
+    /// Attempts to remove a filter entry by its name
     /// - Parameter named: A `String` representing the name of the filter entry
     func remove(entry named: String)
 
@@ -73,21 +72,21 @@ public protocol FrameFiltering {
 }
 
 final class FrameFilterProcessor: NSObject, FrameFiltering {
-
     public var hasEntries: Bool {
         lock.lock(); defer { lock.unlock() }
         return !entries.isEmpty
     }
 
     private let lock = UnfairLock()
-    private let mixerNode: AVAudioMixerNode
+    private let mixerNodeProvider: () -> AVAudioMixerNode
+    private lazy var mixerNode: AVAudioMixerNode = mixerNodeProvider()
 
     private(set) var entries: [FilterEntry] = []
 
     private var hasInstalledTap: Bool = false
 
-    init(mixerNode: AVAudioMixerNode) {
-        self.mixerNode = mixerNode
+    init(mixerNodeProvider: @escaping (() -> AVAudioMixerNode)) {
+        self.mixerNodeProvider = mixerNodeProvider
     }
 
     public func add(entry: FilterEntry) {

AudioStreaming/Streaming/AudioPlayer/Processors/IcycastHeadersProcessor.swift

@@ -26,7 +26,6 @@ import Foundation
 /// ```
 
 final class IcycastHeadersProcessor {
-
     private var icecastHeaders = Data(capacity: 1024)
     private var searchComplete = false
     private var iceHeaderAvailable = false
@@ -38,31 +37,32 @@ final class IcycastHeadersProcessor {
     }
 
     @inline(__always)
-    func proccess(data: Data) -> (Data?, Data) {
-        let stopProccessingCheckOne: [UInt8] = Array("\n\n".utf8)
-        let stopProccessingCheckTwo: [UInt8] = Array("\r\n\r\n".utf8)
+    func process(data: Data) -> (Data?, Data) {
+        let stopProcessingCheckOne: [UInt8] = Array("\n\n".utf8)
+        let stopProcessingCheckTwo: [UInt8] = Array("\r\n\r\n".utf8)
         let icyPrefix: [UInt8] = Array("ICY ".utf8)
         let httpPrefix: [UInt8] = Array("HTTP".utf8)
         return data.withUnsafeBytes { buffer -> (Data?, Data) in
+            guard !buffer.isEmpty else { return (nil, data) }
             var bytesRead = 0
             let bytes = buffer.baseAddress!.assumingMemoryBound(to: UInt8.self)
             // Read through the bytes and stop when our search is complete
-            // Since we don't know the amount of bytes to be proccessed
+            // Since we don't know the amount of bytes to be processed
             // we add each character up until we found on of the checks as defined above.
             while bytesRead < buffer.count, !searchComplete {
                 let pointer = bytes + bytesRead
                 icecastHeaders.append(pointer, count: 1)
 
-                if icecastHeaders.count >= stopProccessingCheckOne.count {
-                    if icecastHeaders.suffix(stopProccessingCheckOne.count) == stopProccessingCheckOne {
+                if icecastHeaders.count >= stopProcessingCheckOne.count {
+                    if icecastHeaders.suffix(stopProcessingCheckOne.count) == stopProcessingCheckOne {
                         iceHeaderAvailable = true
                         searchComplete = true
                         break
                     }
                 }
 
-                if icecastHeaders.count >= stopProccessingCheckTwo.count {
-                    if icecastHeaders.suffix(stopProccessingCheckTwo.count) == stopProccessingCheckTwo {
+                if icecastHeaders.count >= stopProcessingCheckTwo.count {
+                    if icecastHeaders.suffix(stopProcessingCheckTwo.count) == stopProcessingCheckTwo {
                         iceHeaderAvailable = true
                         searchComplete = true
                         break
@@ -71,8 +71,9 @@ final class IcycastHeadersProcessor {
 
                 if icecastHeaders.count >= icyPrefix.count {
                     // in case the first 4 chars are not "ICY " nor "HTTP" then we stop the flow
-                    if icecastHeaders[..<icyPrefix.count].elementsEqual(icyPrefix) == false &&
-                        icecastHeaders[..<httpPrefix.count].elementsEqual(httpPrefix) == false {
+                    if icecastHeaders[..<icyPrefix.count].elementsEqual(icyPrefix) == false,
+                       icecastHeaders[..<httpPrefix.count].elementsEqual(httpPrefix) == false
+                    {
                         iceHeaderAvailable = false
                         searchComplete = true
                     }

AudioStreaming/Streaming/AudioPlayer/Processors/MetadataStreamProcessor.swift

@@ -12,16 +12,16 @@ protocol MetadataStreamSourceDelegate: AnyObject {
 protocol MetadataStreamSource {
     var delegate: MetadataStreamSourceDelegate? { get set }
 
-    /// Returns `true` when the stream header has indicated that we can proccess metadata, otherwise `false`.
-    var canProccessMetadata: Bool { get }
+    /// Returns `true` when the stream header has indicated that we can process metadata, otherwise `false`.
+    var canProcessMetadata: Bool { get }
 
     /// Assigns the metadata step of the metadata
     func metadataAvailable(step: Int)
 
-    /// Proccess the received data and extract the metadata if any, returns audio data only.
+    /// Process the received data and extract the metadata if any, returns audio data only.
     /// - parameter data: A `Data` object for parsing any metadata
     /// - returns: The extracted audio `Data`
-    func proccessMetadata(data: Data) -> Data
+    func processMetadata(data: Data) -> Data
 
     /// Resets the processor
     func reset()
@@ -44,7 +44,7 @@ protocol MetadataStreamSource {
 final class MetadataStreamProcessor: MetadataStreamSource {
     weak var delegate: MetadataStreamSourceDelegate?
 
-    var canProccessMetadata: Bool {
+    var canProcessMetadata: Bool {
         return metadataStep > 0
     }
 
@@ -73,10 +73,10 @@ final class MetadataStreamProcessor: MetadataStreamSource {
         audioDataBytesRead = 0
     }
 
-    // MARK: Proccess Metadata
+    // MARK: Process Metadata
 
     @inline(__always)
-    func proccessMetadata(data: Data) -> Data {
+    func processMetadata(data: Data) -> Data {
         data.withUnsafeBytes { buffer -> Data in
             guard !buffer.isEmpty else { return data }
             var audioData = Data()

AudioStreaming/Streaming/Helpers/AudioFileType.swift

@@ -7,7 +7,7 @@ import AudioToolbox
 import Foundation
 
 /// mapping from mime types to `AudioFileTypeID`
-internal let fileTypesFromMimeType: [String: AudioFileTypeID] =
+let fileTypesFromMimeType: [String: AudioFileTypeID] =
     [
         "audio/mp3": kAudioFileMP3Type,
         "audio/mpg": kAudioFileMP3Type,
@@ -44,7 +44,7 @@ func audioFileType(mimeType: String) -> AudioFileTypeID {
 }
 
 /// mapping from file extension to `AudioFileTypeID`
-internal let fileTypesFromFileExtension: [String: AudioFileTypeID] =
+let fileTypesFromFileExtension: [String: AudioFileTypeID] =
     [
         "mp3": kAudioFileMP3Type,
         "wav": kAudioFileWAVEType,

AudioStreaming/Streaming/Helpers/PlayerQueueEntries.swift

@@ -17,14 +17,14 @@ final class PlayerQueueEntries {
 
     /// Returns `true` when both underlying entries are empty
     var isEmpty: Bool {
-        lock.around {
+        lock.withLock {
             bufferring.isEmpty && upcoming.isEmpty
         }
     }
 
     /// Returns the count of both underlying entries
     var count: Int {
-        lock.around {
+        lock.withLock {
             bufferring.count + upcoming.count
         }
     }

AudioStreaming/Streaming/Parsers/HTTPHeaderParser.swift

@@ -6,7 +6,7 @@
 import AudioToolbox.AudioFile
 import Foundation
 
-struct HeaderField {
+enum HeaderField {
     public static let acceptRanges = "Accept-Ranges"
     public static let contentLength = "Content-Length"
     public static let contentType = "Content-Type"
@@ -14,7 +14,7 @@ struct HeaderField {
 }
 
 enum IcyHeaderField {
-    public static let icyMentaint = "icy-metaint"
+    public static let icyMetaint = "icy-metaint"
 }
 
 struct HTTPHeaderParserOutput {
@@ -22,6 +22,11 @@ struct HTTPHeaderParserOutput {
     let typeId: AudioFileTypeID
     // Metadata Support
     let metadataStep: Int
+    let seekable: Bool
+
+    var isMp4: Bool {
+        (typeId == kAudioFileMPEG4Type || typeId == kAudioFileM4AType)
+    }
 }
 
 protocol HTTPHeaderParsing: Parser {
@@ -46,7 +51,7 @@ struct HTTPHeaderParser: HTTPHeaderParsing {
             typeId = audioFileType(mimeType: contentType)
         }
 
-        var fileLength: Int = 0
+        var fileLength = 0
         if input.statusCode == 200 {
             let contentLength = value(forHTTPHeaderField: HeaderField.contentLength, in: input)
             if let contentLength = contentLength, let length = Int(contentLength) {
@@ -64,15 +69,18 @@ struct HTTPHeaderParser: HTTPHeaderParsing {
         }
 
         var metadataStep = 0
-        if let icyMetaint = value(forHTTPHeaderField: IcyHeaderField.icyMentaint, in: input),
+        if let icyMetaint = value(forHTTPHeaderField: IcyHeaderField.icyMetaint, in: input),
            let intValue = Int(icyMetaint)
         {
             metadataStep = intValue
         }
 
-        return HTTPHeaderParserOutput(fileLength: fileLength,
-                                      typeId: typeId,
-                                      metadataStep: metadataStep)
+        return HTTPHeaderParserOutput(
+            fileLength: fileLength,
+            typeId: typeId,
+            metadataStep: metadataStep,
+            seekable: input.statusCode == 206
+        )
     }
 }
 
@@ -91,10 +99,8 @@ extension Parser where Self: HTTPHeaderParsing {
 
     private func valueForCaseInsensitiveKey(_ key: String, fields: [String: String]) -> String? {
         let keyToBeFound = key.lowercased()
-        for (key, value) in fields {
-            if key.lowercased() == keyToBeFound {
-                return value
-            }
+        for (key, value) in fields where key.lowercased() == keyToBeFound {
+            return value
         }
         return nil
     }

AudioStreaming/Streaming/Parsers/IcycastHeaderParser.swift

@@ -9,9 +9,7 @@
 import Foundation
 
 struct IcycastHeaderParser: Parser {
-
     func parse(input: Data) -> HTTPHeaderParserOutput? {
-
         guard let icecastValue = String(data: input, encoding: .utf8) else {
             return nil
         }
@@ -23,12 +21,15 @@ struct IcycastHeaderParser: Parser {
                 result[String(key)] = String(value)
             }
         }
-        let metadataStep = Int(result[IcyHeaderField.icyMentaint] ?? "") ?? 0
+        let metadataStep = Int(result[IcyHeaderField.icyMetaint] ?? "") ?? 0
         let contentType = result[HeaderField.contentType.lowercased()] ?? "audio/mpeg"
         let typeId = audioFileType(mimeType: contentType)
 
-        return HTTPHeaderParserOutput(fileLength: 0,
-                                      typeId: typeId,
-                                      metadataStep: metadataStep)
+        return HTTPHeaderParserOutput(
+            fileLength: 0,
+            typeId: typeId,
+            metadataStep: metadataStep,
+            seekable: false
+        )
     }
 }

AudioStreaming/Streaming/Parsers/MetadataParser.swift

@@ -18,13 +18,17 @@ struct MetadataParser: Parser {
 
     func parse(input: Data) -> MetadataOutput {
         guard let string = String(data: input, encoding: .utf8) else { return .failure(.unableToParse) }
-        // remove added bytes (zeros) and seperate the string on every ';' char
+        // remove added bytes (zeros) and separate the string on every ';' char
         let pairs = string.trimmingCharacters(in: CharacterSet(charactersIn: "\0")).components(separatedBy: ";")
-        let temp: [String: String] = [:]
-        let metadata = pairs.reduce(into: temp) { result, next in
-            let paired = next.components(separatedBy: "=")
-            if let key = paired.first,
-               let value = paired.last?.replacingOccurrences(of: "'", with: ""), !key.isEmpty
+        let metadata = pairs.reduce(into: [String: String]()) { result, next in
+            let split = next.split(
+                separator: "=",
+                maxSplits: 1,
+                omittingEmptySubsequences: true
+            )
+            .map(String.init)
+            if let key = split.first,
+               let value = split.last?.replacingOccurrences(of: "'", with: ""), !key.isEmpty
             {
                 result[key] = value
             }

AudioStreamingTests/Core/AtomicTests.swift

@@ -7,27 +7,27 @@ import XCTest
 
 @testable import AudioStreaming
 
-class ProtectedTests: XCTestCase {
+class AtomicTests: XCTestCase {
     func testProtectedValuesAreAccessedSafely() {
         measure {
-            let protected = Protected<Int>(0)
+            let atomic = Atomic<Int>(0)
 
-            DispatchQueue.concurrentPerform(iterations: 1_000_000) { _ in
-                _ = protected.value
-                protected.write { $0 += 1 }
+            DispatchQueue.concurrentPerform(iterations: 100_000) { _ in
+                _ = atomic.value
+                atomic.write { $0 += 1 }
             }
 
-            XCTAssertEqual(protected.value, 1_000_000)
+            XCTAssertEqual(atomic.value, 100_000)
         }
     }
 
     func testThatProtectedReadAndWriteAreSafe() {
         measure {
             let initialValue = "aValue"
-            let protected = Protected<String>(initialValue)
+            let protected = Atomic<String>(initialValue)
 
             DispatchQueue.concurrentPerform(iterations: 1000) { i in
-                _ = protected.read { $0 }
+                _ = protected.value
                 protected.write { $0 = "\(i)" }
             }
 

AudioStreamingTests/Core/BiMapTests.swift

@@ -1,5 +1,5 @@
 //
-//  BiMap.swift
+//  BiMapTests.swift
 //  AudioStreamingTests
 //
 //  Created by Dimitrios Chatzieleftheriou on 26/05/2020.

AudioStreamingTests/Core/ByteBufferTests.swift

@@ -0,0 +1,75 @@
+//
+// Copyright © Blockchain Luxembourg S.A. All rights reserved.
+
+import XCTest
+@testable import AudioStreaming
+
+final class ByteBufferTests: XCTestCase {
+    func testWriteAndReadBytes() {
+        var buffer = ByteBuffer(size: 10)
+
+        // Write bytes to the buffer
+        let testData = Data([0x01, 0x02, 0x03, 0x04])
+        buffer.writeBytes(testData)
+        buffer.rewind()
+
+        // Read the written bytes
+        do {
+            let readData = try buffer.readBytes(4)
+            XCTAssertEqual(readData, testData)
+        } catch {
+            XCTFail("Error reading bytes: \(error)")
+        }
+    }
+
+    func testWriteAndReadInteger() {
+        var buffer = ByteBuffer(size: 8)
+
+        // Write integer to the buffer
+        let testInteger: UInt32 = 123_456_789
+        buffer.put(testInteger)
+        buffer.rewind()
+
+        // Read the written integer
+        do {
+            let readInteger: UInt32 = try buffer.getInteger()
+            XCTAssertEqual(readInteger, testInteger.bigEndian)
+        } catch {
+            XCTFail("Error reading integer: \(error)")
+        }
+    }
+
+    func testWriteAndReadFloat() {
+        var buffer = ByteBuffer(size: 8)
+
+        // Write float to the buffer
+        let testFloat: Float = 123.456
+        buffer.put(testFloat)
+        buffer.rewind()
+
+        // Read the written float
+        do {
+            let readFloat: Float = try buffer.getFloat()
+            XCTAssertEqual(readFloat, testFloat, accuracy: 0.001)
+        } catch {
+            XCTFail("Error reading float: \(error)")
+        }
+    }
+
+    func testWriteAndReadDouble() {
+        var buffer = ByteBuffer(size: 8)
+
+        // Write double to the buffer
+        let testDouble = 123.456
+        buffer.put(testDouble)
+        buffer.rewind()
+
+        // Read the written double
+        do {
+            let readDouble: Double = try buffer.getDouble()
+            XCTAssertEqual(readDouble, testDouble, accuracy: 0.001)
+        } catch {
+            XCTFail("Error reading double: \(error)")
+        }
+    }
+}

AudioStreamingTests/Core/DispatchTimerSourceTests.swift

@@ -1,5 +1,5 @@
 //
-//  DispatchReadSourceTests.swift
+//  DispatchTimerSourceTests.swift
 //  AudioStreamingTests
 //
 //  Created by Dimitrios Chatzieleftheriou on 25/10/2020.

AudioStreamingTests/Core/Network/NetworkingClientTests.swift

@@ -4,7 +4,6 @@
 //
 
 import XCTest
-
 @testable import AudioStreaming
 
 class NetworkingClientTests: XCTestCase {

AudioStreamingTests/Streaming/Metadata Stream Processor/MetadataStreamProcessorTests.swift

@@ -18,19 +18,19 @@ class MetadataStreamProcessorTests: XCTestCase {
         let processor = MetadataStreamProcessor(parser: parser.eraseToAnyParser())
 
         // without calling `metadataAvailable(step:)` it should be false
-        XCTAssertFalse(processor.canProccessMetadata)
+        XCTAssertFalse(processor.canProcessMetadata)
 
         // calling `metadataAvailable(step:)` with zero
         processor.metadataAvailable(step: 0)
 
         // it should be false
-        XCTAssertFalse(processor.canProccessMetadata)
+        XCTAssertFalse(processor.canProcessMetadata)
 
         // calling `metadataAvailable(step:)` with greater zero
         processor.metadataAvailable(step: 1)
 
         // it should be true
-        XCTAssertTrue(processor.canProccessMetadata)
+        XCTAssertTrue(processor.canProcessMetadata)
     }
 
     func test_Processor_Outputs_Correct_Metadata_ForStep_WithEmptyMetadata() throws {
@@ -45,7 +45,7 @@ class MetadataStreamProcessorTests: XCTestCase {
         // this is the step value as received from the http headers
         processor.metadataAvailable(step: 16000)
 
-        let audio = processor.proccessMetadata(data: data)
+        let audio = processor.processMetadata(data: data)
         XCTAssertFalse(audio.isEmpty)
 
         XCTAssertTrue(metadataDelegateSpy.receivedMetadata.called)
@@ -64,7 +64,7 @@ class MetadataStreamProcessorTests: XCTestCase {
         // this is the step value as received from the http headers
         processor.metadataAvailable(step: 16000)
 
-        let audio = processor.proccessMetadata(data: data)
+        let audio = processor.processMetadata(data: data)
         XCTAssertFalse(audio.isEmpty)
 
         XCTAssertTrue(metadataDelegateSpy.receivedMetadata.called)
@@ -83,7 +83,7 @@ class MetadataStreamProcessorTests: XCTestCase {
         // this is the step value as received from the http headers
         processor.metadataAvailable(step: 8000)
 
-        let audio = processor.proccessMetadata(data: data)
+        let audio = processor.processMetadata(data: data)
         XCTAssertFalse(audio.isEmpty)
 
         XCTAssertTrue(metadataDelegateSpy.receivedMetadata.called)
@@ -106,7 +106,7 @@ class MetadataStreamProcessorTests: XCTestCase {
         // this is the step value as received from the http headers
         processor.metadataAvailable(step: 16000)
 
-        let audio = processor.proccessMetadata(data: data)
+        let audio = processor.processMetadata(data: data)
         XCTAssertFalse(audio.isEmpty)
 
         XCTAssertFalse(metadataDelegateSpy.receivedMetadata.called)
@@ -122,7 +122,7 @@ class MetadataStreamProcessorTests: XCTestCase {
         // this is the step value as received from the http headers
         processor.metadataAvailable(step: 16000)
 
-        let audio = processor.proccessMetadata(data: data)
+        let audio = processor.processMetadata(data: data)
         XCTAssertTrue(audio.isEmpty)
 
         XCTAssertFalse(metadataDelegateSpy.receivedMetadata.called)

AudioStreamingTests/Streaming/Parsers/HTTPHeaderParserTests.swift

@@ -34,7 +34,7 @@ class HTTPHeaderParserTests: XCTestCase {
         let headers: [String: String] =
             [HeaderField.contentLength: "1000",
              HeaderField.contentType: "audio/mp3",
-             IcyHeaderField.icyMentaint: "16000"]
+             IcyHeaderField.icyMetaint: "16000"]
         let httpURLResponse = HTTPURLResponse(url: URL(string: "www.google.com")!,
                                               statusCode: 200,
                                               httpVersion: "",
@@ -57,7 +57,7 @@ class HTTPHeaderParserTests: XCTestCase {
         let headers: [String: String] =
             [HeaderField.contentLength.lowercased(): "1000",
              HeaderField.contentType.lowercased(): "audio/mp3",
-             IcyHeaderField.icyMentaint.lowercased(): "16000"]
+             IcyHeaderField.icyMetaint.lowercased(): "16000"]
         let httpURLResponse = HTTPURLResponse(url: URL(string: "www.google.com")!,
                                               statusCode: 200,
                                               httpVersion: "",

AudioStreamingTests/Streaming/Parsers/MetadataParser.swift

@@ -50,6 +50,26 @@ class MetadataParserTests: XCTestCase {
         }
     }
 
+    func testParserOutputsCorrectResultWhenEntryContainsEqualSign() throws {
+        let string = "StreamTitle=\'Gramatik - In This Whole World (Original Mix)\';StreamUrl=\'\';track_info=\'k4Smc3RhdHVzoUihQNJiGp6BpHR5cGWhVKJpZKhNWDUxMTYzNISmc3RhdHVzoUOhQNJiGp9cpHR5cGWhVKJpZKhNWDUxMDM3MoSmc3RhdHVzoUOhQNJiGqAqpHR5cGWhVKJpZKhNWDUxMjA5Ng==\';UTC=\'20220226T214447.206\';\0\0\0\0\0\0\0\0\0"
+        let data = string.data(using: .utf8)!
+
+        let parser = MetadataParser()
+
+        let output = parser.parse(input: data)
+
+        switch output {
+        case let .success(values):
+            XCTAssertFalse(values.isEmpty)
+            XCTAssertEqual(values["StreamTitle"], "Gramatik - In This Whole World (Original Mix)")
+            XCTAssertEqual(values["StreamUrl"], "")
+            XCTAssertEqual(values["track_info"], "k4Smc3RhdHVzoUihQNJiGp6BpHR5cGWhVKJpZKhNWDUxMTYzNISmc3RhdHVzoUOhQNJiGp9cpHR5cGWhVKJpZKhNWDUxMDM3MoSmc3RhdHVzoUOhQNJiGqAqpHR5cGWhVKJpZKhNWDUxMjA5Ng==")
+            XCTAssertEqual(values["UTC"], "20220226T214447.206")
+        case .failure:
+            XCTFail()
+        }
+    }
+
     func testParserOutputsFailureOnEmptyStringData() throws {
         let data = "".data(using: .utf8)!
         let parser = MetadataParser()

Package.swift

@@ -17,7 +17,7 @@ let package = Package(
         .target(
             name: "AudioStreaming",
             path: "AudioStreaming"
-        )
+        ),
     ],
     swiftLanguageVersions: [.v5]
 )

README.md

@@ -6,34 +6,36 @@ An AudioPlayer/Streaming library for iOS written in Swift, allows playback of on
 Under the hood `AudioStreaming` uses `AVAudioEngine` and `CoreAudio` for playback and provides an easy way of applying real-time [audio enhancements](https://developer.apple.com/documentation/avfaudio/audio_engine/audio_units).
 
 #### Supported audio
-- Online streaming (Shoutcast/ICY streams) with metadata parsing 
+- Online streaming (Shoutcast/ICY streams) with metadata parsing
 - AIFF, AIFC, WAVE, CAF, NeXT, ADTS, MPEG Audio Layer 3, AAC audio formats
 - M4A (_Optimized files only_)
 
+As of 1.2.0 version, there's support for non-optimized remote M4A, please report any issues
+
 Known limitations: 
-- As described above non-optimised M4A files are not supported this is a limitation of [AudioFileStream Services](https://developer.apple.com/documentation/audiotoolbox/audio_file_stream_services?language=swift) 
+~~- As described above non-optimised M4A files are not supported this is a limitation of [AudioFileStream Services](https://developer.apple.com/documentation/audiotoolbox/audio_file_stream_services?language=swift)~~
 
 
 # Requirements
- - iOS 12.0+
+ - iOS 13.0+
  - Swift 5.x
 
 # Using AudioStreaming
 
 ### Playing an audio source over HTTP
 Note: You need to keep a reference to the `AudioPlayer` object
-```
+```swift
 let player = AudioPlayer()
 player.play(url: URL(string: "https://your-remote-url/to/audio-file.mp3")!)
 ```
 
 ### Playing a local file 
-```
+```swift
 let player = AudioPlayer()
 player.play(url: URL(fileURLWithPath: "your-local-path/to/audio-file.mp3")!)
 ```
 ### Queueing audio files
-```
+```swift
 let player = AudioPlayer()
 // when you want to queue a single url
 player.queue(url: URL(string: "https://your-remote-url/to/audio-file.mp3")!)
@@ -46,7 +48,7 @@ player.queue(urls: [
 ```
 
 ### Adjusting playback properties
-```
+```swift
 let player = AudioPlayer()
 player.play(url: URL(fileURLWithPath: "your-local-path/to/audio-file.mp3")!)
 // adjust the playback rate
@@ -72,7 +74,7 @@ player.seek(to: 10)
 ```
 
 ### Audio playback properties
-```
+```swift
 let player = AudioPlayer()
 player.play(url: URL(fileURLWithPath: "your-local-path/to/audio-file.mp3")!)
 
@@ -93,7 +95,7 @@ let state = player.stopReason
 You can inspect various callbacks by using the `delegate` property of the `AudioPlayer` to get informed about the player state, errors etc.
 View the [AudioPlayerDelegate](AudioStreaming/Streaming/AudioPlayer/AudioPlayerDelegate.swift) for more details
 
-```
+```swift
 let player = AudioPlayer()
 player.play(url: URL(fileURLWithPath: "your-local-path/to/audio-file.mp3")!)
 
@@ -105,9 +107,9 @@ func audioPlayerStateChanged(player: AudioPlayer, with newState: AudioPlayerStat
 
 ### Adding custom audio nodes to AudioPlayer
 `AudioStreaming` provides an easy way to attach/remove `AVAudioNode`(s).
-This provides a powerful way of adjusting the playback audio with various enchncements 
+This provides a powerful way of adjusting the playback audio with various enhancements
 
-```
+```swift
 let reverbNode = AVAudioUnitReverb()
 reverbNode.wetDryMix = 50 
 
@@ -126,11 +128,11 @@ The example project shows an example of adding a custom `AVAudioUnitEQ` node for
 
 ### Adding custom frame filter for recording and observation of audio data
 
-`AudioStreaming` allow for custom frame fliters to be added so that recording or other observation for audio that's playing.
+`AudioStreaming` allow for custom frame filters to be added so that recording or other observation for audio that's playing.
 
 You add a frame filter by using the `AudioPlayer`'s property `frameFiltering`.
 
-```
+```swift
 let player = AudioPlayer()
 let format = player.mainMixerNode.outputFormat(forBus: 0)
 
@@ -152,12 +154,12 @@ let record = FilterEntry(name: "record") { buffer, when in
 
 player.frameFiltering.add(entry: record)
 ```
-See the `FrameFiltering` protocol for more ways of adding and removing frame filters. 
-The callback in which you observe a filter will be run on a thread other than the main thread. 
+See the `FrameFiltering` protocol for more ways of adding and removing frame filters.
+The callback in which you observe a filter will be run on a thread other than the main thread.
 
-Under the hood the concrete class for frame filters, `FrameFilterProcessor` installs a tap on the `mainMixerNode` of  `AVAudioEngine` in which all the added fitler will be called from.
+Under the hood the concrete class for frame filters, `FrameFilterProcessor` installs a tap on the `mainMixerNode` of  `AVAudioEngine` in which all the added filter will be called from.
 
-**Note** since the `mainMixerNode` is publicly exposed extra care should be taken to not install a tap directly and also use frame filters, this result in an exception because only one tap can be installed on an output node, as per Apple's documention. 
+**Note** since the `mainMixerNode` is publicly exposed extra care should be taken to not install a tap directly and also use frame filters, this result in an exception because only one tap can be installed on an output node, as per Apple's documentation.
 
 # Installation
 
@@ -199,5 +201,5 @@ Visit [installation instructions](https://github.com/Carthage/Carthage#adding-fr
 AudioStreaming is available under the MIT license. See the LICENSE file for more info.
 
 # Attributions
-This librabry takes inspiration on the already battled-tested streaming library, [StreamingKit](https://github.com/tumtumtum/StreamingKit).
+This library takes inspiration on the already battled-tested streaming library, [StreamingKit](https://github.com/tumtumtum/StreamingKit).
 Big 🙏 to Thong Nguyen (@tumtumtum) and Matt Gallagher (@mattgallagher) for [AudioStreamer](https://github.com/mattgallagher/AudioStreamer)