Merge branch 'main' of https://github.com/dimitris-c/AudioStreaming into main

* Fixes queing multiple items

Adds error callback on AudioConverter failure

* Adds a new radio stream in AudioExample

* Updates Readme file

.github/workflows/swift.yml

@@ -0,0 +1,24 @@
+name: "AudioStreaming CI"
+
+on: 
+  push:
+    branches: 
+      - main
+      - hotfix
+  pull_request:
+    branches: 
+      - '*'
+
+jobs:
+  iOS:
+    name: Test iOS 
+    runs-on: macOS-latest
+    env: 
+      DEVELOPER_DIR: /Applications/Xcode_12.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"]
+    steps:
+      - uses: actions/checkout@v2
+      - name: iOS - ${{ matrix.destination }}
+        run: set -o pipefail && env NSUnbufferedIO=YES xcodebuild -project "AudioStreaming.xcodeproj" -scheme "AudioStreaming" -destination "${{ matrix.destination }}" clean test | xcpretty

AudioExample/AudioExample/Controllers/PlayerViewController.swift

@@ -55,7 +55,7 @@ class PlayerViewController: UIViewController {
         tableView.translatesAutoresizingMaskIntoConstraints = false
         tableView.delegate = self
         tableView.dataSource = self
-        tableView.register(UITableViewCell.self, forCellReuseIdentifier: "PlaylistCell")
+        tableView.register(PlaylistTableViewCell.self, forCellReuseIdentifier: "PlaylistCell")
 
         let controlsController = controlsProvider()
         playerControlsController = controlsController
@@ -120,6 +120,7 @@ extension PlayerViewController: UITableViewDataSource {
             return cell
         }
         cell.textLabel?.text = item.name
+        cell.detailTextLabel?.text = item.queues ? "Queue item" : nil
         update(status: item.status, of: cell)
         return cell
     }
@@ -147,3 +148,15 @@ extension PlayerViewController: UITableViewDelegate {
         viewModel.playItem(at: indexPath)
     }
 }
+
+
+final class PlaylistTableViewCell: UITableViewCell {
+    override init(style: UITableViewCell.CellStyle, reuseIdentifier: String?) {
+        super.init(style: .subtitle, reuseIdentifier: reuseIdentifier)
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+}

AudioExample/AudioExample/Controllers/PlayerViewModel.swift

@@ -47,7 +47,7 @@ final class PlayerViewModel {
             print("malformed url error")
             return
         }
-        playlistItemsService.add(item: PlaylistItem(url: url, name: urlString, status: .stopped))
+        playlistItemsService.add(item: PlaylistItem(url: url, name: urlString, status: .stopped, queues: false))
         reloadContent?(.all)
     }
 
@@ -57,13 +57,20 @@ final class PlayerViewModel {
 
     func playItem(at indexPath: IndexPath) {
         guard let item = item(at: indexPath) else { return }
-        if let index = currentPlayingItemIndex {
-            playlistItemsService.setStatus(for: index, status: .stopped)
-            reloadContent?(.item(IndexPath(row: index, section: 0)))
-            currentPlayingItemIndex = nil
+        if item.queues {
+            playerService.queue(url: item.url)
+            if currentPlayingItemIndex == nil {
+                currentPlayingItemIndex = indexPath.row
+            }
+        } else {
+            if let index = currentPlayingItemIndex {
+                playlistItemsService.setStatus(for: index, status: .stopped)
+                reloadContent?(.item(IndexPath(row: index, section: 0)))
+                currentPlayingItemIndex = nil
+            }
+            playerService.play(url: item.url)
+            currentPlayingItemIndex = indexPath.row
         }
-        playerService.play(url: item.url)
-        currentPlayingItemIndex = indexPath.row
     }
 }
 

AudioExample/AudioExample/Services/AudioContent.swift

@@ -12,10 +12,12 @@ enum AudioContent: Int, CaseIterable {
     case offradio
     case enlefko
     case pepper966
+    case kosmos
     case radiox
     case khruangbin
     case piano
     case local
+    case podcast
 
     var title: String {
         switch self {
@@ -25,6 +27,8 @@ enum AudioContent: Int, CaseIterable {
             return "Enlefko (stream)"
         case .pepper966:
             return "Pepper 96.6 (stream)"
+        case .kosmos:
+            return "Kosmos 93.6 (stream)"
         case .radiox:
             return "Radio X (stream)"
         case .khruangbin:
@@ -33,6 +37,8 @@ enum AudioContent: Int, CaseIterable {
             return "Piano (mp3)"
         case .local:
             return "Local file (mp3)"
+        case .podcast:
+            return "Swift by Sundell. Ep. 50 (mp3)"
         }
     }
 
@@ -44,6 +50,8 @@ enum AudioContent: Int, CaseIterable {
             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")!
+        case .kosmos:
+            return URL(string: "https://radiostreaming.ert.gr/ert-kosmos")!
         case .radiox:
             return URL(string: "https://media-ssl.musicradio.com/RadioXLondon")!
         case .khruangbin:
@@ -53,6 +61,8 @@ enum AudioContent: Int, CaseIterable {
         case .local:
             let path = Bundle.main.path(forResource: "bensound-jazzyfrenchy", ofType: "mp3")!
             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")!
         }
     }
 }

AudioExample/AudioExample/Services/AudioPlayerService.swift

@@ -56,6 +56,11 @@ final class AudioPlayerService {
         player.play(url: url)
     }
 
+    func queue(url: URL) {
+        activateAudioSession()
+        player.queue(url: url)
+    }
+
     func stop() {
         player.stop()
         deactivateAudioSession()

AudioExample/AudioExample/Services/PlaylistItemsService.swift

@@ -19,17 +19,20 @@ struct PlaylistItem: Equatable {
     let url: URL
     let name: String
     let status: Status
+    let queues: Bool
 
-    init(content: AudioContent) {
+    init(content: AudioContent, queues: Bool) {
         name = content.title
         url = content.streamUrl
         status = .stopped
+        self.queues = queues
     }
 
-    init(url: URL, name: String, status: Status) {
+    init(url: URL, name: String, status: Status, queues: Bool) {
         self.url = url
         self.name = name
         self.status = status
+        self.queues = queues
     }
 }
 
@@ -70,10 +73,14 @@ final class PlaylistItemsService {
         guard let item = item(at: index) else {
             return
         }
-        items[index] = PlaylistItem(url: item.url, name: item.name, status: status)
+        items[index] = PlaylistItem(url: item.url, name: item.name, status: status, queues: item.queues)
     }
 }
 
 func provideInitialPlaylistItems() -> [PlaylistItem] {
-    AudioContent.allCases.map(PlaylistItem.init(content:))
+    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) }
+    return allItems + casesForQueuingItems
 }

AudioStreaming.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name = 'AudioStreaming'
-  s.version = '0.1.0'
+  s.version = '0.3.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'
@@ -13,9 +13,7 @@ Pod::Spec.new do |s|
 
   s.source_files = 'AudioStreaming/**/*.swift'
 
-  s.frameworks = 'AVFoundation', ' CoreAudio', 'AudioToolbox', 'Network'
-
   s.pod_target_xcconfig = {
     'SWIFT_INSTALL_OBJC_HEADER' => 'NO'
   }
-end
+end

AudioStreaming.xcodeproj/project.pbxproj

@@ -798,7 +798,7 @@
 					"@executable_path/Frameworks",
 					"@loader_path/Frameworks",
 				);
-				MARKETING_VERSION = 0.1.0;
+				MARKETING_VERSION = 0.3.0;
 				OTHER_LDFLAGS = "-ObjC";
 				PRODUCT_BUNDLE_IDENTIFIER = com.decimal.AudioStreaming;
 				PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)";
@@ -828,7 +828,7 @@
 					"@executable_path/Frameworks",
 					"@loader_path/Frameworks",
 				);
