Maintaining good scroll performance when using AVPlayer

Build your AVPlayerItem in a background queue as much as possible (some operations you have to do on the main thread, but you can do setup operations and waiting for video properties to load on background queues - read the docs very carefully). This involves voodoo dances with KVO and is really not fun.

The hiccups happen while the AVPlayer is waiting for the AVPlayerItems status to become AVPlayerItemStatusReadyToPlay. To reduce the length of the hiccups you want to do as much as you can to bring the AVPlayerItem closer to AVPlayerItemStatusReadyToPlay on a background thread before assigning it to the AVPlayer.

It's been a while since I actually implemented this, but IIRC the main thread blocks are caused because the underlying AVURLAsset's properties are lazy-loaded, and if you don't load them yourself, they get busy-loaded on the main thread when the AVPlayer wants to play.

Check out the AVAsset documentation, especially the stuff around AVAsynchronousKeyValueLoading. I think we needed to load the values for duration and tracks before using the asset on an AVPlayer to minimize the main thread blocks. It's possible we also had to walk through each of the tracks and do AVAsynchronousKeyValueLoading on each of the segments, but I don't remember 100%.

Don't know if this will help – but here's some code I'm using to load videos on background queue that definitely helps with main thread blocking (Apologies if it doesn't compile 1:1, I abstracted from a larger code base I'm working on):

func loadSource() {    self.status = .Unknown    let operation = NSBlockOperation()    operation.addExecutionBlock { () -> Void in    // create the asset    let asset = AVURLAsset(URL: self.mediaUrl, options: nil)    // load values for track keys    let keys = ["tracks", "duration"]    asset.loadValuesAsynchronouslyForKeys(keys, completionHandler: { () -> Void in        // Loop through and check to make sure keys loaded        var keyStatusError: NSError?        for key in keys {            var error: NSError?            let keyStatus: AVKeyValueStatus = asset.statusOfValueForKey(key, error: &error)            if keyStatus == .Failed {                let userInfo = [NSUnderlyingErrorKey : key]                keyStatusError = NSError(domain: MovieSourceErrorDomain, code: MovieSourceAssetFailedToLoadKeyValueErrorCode, userInfo: userInfo)                println("Failed to load key: \(key), error: \(error)")            }            else if keyStatus != .Loaded {                println("Warning: Ignoring key status: \(keyStatus), for key: \(key), error: \(error)")            }        }        if keyStatusError == nil {            if operation.cancelled == false {                let composition = self.createCompositionFromAsset(asset)                // register notifications                let playerItem = AVPlayerItem(asset: composition)                self.registerNotificationsForItem(playerItem)                self.playerItem = playerItem                // create the player                let player = AVPlayer(playerItem: playerItem)                self.player = player            }        }        else {            println("Failed to load asset: \(keyStatusError)")        }    })    // add operation to the queue    SomeBackgroundQueue.addOperation(operation)}func createCompositionFromAsset(asset: AVAsset, repeatCount: UInt8 = 16) -> AVMutableComposition {     let composition = AVMutableComposition()     let timescale = asset.duration.timescale     let duration = asset.duration.value     let editRange = CMTimeRangeMake(CMTimeMake(0, timescale), CMTimeMake(duration, timescale))     var error: NSError?     let success = composition.insertTimeRange(editRange, ofAsset: asset, atTime: composition.duration, error: &error)     if success {         for _ in 0 ..< repeatCount - 1 {          composition.insertTimeRange(editRange, ofAsset: asset, atTime: composition.duration, error: &error)         }     }     return composition}

If you look into Facebook's AsyncDisplayKit (the engine behind Facebook and Instagram feeds), you can render video for the most part on background threads using their AVideoNode. If you subnode that into an ASDisplayNode and add the displayNode.view to whatever view you are scrolling (table/collection/scroll), you can achieve perfectly smooth scrolling (just make sure they create the node and assets and all that on a background thread). The only issue is when having the change the video item, as this forces itself onto the main thread. If you only have a few videos on that particular view you are fine to use this method!

        dispatch_async(dispatch_get_global_queue(QOS_CLASS_BACKGROUND, 0), {            self.mainNode = ASDisplayNode()            self.videoNode = ASVideoNode()            self.videoNode!.asset = AVAsset(URL: self.videoUrl!)            self.videoNode!.frame = CGRectMake(0.0, 0.0, self.bounds.width, self.bounds.height)            self.videoNode!.gravity = AVLayerVideoGravityResizeAspectFill            self.videoNode!.shouldAutoplay = true            self.videoNode!.shouldAutorepeat = true            self.videoNode!.muted = true            self.videoNode!.playButton.hidden = true                        dispatch_async(dispatch_get_main_queue(), {                self.mainNode!.addSubnode(self.videoNode!)                self.addSubview(self.mainNode!.view)            })        })