Better way to do skip to previous with AVQueuePlayer?

I am using an AVQueuePlayer in my app. I have a two swipe gestures to skip to next and skip to previous avplayeritems. Right now to do skip to next I am just calling advanceToNextItem on the avqueueplayer which works well.

However the skip to previous I am removing all items and adding them back in with the previous video up front, this is really slow when skipping to previous multiple times. How can I make this faster just like calling advanceToNextItem?

  • AVQueuePlayer playback without gap and freeze
  • AVPlayer was deallocated while key value observers were still registered with it
  • AVPlayer does not fire playbackBufferEmpty but does not play either
  • How to close previous AVPlayer and AVPlayerItem
  • AVPlayer stalling on large video files using resource loader delegate
  • Swift AVPlayerItem close when finished
  • My code looks like this:

    func skipToPrevious() {
        queuePlayer.removeAllItems()
        // move the previous playerItem to the front of the list then add them all back in
        for playerItem in playerItems:
            queuePlayer.insertItem(playerItem, afterItem: nil)
    
    }
    

    4 Solutions Collect From Internet About “Better way to do skip to previous with AVQueuePlayer?”

    It seems like AVQueuePlayer removes the current item from the play queue when calling advanceToNextItem. Theoretically, there is no way to get this item back without rebuilding the queue.

    What you could do is use a standard AVPlayer, have an array of AVPlayerItems, and an integer index which keeps the index of the current track.

    Swift 3:

    let player = AVPlayer()
    let playerItems = [AVPlayerItem]() // your array of items
    var currentTrack = 0
    
    func previousTrack() {
        if currentTrack - 1 < 0 {
            currentTrack = (playerItems.count - 1) < 0 ? 0 : (playerItems.count - 1)
        } else {
            currentTrack -= 1
        }
    
        playTrack()
    }
    
    func nextTrack() {
        if currentTrack + 1 > playerItems.count {
            currentTrack = 0
        } else {
            currentTrack += 1;
        }
    
        playTrack()
    }
    
    func playTrack() {
    
        if playerItems.count > 0 {
            player.replaceCurrentItem(with: playerItems[currentTrack])
            player.play()
        }
    }
    

    Swift 2.x:

    func previousTrack() {
        if currentTrack-- < 0 {
            currentTrack = (playerItems.count - 1) < 0 ? 0 : (playerItems.count - 1)
        } else {
            currentTrack--
        }
    
        playTrack()
    }
    
    func nextTrack() {
        if currentTrack++ > playerItems.count {
            currentTrack = 0
        } else {
            currentTrack++;
        }
    
        playTrack()
    }
    
    func playTrack() {
    
        if playerItems.count > 0 {
            player.replaceCurrentItemWithPlayerItem(playerItems[currentTrack])
            player.play()
        }
    }
    

    does the queue handle more than one skip forward smoothly? if so, you could constantly re-insert the previous video back into the queue at index n+2. when the user wishes to play the previous track, you would skip forward twice.

    if playing from track A to F without any skips, the pattern would look like this:

    A B C D E F
    B C D E F
    
    // re-insert A after next track
    B C A D E F
    C A D E F
    
    // remove A then re-insert B
    C D E F
    C D B E F
    D B E F
    
    // remove B then re-insert C
    D E F
    D E C F
    E C F
    
    // remove C then re-insert D
    E F
    E F D
    F D
    
    // remove D then re-insert E
    F
    FE
    

    using this pattern you could only smoothly skip backwards once, but it could be modified to allow more.

    definitely not an ideal solution, but may work!

    the replaceCurrentItemWithPlayerItem had limitation and should be avoided when possible, in Apple’s document, it states “The new item must have the same compositor as the item it replaces, or have no compositor.”

    instead insert the playerItems one by one using a loop, just create an AVQueuePlayer would be faster:

    func skipToPrevious() {
        queuePlayer = AVQueuePlayer.queuePlayerWithItems(playerItem)
    }
    

    I am thinking a very different approach which is in fact in terms of advanceToNextItem method. You said that advanceToNextItem works fine. So I am wondering if you can implement the skip to previous using advanceToNextItem itself but by pointing the queue two items backwards of the current playing item.

    E.g. if you your queue is this and the bold one is the current item

    A B C D E F G H

    Then set the current item to C and then use advanceToNextItem so that it plays D.

    Not sure how your advanceToNextItem is implemented though. So it depends on that.