-				MARKETING_VERSION = 0.1.0;
+				MARKETING_VERSION = 0.3.0;
 				OTHER_LDFLAGS = "-ObjC";
 				PRODUCT_BUNDLE_IDENTIFIER = com.decimal.AudioStreaming;
 				PRODUCT_NAME = "$(TARGET_NAME:c99extidentifier)";

AudioStreaming/Streaming/Audio Entry/AudioSource/CoreAudioSource.swift

@@ -1,278 +0,0 @@
-//
-//  Created by Dimitrios Chatzieleftheriou on 27/05/2020.
-//  Copyright © 2020 Decimal. All rights reserved.
-//
-
-import AudioToolbox
-import Foundation
-
-typealias CoreAudioURLBlock = (URL) -> Void
-
-public class RemoteAudioSource: NSObject, AudioStreamSource {
-    var inputStream: InputStream?
-
-    weak var delegate: AudioStreamSourceDelegate?
-
-    var position: Int {
-        return seekOffset + relativePosition
-    }
-
-    var length: Int {
-        guard let parsedHeader = parsedHeaderOutput else { return 0 }
-        return parsedHeader.fileLength
-    }
-
-    private let url: URL
-    private let networking: NetworkingClient
-    internal let metadataStreamProccessor: MetadataStreamSource
-    private var streamRequest: NetworkDataStream?
-
-    private var additionalRequestHeaders: [String: String]
-    private var httpStatusCode: Int
-
-    private var httpResponse: HTTPURLResponse?
-    private var parsedHeaderOutput: HTTPHeaderParserOutput?
-    private var relativePosition: Int
-    private var seekOffset: Int
-
-    internal var dispatchQueue: DispatchQueue?
-
-    init(networking: NetworkingClient,
-         metadataStreamSource: MetadataStreamSource,
-         url: URL,
-         httpHeaders: [String: String])
-    {
-        self.networking = networking
-        metadataStreamProccessor = metadataStreamSource
-        self.url = url
-        additionalRequestHeaders = httpHeaders
-        httpStatusCode = 0
-        relativePosition = 0
-        seekOffset = 0
-    }
-
-    convenience init(networking: NetworkingClient, url: URL, httpHeaders: [String: String]) {
-        let metadataParser = MetadataParser()
-        let metadataProccessor = MetadataStreamProccessor(parser: metadataParser.eraseToAnyParser())
-        self.init(networking: networking,
-                  metadataStreamSource: metadataProccessor,
-                  url: url,
-                  httpHeaders: httpHeaders)
-    }
-
-    convenience init(networking: NetworkingClient, url: URL) {
-        self.init(networking: networking,
-                  url: url,
-                  httpHeaders: [:])
-    }
-
-    func setup(for queue: DispatchQueue) {
-        dispatchQueue = queue
-
-        guard let stream = inputStream else {
-            return
-        }
-
-        stream.delegate = self
-        stream.set(onQueue: queue)
-
-        return
-    }
-
-    func removeFromQueue() {
-        guard let stream = inputStream else { return }
-        stream.delegate = nil
-        stream.unsetFromQueue()
-    }
-
-    func close() {
-        if inputStream != nil {
-            if dispatchQueue != nil {
-                removeFromQueue()
-            }
-            inputStream?.close()
-            inputStream = nil
-        }
-    }
-
-    func seek(at offset: Int) {
-        guard let queue = dispatchQueue else {
-            return
-        }
-        dispatchPrecondition(condition: .onQueue(queue))
-
-        close()
-
-        relativePosition = 0
-        seekOffset = offset
-
-        if let supportsSeek = parsedHeaderOutput?.supportsSeek,
-           !supportsSeek, offset != relativePosition
-        {
-            return
-        }
-
-        performOpen(seek: seekOffset)
-    }
-
-    func audioFileHint() -> AudioFileTypeID {
-        return audioFileType(fileExtension: url.pathExtension)
-    }
-
-    func read(into buffer: UnsafeMutablePointer<UInt8>, size: Int) -> Int {
-        return performRead(into: buffer, size: size)
-    }
-
-    // MARK: Private
-
-    private func performRead(into buffer: UnsafeMutablePointer<UInt8>, size: Int) -> Int {
-        guard size != 0 else { return 0 }
-        guard let stream = inputStream else { return 0 }
-
-        var read: Int = 0
-        // Metadata parsing
-//        if metadataStreamProccessor.canProccessMetadata {
-//            read = metadataStreamProccessor.proccessFromRead(into: buffer, size: size, using: stream) { [weak self] position in
-//                self?.relativePosition += position
-//            }
-//        } else {
-        read = stream.read(buffer, maxLength: size)
-//        }
-
-        guard read > 0 else { return read }
-        relativePosition += read
-
-        return read
-    }
-
-    private func performOpen(seek seekOffset: Int) {
-        let urlRequest = buildUrlRequest(with: url, seekIfNeeded: seekOffset)
-
-        let streamRequest = networking.stream(request: urlRequest)
-            .responseStream(on: .global(qos: .default)) { [weak self] event in
-                switch event {
-                case let .stream(result):
-                    switch result {
-                    case let .success(response):
-                        self?.httpResponse = response.response
-                    default:
-                        break
-                    }
-                case let .complete(completion):
-                    print(completion)
-                }
-            }
-        self.streamRequest = streamRequest
-        inputStream = streamRequest.asInputStream()
-
-        guard let inputStream = inputStream else {
-            errorOccured()
-            return
-        }
-
-        inputStream.setProperty(StreamNetworkServiceTypeValue.background, forKey: .networkServiceType)
-
-        if let scheme = url.scheme, scheme == "https" {
-            inputStream.setProperty(StreamSocketSecurityLevel.negotiatedSSL, forKey: .socketSecurityLevelKey)
-            let sslSettings: [String: Any] = [kCFStreamSSLValidatesCertificateChain as String: false]
-            inputStream.setProperty(sslSettings, forKey: kCFStreamPropertySSLSettings as Stream.PropertyKey)
-        }
-
-        performSoftSetup()
-        httpStatusCode = 0
-
-        inputStream.open()
-    }
-
-    private func parseHeader(response: HTTPURLResponse?) -> Bool {
-        guard let response = response else { return false }
-        httpStatusCode = response.statusCode
-        // parse the header response
-        let parser = HTTPHeaderParser()
-        parsedHeaderOutput = parser.parse(input: response)
-        // check to see if we have metadata to proccess
-        if let metadataStep = parsedHeaderOutput?.metadataStep {
-            metadataStreamProccessor.metadataAvailable(step: metadataStep)
-        }
-        // check for error
-        if httpStatusCode == 416 { // range not satisfied error
-            if length >= 0 { seekOffset = length }
-            endOfFileOccurred()
-            return false
-        } else if httpStatusCode >= 300 {
-            errorOccured()
-            return false
-        }
-        return true
-    }
-
-    private func performSoftSetup() {
-        guard let queue = dispatchQueue, let inputStream = inputStream else { return }
-        inputStream.delegate = self
-        inputStream.set(onQueue: queue)
-    }
-
-    private func buildUrlRequest(with _: URL, seekIfNeeded seekOffset: Int) -> URLRequest {
-        var urlRequest = URLRequest(url: url)
-        urlRequest.timeoutInterval = 30
-        urlRequest.networkServiceType = .avStreaming
-
-        for header in additionalRequestHeaders {
-            urlRequest.addValue(header.value, forHTTPHeaderField: header.key)
-        }
-        urlRequest.addValue("*/*", forHTTPHeaderField: "Accept")
-        urlRequest.addValue("1", forHTTPHeaderField: "Icy-Metadata")
-
-        if let supportsSeek = parsedHeaderOutput?.supportsSeek, supportsSeek, seekOffset > 0 {
-            urlRequest.addValue("bytes=\(seekOffset)", forHTTPHeaderField: "Range")
-        }
-
-        return urlRequest
-    }
-}
-
-// MARK: StreamEventsSource
-
-extension RemoteAudioSource: StreamEventsSource {
-    func openCompleted() {
-        print("open completed")
-    }
-
-    func dataAvailable() {
-        guard inputStream != nil else { return }
-        if httpStatusCode == 0 {
-            guard parseHeader(response: httpResponse) else { return }
-            if hasBytesAvailable {
-                delegate?.dataAvailable(source: self)
-            }
-        } else {
-            delegate?.dataAvailable(source: self)
-        }
-    }
-
-    func endOfFileOccurred() {
-        delegate?.endOfFileOccured(source: self)
-    }
-
-    func errorOccured() {
-        delegate?.errorOccured(source: self)
-    }
-}
-
-// MARK: StreamDelegate
-
-extension RemoteAudioSource: StreamDelegate {
-    public func stream(_: Stream, handle eventCode: Stream.Event) {
-        switch eventCode {
-        case .openCompleted:
-            openCompleted()
-        case .hasBytesAvailable:
-            dataAvailable()
-        case .endEncountered:
-            endOfFileOccurred()
-        case .errorOccurred:
-            errorOccured()
-        default: break
-        }
-    }
-}

