如何提升AVPlayer加载速率？AVPlayer缓冲达标未进入prepared状态

Hey there! Let’s dive into your two AVPlayer questions—these are super common pain points in media development, so I’ve got some practical fixes to share:

The goal here is to cut down the time between initiating playback and the video being ready to play. Try these actionable tactics:

• Preload critical asset metadata upfront
  Don’t wait until you create an AVPlayerItem to start loading your asset’s key properties. Use AVAsset’s loadValuesAsynchronously(forKeys:) to fetch things like playable, duration, and tracks in the background before setting up the player. This reduces the time the player spends waiting for metadata once initialized. Here’s a quick example:

  let mediaURL = URL(string: "your-stream-url")!
  let asset = AVAsset(url: mediaURL)
  let essentialKeys = ["playable", "duration", "tracks"]
  
  asset.loadValuesAsynchronously(forKeys: essentialKeys) {
      DispatchQueue.main.async {
          var loadError: NSError?
          for key in essentialKeys {
              if asset.statusOfValue(forKey: key, error: &loadError) != .loaded {
                  // Handle missing metadata or network errors here
                  return
              }
          }
          // Now the asset is prepped—create your player item and player
          let playerItem = AVPlayerItem(asset: asset)
          let player = AVPlayer(playerItem: playerItem)
      }
  }
  

• Optimize streaming configuration
  If you’re using HLS, ensure your server supports byte-range requests—this lets the player fetch only the media segments it needs instead of the entire file. You can also:

  • Set a reasonable preferredPeakBitRate on your AVPlayerItem to avoid the player trying to load a high-resolution stream your network can’t handle.
  • Disable unused tracks (like subtitles or alternate audio) using AVPlayerItem.selectMediaOption(_:inMediaSelectionGroup:) to reduce the data the player has to download.

• Implement local caching
  Cache previously loaded media segments locally so the player doesn’t re-download them on subsequent plays. You can build a custom cache using URLSession with disk storage, or use AVAssetResourceLoader to intercept and cache network requests.

• Keep heavy work off the main thread
  All asset loading, network calls, and metadata parsing should run on background queues. Blocking the main thread will make the load feel slower even if the actual network transfer is fine.

This usually means the player is waiting for more than just raw buffer data. Here’s how to diagnose and fix it:

• Check if asset metadata is fully loaded
  The player can’t enter the prepared state until the underlying AVAsset has all necessary playback info (like track layouts, codec details). Even if buffer data is coming in, if the asset’s playable status is still .loading, the player will hold off. Use the loadValuesAsynchronously(forKeys:) method from the first question to ensure all essential keys are loaded before creating the player item.

• Verify your streaming source is valid
  Corrupted HLS playlists, missing segments, or incompatible codecs can cause the player to get stuck. Test with a known-good stream to rule out source issues. You can also check for errors by listening to the AVPlayerItemFailedToPlayToEndTime notification or checking the error property on your AVPlayerItem.

• Calculate continuous buffer, not just total buffer
  The loadedTimeRanges property returns all buffered intervals, but the player needs a continuous buffer starting from the current playback time to proceed. A "sufficient" total buffer might be split into non-contiguous chunks, which won’t trigger the prepared state. Use this code to calculate actual continuous buffer length:

  func calculateContinuousBuffer(for player: AVPlayer) -> TimeInterval {
      guard let loadedRanges = player.currentItem?.loadedTimeRanges, !loadedRanges.isEmpty else {
          return 0
      }
      
      var continuousBuffer = 0.0
      var lastEndTime = CMTime.zero
      
      for range in loadedRanges {
          let start = range.timeRange.start
          let duration = range.timeRange.duration
          let end = CMTimeAdd(start, duration)
          
          if CMTimeCompare(start, lastEndTime) == 0 {
              continuousBuffer += CMTimeGetSeconds(duration)
          } else if CMTimeCompare(start, lastEndTime) < 0 {
              let overlap = CMTimeGetSeconds(CMTimeSubtract(lastEndTime, start))
              continuousBuffer += CMTimeGetSeconds(duration) - overlap
          } else {
              continuousBuffer = CMTimeGetSeconds(duration)
          }
          lastEndTime = end
      }
      return continuousBuffer
  }
  

• Adjust buffer settings
  If you’ve set preferredForwardBufferDuration to a very high value, the player might wait until that full duration is buffered before preparing. Try lowering this value (or using the default) to see if it triggers the prepared state earlier. You can also listen to the AVPlayerItemPlaybackBufferFull and AVPlayerItemPlaybackBufferEmpty notifications to get a clearer picture of the buffer’s actual state.

内容的提问来源于stack exchange，提问作者Zongbin Xia