Why AVPlayer downloading first instead live streaming?

Question

First time I am working with AVPlayer and I want to play a mp3 file using HTTP request with live streaming. I use AVPlayer that is working fine to play mp3 files, but the problem is AVPlayer needs to download the mp3 first then play it. I don't know why AVPlayer downloads the file and then play it instead of live playing. My Xcode 8.2.1 and I am using Swift 3.

Here is my code snippet.

var audioPlayer = AVPlayer()
var avplayerItem : AVPlayerItem?

override func viewDidLoad() {
    super.viewDidLoad()

    let fileurl:URL = URL(string : "http://www.noiseaddicts.com/samples_1w72b820/2514.mp3")!
    avplayerItem = AVPlayerItem(url : fileurl)
    audioPlayer = AVPlayer(playerItem : avplayerItem)
    audioPlayer.rate = 1.0
    audioPlayer.play()
}

In case of AVPlayer requires to download the whole file before playing it, what should I do for audio live streaming?

Thanks.

Answer 1

You are basically using mp3 as the container to transmit your audio throughout internet so the player must have to download it all, if you want to make it efficiently or avoid latency of the download you must use HLS, DASH, CMAF or WebRTC to transmit it, so the player will download it by chunks, and plays it while downloading, something similar to Spotify or Apple music does.

Answer 2

Edit for in addition: Also Luaan is right. "Live streaming needs server support - at least the ability to do partial downloads. Does some other player allow live streaming with that URL?" You should also try with an undefined duration sound url.

Have you tried to approach like it is an undefined duration audio stream ?

  avplayerItem = CachingPlayerItem(url: url, recordingName: recordingName ?? "default.mp3")

CachingPlayerItem going to prepare an AVURLAsset from the url.

 init(url: URL, customFileExtension: String?, recordingName: String) {
    guard let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
    let scheme = components.scheme,
    var urlWithCustomScheme = url.withScheme(cachingPlayerItemScheme) else {
    fatalError("Urls without a scheme are not supported")
    }
    self.recordingName = recordingName
    self.url = url
    self.initialScheme = scheme
    if let ext = customFileExtension {
    urlWithCustomScheme.deletePathExtension()
    urlWithCustomScheme.appendPathExtension(ext)
    self.customFileExtension = ext
    }
    let asset = AVURLAsset(url: urlWithCustomScheme)
    asset.resourceLoader.setDelegate(resourceLoaderDelegate, queue: DispatchQueue.main)
    super.init(asset: asset, automaticallyLoadedAssetKeys: nil)
    resourceLoaderDelegate.owner = self
    addObserver(self, forKeyPath: "status", options: NSKeyValueObservingOptions.new, context: nil)
    NotificationCenter.default.addObserver(self, selector: #selector(playbackStalledHandler), name:NSNotification.Name.AVPlayerItemPlaybackStalled, object: self)
    }

After AVPlayerItem is initialized, make an AVPlayer object from it so that it can kick start the process of loading audio stream from the given url:

player = AVPlayer(playerItem: playerItem)
player.automaticallyWaitsToMinimizeStalling = false

func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest) -> Bool {
if playingFromData {
// Nothing to load.
} else if session == nil {
// If we're playing from a url, we need to download the file.
// We start loading the file on first request only.
guard let initialUrl = owner?.url else {
fatalError("internal inconsistency")
}
startDataRequest(with: initialUrl)
}
pendingRequests.insert(loadingRequest)
processPendingRequests()
return true
}

Once resource is installed:

func startDataRequest(with url: URL) {
var recordingName = "default.mp3"
if let recording = owner?.recordingName{
recordingName = recording
}
fileURL = try! FileManager.default.url(for: .documentDirectory, in: .userDomainMask, appropriateFor: nil, create: false)
.appendingPathComponent(recordingName)
let configuration = URLSessionConfiguration.default
configuration.requestCachePolicy = .reloadIgnoringLocalAndRemoteCacheData
session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
session?.dataTask(with: url).resume()
outputStream = OutputStream(url: fileURL, append: true)
outputStream?.schedule(in: RunLoop.current, forMode: RunLoopMode.defaultRunLoopMode)
outputStream?.open()
}

Then, start receiving data bytes into the delegate function:

func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data)

Now you have started receiving live audio stream.

func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
let bytesWritten = data.withUnsafeBytes{outputStream?.write($0, maxLength: data.count)}
print("bytes written :\(bytesWritten!) to \(fileURL)")
}

Now create an OutputStream object, open it then append the bytes we are receiving in the above delegate function and thats it, we saved the desired part of the live audio stream.

Taken from: Medium Article, Mohan Pandey