AudioStreaming/Streaming/Audio Source/FileAudioSource.swift

@@ -41,6 +41,10 @@ final class FileAudioSource: NSObject, CoreAudioStreamSource {
         length = 0
     }
 
+    deinit {
+        buffer.deallocate()
+    }
+
     func close() {
         guard let inputStream = inputStream else {
             return

AudioStreaming/Streaming/Audio Source/RemoteAudioSource.swift

@@ -29,6 +29,7 @@ public class RemoteAudioSource: AudioStreamSource {
     private var parsedHeaderOutput: HTTPHeaderParserOutput?
     private var relativePosition: Int
     private var seekOffset: Int
+    private var supportsSeek: Bool
 
     internal var metadataStreamProcessor: MetadataStreamSource
 
@@ -59,6 +60,7 @@ public class RemoteAudioSource: AudioStreamSource {
         additionalRequestHeaders = httpHeaders
         relativePosition = 0
         seekOffset = 0
+        supportsSeek = false
         netStatusService = netStatusProvider
         self.underlyingQueue = underlyingQueue
         streamOperationQueue = OperationQueue()
@@ -116,9 +118,7 @@ public class RemoteAudioSource: AudioStreamSource {
         relativePosition = 0
         seekOffset = offset
 
-        if let supportsSeek = parsedHeaderOutput?.supportsSeek,
-           !supportsSeek, offset != relativePosition
-        {
+        if !supportsSeek, offset != relativePosition {
             return
         }
 
@@ -189,9 +189,9 @@ public class RemoteAudioSource: AudioStreamSource {
     private func handleStreamEvent(event: NetworkDataStream.StreamResult) {
         switch event {
         case let .success(value):
-            addStreamOperation { [weak self] in
-                guard let self = self else { return }
-                if let data = value.data {
+            if let data = value.data {
+                addStreamOperation { [weak self] in
+                    guard let self = self else { return }
                     if self.metadataStreamProcessor.canProccessMetadata {
                         let extractedAudioData = self.metadataStreamProcessor.proccessMetadata(data: data)
                         self.delegate?.dataAvailable(source: self, data: extractedAudioData)
@@ -216,6 +216,11 @@ public class RemoteAudioSource: AudioStreamSource {
         let httpStatusCode = response.statusCode
         let parser = HTTPHeaderParser()
         parsedHeaderOutput = parser.parse(input: response)
+
+        if let acceptRanges = parser.value(forHTTPHeaderField: HeaderField.acceptRanges, in: response) {
+            supportsSeek = acceptRanges != "none"
+        }
+
         // check to see if we have metadata to proccess
         if let metadataStep = parsedHeaderOutput?.metadataStep {
             metadataStreamProcessor.metadataAvailable(step: metadataStep)
@@ -242,7 +247,7 @@ public class RemoteAudioSource: AudioStreamSource {
         urlRequest.addValue("1", forHTTPHeaderField: "Icy-MetaData")
         urlRequest.addValue("identity", forHTTPHeaderField: "Accept-Encoding")
 
-        if let supportsSeek = parsedHeaderOutput?.supportsSeek, supportsSeek, seekOffset > 0 {
+        if supportsSeek && seekOffset > 0 {
             urlRequest.addValue("bytes=\(seekOffset)-", forHTTPHeaderField: "Range")
         }
         return urlRequest

AudioStreaming/Streaming/AudioPlayer/AudioPlayer.swift

@@ -70,7 +70,14 @@ public final class AudioPlayer {
         playerContext.entriesLock.lock()
         let playingEntry = playerContext.audioPlayingEntry
         playerContext.entriesLock.unlock()
-        guard let entry = playingEntry, !entry.seekRequest.requested else { return 0 }
+        guard let entry = playingEntry else { return 0 }
+        entry.seekRequest.lock.lock()
+        let seekRequested = entry.seekRequest.requested
+        let seekTime = entry.seekRequest.time
+        entry.seekRequest.lock.unlock()
+        if seekRequested {
+            return seekTime
+        }
         return entry.progress
     }
 
@@ -109,7 +116,7 @@ public final class AudioPlayer {
     let playerRenderProcessor: AudioPlayerRenderProcessor
 
     private let audioReadSource: DispatchTimerSource
-    private let underlyingQueue = DispatchQueue(label: "streaming.core.queue", qos: .userInitiated, attributes: .concurrent)
+    private let serializationQueue: DispatchQueue
     private let sourceQueue: DispatchQueue
 
     private let entryProvider: AudioEntryProviding
@@ -123,7 +130,8 @@ public final class AudioPlayer {
         playerContext = AudioPlayerContext()
         entriesQueue = PlayerQueueEntries()
 
-        sourceQueue = DispatchQueue(label: "source.queue", qos: .userInitiated, target: underlyingQueue)
+        serializationQueue = DispatchQueue(label: "streaming.core.queue", qos: .userInitiated)
+        sourceQueue = DispatchQueue(label: "source.queue", qos: .userInitiated)
         audioReadSource = DispatchTimerSource(interval: .milliseconds(200), queue: sourceQueue)
 
         entryProvider = AudioEntryProvider(networkingClient: NetworkingClient(),
@@ -144,7 +152,6 @@ public final class AudioPlayer {
     }
 
     deinit {
-        // todo more stuff to release...
         playerContext.audioPlayingEntry?.close()
         clearQueue()
         stopReadProccessFromSource()
@@ -167,18 +174,21 @@ public final class AudioPlayer {
     public func play(url: URL, headers: [String: String]) {
         let audioEntry = entryProvider.provideAudioEntry(url: url, headers: headers)
         audioEntry.delegate = self
-        clearQueue()
-        entriesQueue.enqueue(item: audioEntry, type: .upcoming)
-        playerContext.setInternalState(to: .pendingNext)
 
         checkRenderWaitingAndNotifyIfNeeded()
-        sourceQueue.async { [weak self] in
-            guard let self = self else { return }
+        serializationQueue.sync {
+            clearQueue()
+            entriesQueue.enqueue(item: audioEntry, type: .upcoming)
+            playerContext.setInternalState(to: .pendingNext)
             do {
                 try self.startEngineIfNeeded()
             } catch {
                 self.raiseUnxpected(error: .audioSystemError(.engineFailure))
             }
+        }
+
+        sourceQueue.async { [weak self] in
+            guard let self = self else { return }
             self.processSource()
             self.startReadProcessFromSourceIfNeeded()
         }
@@ -186,19 +196,47 @@ public final class AudioPlayer {
 
     /// Queues the specified URL
     ///
-    /// - Parameter url: A `URL` specifying the audio context to be played.
+    /// - Parameter url: A `URL` specifying the audio content to be played.
     public func queue(url: URL) {
         queue(url: url, headers: [:])
     }
 
+    /// Queues the specified URLs
+    ///
+    /// - Parameter url: A `URL` specifying the audio content to be played.
+    public func queue(urls: [URL]) {
+        queue(urls: urls, headers: [:])
+    }
+
     /// Queues the specified URL
     ///
-    /// - Parameter url: A `URL` specifying the audio context to be played.
+    /// - Parameter url: A `URL` specifying the audio content to be played.
     /// - parameter headers: A `Dictionary` specifying any additional headers to be pass to the network request.
     public func queue(url: URL, headers: [String: String]) {
-        let audioEntry = entryProvider.provideAudioEntry(url: url, headers: headers)
-        audioEntry.delegate = self
-        entriesQueue.enqueue(item: audioEntry, type: .upcoming)
+        serializationQueue.sync {
+            let audioEntry = entryProvider.provideAudioEntry(url: url, headers: headers)
+            audioEntry.delegate = self
+            entriesQueue.enqueue(item: audioEntry, type: .upcoming)
+        }
+        checkRenderWaitingAndNotifyIfNeeded()
+        sourceQueue.async { [weak self] in
+            self?.processSource()
+        }
+    }
+
+    /// Queues the specified URLs
+    ///
+    /// - Parameter url: A array of `URL`s specifying the audio content to be played.
+    /// - parameter headers: A `Dictionary` specifying any additional headers to be pass to the network request.
+    public func queue(urls: [URL], headers: [String: String]) {
+        serializationQueue.sync {
+            for url in urls {
+                let audioEntry = entryProvider.provideAudioEntry(url: url, headers: headers)
+                audioEntry.delegate = self
+                entriesQueue.enqueue(item: audioEntry, type: .upcoming)
+            }
+        }
+        checkRenderWaitingAndNotifyIfNeeded()
         sourceQueue.async { [weak self] in
             self?.processSource()
         }
@@ -208,8 +246,11 @@ public final class AudioPlayer {
     public func stop() {
         guard playerContext.internalState != .stopped else { return }
 
-        stopEngine(reason: .userAction)
         stopReadProccessFromSource()
+        serializationQueue.sync {
+            stopEngine(reason: .userAction)
+        }
+        checkRenderWaitingAndNotifyIfNeeded()
         sourceQueue.async { [weak self] in
             guard let self = self else { return }
             self.playerContext.audioReadingEntry?.delegate = nil
@@ -226,7 +267,6 @@ public final class AudioPlayer {
 
             self.processSource()
         }
-        checkRenderWaitingAndNotifyIfNeeded()
     }
 
     /// Pauses the audio playback
@@ -234,8 +274,9 @@ public final class AudioPlayer {
         if playerContext.internalState != .paused, playerContext.internalState.contains(.running) {
             stateBeforePaused = playerContext.internalState
             playerContext.setInternalState(to: .paused)
-
-            pauseEngine()
+            serializationQueue.sync {
+                pauseEngine()
+            }
             stopReadProccessFromSource()
             playerContext.audioPlayingEntry?.suspend()
             sourceQueue.async { [weak self] in
@@ -248,20 +289,20 @@ public final class AudioPlayer {
     public func resume() {
         guard playerContext.internalState == .paused else { return }
         playerContext.setInternalState(to: stateBeforePaused)
-        // check if seek time requested and reset buffers
-        do {
-            try startEngine()
-        } catch {
-            Logger.debug("resuming audio engine failed: %@", category: .generic, args: error.localizedDescription)
-        }
-
-        if let playingEntry = playerContext.audioReadingEntry {
-            if playingEntry.seekRequest.requested {
-                rendererContext.resetBuffers()
+        serializationQueue.sync {
+            do {
+                try startEngine()
+            } catch {
+                Logger.debug("resuming audio engine failed: %@", category: .generic, args: error.localizedDescription)
             }
-            playingEntry.resume()
+            if let playingEntry = playerContext.audioReadingEntry {
+                if playingEntry.seekRequest.requested {
+                    rendererContext.resetBuffers()
+                }
+                playingEntry.resume()
+            }
+            startPlayer(resetBuffers: false)
         }
-        startPlayer(resetBuffers: false)
         startReadProcessFromSourceIfNeeded()
     }
 
@@ -375,9 +416,11 @@ public final class AudioPlayer {
 
         playerRenderProcessor.audioFinishedPlaying = { [weak self] entry in
             guard let self = self else { return }
-            self.sourceQueue.async {
+            self.serializationQueue.sync {
                 let nextEntry = self.entriesQueue.dequeue(type: .buffering)
                 self.processFinishPlaying(entry: entry, with: nextEntry)
+            }
+            self.sourceQueue.async {
                 self.processSource()
             }
         }
@@ -455,10 +498,6 @@ public final class AudioPlayer {
     ///
     /// - parameter reason: A value of `AudioPlayerStopReason` indicating the reason the engine stopped.
     private func stopEngine(reason: AudioPlayerStopReason) {
-        guard isEngineRunning && player.auAudioUnit.isRunning else {
-            Logger.debug("already already stopped 🛑", category: .generic)
-            return
-        }
         audioEngine.stop()
         player.auAudioUnit.stopHardware()
         rendererContext.resetBuffers()
@@ -491,11 +530,8 @@ public final class AudioPlayer {
         if resetBuffers {
             rendererContext.resetBuffers()
         }
-        if !isEngineRunning && !player.auAudioUnit.isRunning {
-            Logger.debug("trying to start the player when audio engine and player are already running", category: .generic)
-            return
-        }
         do {
+            try startEngineIfNeeded()
             try player.auAudioUnit.allocateRenderResources()
             try player.auAudioUnit.startHardware()
         } catch {
@@ -542,7 +578,7 @@ public final class AudioPlayer {
                 let entry = entriesQueue.dequeue(type: .upcoming)
                 let shouldStartPlaying = playerContext.audioPlayingEntry == nil
                 playerContext.setInternalState(to: .waitingForData)
-                setCurrentReading(entry: entry, startPlaying: shouldStartPlaying, shouldClearQueue: true)
+                setCurrentReading(entry: entry, startPlaying: shouldStartPlaying, shouldClearQueue: false)
             } else if playerContext.audioPlayingEntry == nil {
                 if playerContext.internalState != .stopped {
                     stopReadProccessFromSource()
@@ -574,7 +610,8 @@ public final class AudioPlayer {
     }
 
     private func proccessSeekTime() {
-        assert(playerContext.audioReadingEntry === playerContext.audioPlayingEntry, "reading and playing entry must be the same")
+        assert(playerContext.audioReadingEntry === playerContext.audioPlayingEntry,
+               "reading and playing entry must be the same")
         fileStreamProcessor.processSeek()
     }
 
@@ -662,7 +699,9 @@ public final class AudioPlayer {
             playerContext.audioPlayingEntry = nil
             playerContext.entriesLock.unlock()
         }
-        processSource()
+        sourceQueue.async { [weak self] in
+            self?.processSource()
+        }
         checkRenderWaitingAndNotifyIfNeeded()
     }
 

AudioStreaming/Streaming/AudioPlayer/Processors/AudioFileStreamProcessor.swift

@@ -191,7 +191,11 @@ final class AudioFileStreamProcessor {
             guard AudioFileStreamGetProperty(fileStream, kAudioFileStreamProperty_MagicCookieData, &cookieSize, &cookie) == noErr else {
                 return
             }
-            guard AudioFileStreamSetProperty(fileStream, kAudioConverterDecompressionMagicCookie, cookieSize, cookie) == noErr else {
+            guard let converter = audioConverter else {
+                fileStreamCallback?(.raiseError(.audioSystemError(.fileStreamError(.unknownError))))
+                 return
+            }
+            guard AudioConverterSetProperty(converter, kAudioConverterDecompressionMagicCookie, cookieSize, cookie) == noErr else {
                 fileStreamCallback?(.raiseError(.audioSystemError(.fileStreamError(.unknownError))))
                 return
             }
@@ -382,41 +386,43 @@ final class AudioFileStreamProcessor {
             var start = bufferContext.frameStartIndex
             var end = bufferContext.end
 
-            var framesLeftInBuffer = max(bufferContext.totalFrameCount &- used, 0)
+            var framesLeftInBuffer = bufferContext.totalFrameCount - used
             rendererContext.lock.unlock()
 
             if framesLeftInBuffer == 0 {
-                rendererContext.lock.lock()
-                let bufferContext = rendererContext.bufferContext
-                used = bufferContext.frameUsedCount
-                start = bufferContext.frameStartIndex
-                end = bufferContext.end
-                framesLeftInBuffer = max(bufferContext.totalFrameCount &- used, 0)
-                rendererContext.lock.unlock()
-                if framesLeftInBuffer > 0 {
-                    break packetProccess
-                }
-                if playerContext.disposedRequested
-                    || playerContext.internalState == .disposed
-                    || playerContext.internalState == .pendingNext
-                    || playerContext.internalState == .stopped
-                {
-                    return
-                }
-
-                if let playingEntry = playerContext.audioPlayingEntry,
-                   playingEntry.seekRequest.requested, playingEntry.calculatedBitrate() > 0
-                {
-                    fileStreamCallback?(.proccessSource)
-                    if rendererContext.waiting.value {
-                        rendererContext.packetsSemaphore.signal()
+                while true {
+                    rendererContext.lock.lock()
+                    let bufferContext = rendererContext.bufferContext
+                    used = bufferContext.frameUsedCount
+                    start = bufferContext.frameStartIndex
+                    end = (bufferContext.frameStartIndex + bufferContext.frameUsedCount) % bufferContext.totalFrameCount
+                    framesLeftInBuffer = bufferContext.totalFrameCount - used
+                    rendererContext.lock.unlock()
+                    if framesLeftInBuffer > 0 {
+                        break
+                    }
+                    if playerContext.disposedRequested
+                        || playerContext.internalState == .disposed
+                        || playerContext.internalState == .pendingNext
+                        || playerContext.internalState == .stopped
+                    {
+                        return
                     }
-                    return
-                }
 
-                rendererContext.waiting.write { $0 = true }
-                rendererContext.packetsSemaphore.wait()
-                rendererContext.waiting.write { $0 = false }
+                    if let playingEntry = playerContext.audioPlayingEntry,
+                       playingEntry.seekRequest.requested, playingEntry.calculatedBitrate() > 0
+                    {
+                        fileStreamCallback?(.proccessSource)
+                        if rendererContext.waiting.value {
+                            rendererContext.packetsSemaphore.signal()
+                        }
+                        return
+                    }
+
+                    rendererContext.waiting.write { $0 = true }
+                    rendererContext.packetsSemaphore.wait()
+                    rendererContext.waiting.write { $0 = false }
+                }
             }
 
             let localBufferList = AudioBufferList.allocate(maximumBuffers: 1)
@@ -444,7 +450,7 @@ final class AudioFileStreamProcessor {
                     fillUsedFrames(framesCount: framesAdded)
                     return
                 } else if status != 0 {
-                    /// raise undexpected error... codec error
+                    fileStreamCallback?(.raiseError(.codecError))
                     return
                 }
 
@@ -473,7 +479,7 @@ final class AudioFileStreamProcessor {
                     fillUsedFrames(framesCount: framesAdded)
                     continue packetProccess
                 } else if status != 0 {
-                    /// raise undexpected error... codec error
+                    fileStreamCallback?(.raiseError(.codecError))
                     return
                 }
             } else {
@@ -500,7 +506,7 @@ final class AudioFileStreamProcessor {
                     fillUsedFrames(framesCount: framesAdded)
                     continue packetProccess
                 } else if status != 0 {
-                    /// raise undexpected error... codec error
+                    fileStreamCallback?(.raiseError(.codecError))
                     return
                 }
             }

AudioStreaming/Streaming/Parsers/HTTPHeaderParser.swift

@@ -18,22 +18,29 @@ enum IcyHeaderField {
 }
 
 struct HTTPHeaderParserOutput {
-    let supportsSeek: Bool
     let fileLength: Int
     let typeId: AudioFileTypeID
     // Metadata Support
     let metadataStep: Int
 }
 
-struct HTTPHeaderParser: Parser {
+protocol HTTPHeaderParsing: Parser {
+    /// Returns the value for the given field of the headers in the given `HTTPURLResponse`
+    ///
+    /// - Parameters:
+    ///   - field: The header field to be searched
+    ///   - response: The `HTTPURLResponse` for the header
+    /// - Returns: A `String` if the field exists in the headers otherwise `nil`
+    func value(forHTTPHeaderField field: String, in response: HTTPURLResponse) -> String?
+}
+
+struct HTTPHeaderParser: HTTPHeaderParsing {
     typealias Input = HTTPURLResponse
     typealias Output = HTTPHeaderParserOutput?
 
     func parse(input: HTTPURLResponse) -> HTTPHeaderParserOutput? {
         guard let headers = input.allHeaderFields as? [String: String], !headers.isEmpty else { return nil }
 
-        let supportsSeek = headers[HeaderField.acceptRanges] != "none"
-
         var typeId: UInt32 = 0
         if let contentType = input.mimeType {
             typeId = audioFileType(mimeType: contentType)
@@ -41,13 +48,12 @@ struct HTTPHeaderParser: Parser {
 
         var fileLength: Int = 0
         if input.statusCode == 200 {
-            if let contentLength = headers[HeaderField.contentLength],
-               let length = Int(contentLength)
-            {
+            let contentLength = value(forHTTPHeaderField: HeaderField.contentLength, in: input)
+            if let contentLength = contentLength, let length = Int(contentLength) {
                 fileLength = length
             }
         } else if input.statusCode == 206 {
-            if let contentLength = headers[HeaderField.contentRange] {
+            if let contentLength = value(forHTTPHeaderField: HeaderField.contentRange, in: input) {
                 let components = contentLength.components(separatedBy: "/")
                 if components.count == 2 {
                     if let last = components.last, let length = Int(last) {
@@ -58,15 +64,38 @@ struct HTTPHeaderParser: Parser {
         }
 
         var metadataStep = 0
-        if let icyMetaint = headers[IcyHeaderField.icyMentaint],
+        if let icyMetaint = value(forHTTPHeaderField: IcyHeaderField.icyMentaint, in: input),
            let intValue = Int(icyMetaint)
         {
             metadataStep = intValue
         }
 
-        return HTTPHeaderParserOutput(supportsSeek: supportsSeek,
-                                      fileLength: fileLength,
+        return HTTPHeaderParserOutput(fileLength: fileLength,
                                       typeId: typeId,
                                       metadataStep: metadataStep)
     }
 }
+
+extension Parser where Self: HTTPHeaderParsing {
+    func value(forHTTPHeaderField field: String, in response: HTTPURLResponse) -> String? {
+        if #available(iOS 13.0, *) {
+            return response.value(forHTTPHeaderField: field)
+        } else {
+            if let fields = response.allHeaderFields as? [String: String] {
+                return valueForCaseInsensitiveKey(field, fields: fields)
+            } else {
+                return nil
+            }
+        }
+    }
+
+    private func valueForCaseInsensitiveKey(_ key: String, fields: [String: String]) -> String? {
+        let keyToBeFound = key.lowercased()
+        for (key, value) in fields {
+            if key.lowercased() == keyToBeFound {
+                return value
+            }
+        }
+        return nil
+    }
+}

AudioStreamingTests/Streaming/Parsers/HTTPHeaderParserTests.swift

@@ -32,8 +32,7 @@ class HTTPHeaderParserTests: XCTestCase {
 
         // When
         let headers: [String: String] =
-            [HeaderField.acceptRanges: "range",
-             HeaderField.contentLength: "1000",
+            [HeaderField.contentLength: "1000",
              HeaderField.contentType: "audio/mp3",
              IcyHeaderField.icyMentaint: "16000"]
         let httpURLResponse = HTTPURLResponse(url: URL(string: "www.google.com")!,
@@ -46,23 +45,21 @@ class HTTPHeaderParserTests: XCTestCase {
         // Then
         XCTAssertNotNil(output)
         XCTAssertEqual(output!.fileLength, 1000)
-        XCTAssertEqual(output!.supportsSeek, true)
         XCTAssertEqual(output!.typeId, kAudioFileMP3Type)
         XCTAssertEqual(output!.metadataStep, 16000)
     }
 
-    func testReturnCorrectValuesOnRequestThatSupportsSeekRanges() throws {
+    func testReturnCorectValuesOnCaseInsensitiveHeaderFiels() throws {
         // Given
         let parser = HTTPHeaderParser()
 
         // When
         let headers: [String: String] =
-            [HeaderField.acceptRanges: "range",
-             HeaderField.contentLength: "1000",
-             HeaderField.contentType: "audio/mp3",
-             HeaderField.contentRange: "100/1000"]
+            [HeaderField.contentLength.lowercased(): "1000",
+             HeaderField.contentType.lowercased(): "audio/mp3",
+             IcyHeaderField.icyMentaint.lowercased(): "16000"]
         let httpURLResponse = HTTPURLResponse(url: URL(string: "www.google.com")!,
-                                              statusCode: 206,
+                                              statusCode: 200,
                                               httpVersion: "",
                                               headerFields: headers)
 
@@ -71,7 +68,7 @@ class HTTPHeaderParserTests: XCTestCase {
         // Then
         XCTAssertNotNil(output)
         XCTAssertEqual(output!.fileLength, 1000)
-        XCTAssertEqual(output!.supportsSeek, true)
         XCTAssertEqual(output!.typeId, kAudioFileMP3Type)
+        XCTAssertEqual(output!.metadataStep, 16000)
     }
 }

README.md

@@ -0,0 +1,168 @@
+![AudioStreaming CI](https://github.com/dimitris-c/AudioStreaming/workflows/AudioStreaming%20CI/badge.svg)
+
+# AudioStreaming
+An AudioPlayer/Streaming library for iOS written in Swift, allows playback of online audio streaming, local file as well as gapless queueing.
+
+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/avfoundation/audio_playback_recording_and_processing/avaudioengine/audio_units?language=swift).
+
+#### Supported audio
+- 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_)
+
+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) 
+
+
+# Requirements
+ - iOS 12.0+
+ - Swift 5.x
+
+# Using AudioStreaming
+
+### Playing an audio source over HTTP
+Note: You need to keep a reference to the `AudioPlayer` object
+```
+let player = AudioPlayer()
+player.play(url: URL(string: "https://your-remote-url/to/audio-file.mp3")!)
+```
+
+### Playing a local file 
+```
+let player = AudioPlayer()
+player.play(url: URL(fileURLWithPath: "your-local-path/to/audio-file.mp3")!)
+```
+### Queueing audio files
+```
+let player = AudioPlayer()
+// when you want to queue a single url
+player.queue(url: URL(string: "https://your-remote-url/to/audio-file.mp3")!)
+
+// or if you want to queue a list of urls use
+player.queue(urls: [
+    URL(fileURLWithPath: "your-local-path/to/audio-file.mp3")!,
+    URL(fileURLWithPath: "your-local-path/to/audio-file-2.mp3")!
+])
+```
+
+### Adjusting playback properties
+```
+let player = AudioPlayer()
+player.play(url: URL(fileURLWithPath: "your-local-path/to/audio-file.mp3")!)
+// adjust the playback rate
+player.rate = 2.0
+
+// adjusting the volume
+player.volume = 0.5
+
+// mute/unmute the audio
+player.mute = true
+
+// pause the playback
+player.pause()
+
+// resume the playback
+player.resume()
+
+// stop the playback
+player.stop()
+
+// seeking to to a time (in seconds)
+player.seek(to: 10)
+```
+
+### Audio playback properties
+```
+let player = AudioPlayer()
+player.play(url: URL(fileURLWithPath: "your-local-path/to/audio-file.mp3")!)
+
+// To get the audio file duration
+let duration = player.duration
+
+// To get the progress of the player
+let progress = player.progress
+
+// To get the state of the player, for possible values view the `AudioPlayerState` enum
+let state = player.state
+
+// To get the stop reason of the player, for possible values view the `AudioPlayerStopReason` enum
+let state = player.stopReason
+```
+
+### AudioPlayer Delegate
+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
+
+```
+let player = AudioPlayer()
+player.play(url: URL(fileURLWithPath: "your-local-path/to/audio-file.mp3")!)
+
+player.delegate = self // an object conforming to AudioPlayerDelegate
+
+// observing the audio player state, provides the new and previous state of the player.
+func audioPlayerStateChanged(player: AudioPlayer, with newState: AudioPlayerState, previous: AudioPlayerState) {}
+```
+
+### 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 
+
+```
+let reverbNode = AVAudioUnitReverb()
+reverbNode.wetDryMix = 50 
+
+let player = AudioPlayer()
+// attach a single node
+player.attach(node: reverbNode)
+
+// detach a single node
+player.detach(node: reverbNode)
+
+// detach all custom added nodes
+player.detachCustomAttachedNodes()
+```
+
+The example project shows an example of adding a custom `AVAudioUnitEQ` node for adding equaliser to the `AudioPlayer`
+
+# Installation
+
+### Cocoapods
+
+[Cocoapods](https://cocoapods.org/) is a dependency manager for Cocoa projects. You can install it with the following command:
+```
+$ gem install cocoapods
+```
+
+To intergrate AudioStreaming with [Cocoapods](https://cocoapods.org/) to your Xcode project add the following to your `Podfile`:
+```
+pod 'AudioStreaming'
+```
+
+### Swift Package Manager
+
+On Xcode 11.0+ you can add a new dependency by going to **File / Swift Packages / Add Package Dependency...**
+and enter package repository URL https://github.com/dimitris-c/AudioStreaming.git, then follow the instructions.
+
+### Carthage
+
+[Carthage](https://github.com/Carthage/Carthage) is a decentralized dependency manager that builds your dependencies and provides you with frameworks.
+
+You can install Carthage with Homebrew using the following command:
+```
+$ brew update
+$ brew install carthage
+```
+
+To integrate AudioStreaming into your Xcode project using Carthage, add the following to your `Cartfile`:
+```
+github "dimitris-c/AudioStreaming"
+```
+Visit [installation instructions](https://github.com/Carthage/Carthage#adding-frameworks-to-an-application) on Carthage to install the framework
+
+# Licence
+
+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).
+Big 🙏 to Thong Nguyen (@tumtumtum) and Matt Gallagher (@mattgallagher) for [AudioStreamer](https://github.com/mattgallagher/AudioStreamer)