异步生成视频缩略图：generateCGImagesAsynchronously参数与方案解析

Hey there! Great question—switching to generateCGImagesAsynchronously is absolutely a better approach for your thumbnail generation task, and I’ll break down exactly how to use it, plus why it’s way more efficient than your original synchronous loop.

Your original code uses copyCGImage in a synchronous loop, which blocks the main thread for the entire duration of thumbnail generation. This will make your app feel unresponsive (or even freeze) if you’re working with long or high-resolution videos.

The generateCGImagesAsynchronously method fixes this by handling all heavy lifting on background threads, while letting you process results as they come in. It also gives you better error handling per-thumbnail, and lets you cancel the operation mid-process if needed.

Let’s break down the two parts you’re confused about: the [NSValue] time array and the completion handler.

1. Creating the [NSValue] Time Array #

AVFoundation needs you to pass an array of time points wrapped in NSValue (since Swift can’t store CMTime directly in an array). Each NSValue represents a timestamp where you want a thumbnail.

For your 15-thumbnail requirement, calculate the times just like you did before, then wrap each CMTime in NSValue:

let duration = asset.duration
let totalSeconds = CMTimeGetSeconds(duration)
guard totalSeconds > 0 else { /* handle zero-length video */ return }

let interval = totalSeconds / 15
var timeValues = [NSValue]()
var currentTime = 1.0

while currentTime < totalSeconds {
    // Use CMTimeMakeWithSeconds for better precision, 600 is a recommended timescale for AVFoundation
    let cmTime = CMTimeMakeWithSeconds(currentTime, preferredTimescale: 600)
    timeValues.append(NSValue(time: cmTime))
    currentTime += interval
}

2. The Completion Handler #

This closure is called once per thumbnail (whether it succeeds or fails). It gives you all the context you need to process each result:

• requestedTime: The timestamp you asked for
• image: The generated CGImage? (non-nil on success)
• actualTime: The actual timestamp the thumbnail was pulled from (AVFoundation often uses keyframes, so this might differ slightly)
• result: A status enum (AVAssetImageGeneratorResult) indicating success, failure, or cancellation
• error: An optional error if the generation failed

Here’s how to use it to collect your thumbnails, with proper thread safety (since the handler runs on a background thread):

Here’s a complete, updated version of your function using the asynchronous approach, with added best practices like size limiting and completion callbacks:

func generateThumbnails(from fileURL: URL, completion: @escaping ([UIImage]) -> Void) {
    let asset = AVAsset(url: fileURL)
    let imageGenerator = AVAssetImageGenerator(asset: asset)
    
    // Keep your existing configuration
    imageGenerator.apertureMode = AVAssetImageGeneratorApertureMode.cleanAperture
    imageGenerator.appliesPreferredTrackTransform = true
    // Add this to limit thumbnail size and boost performance
    imageGenerator.maximumSize = CGSize(width: 300, height: 300)
    
    let totalSeconds = CMTimeGetSeconds(asset.duration)
    guard totalSeconds > 0 else {
        DispatchQueue.main.async { completion([]) }
        return
    }
    
    // Prepare the time values array
    let interval = totalSeconds / 15
    var timeValues = [NSValue]()
    var currentTime = 1.0
    while currentTime < totalSeconds {
        let cmTime = CMTimeMakeWithSeconds(currentTime, preferredTimescale: 600)
        timeValues.append(NSValue(time: cmTime))
        currentTime += interval
    }
    
    var thumbnails = [UIImage]()
    
    imageGenerator.generateCGImagesAsynchronously(forTimes: timeValues) { [weak self] requestedTime, image, actualTime, result, error in
        guard let self = self else { return }
        
        switch result {
        case .succeeded:
            if let cgImage = image {
                let uiImage = UIImage(cgImage: cgImage)
                thumbnails.append(uiImage)
                
                // When all thumbnails are generated, call completion on main thread
                if thumbnails.count == timeValues.count {
                    DispatchQueue.main.async {
                        completion(thumbnails)
                    }
                }
            }
        case .failed:
            print("Failed to generate thumbnail at \(CMTimeGetSeconds(requestedTime))s: \(error?.localizedDescription ?? "Unknown error")")
        case .cancelled:
            print("Thumbnail generation was cancelled")
        @unknown default:
            print("Unexpected result from thumbnail generation")
        }
    }
}

// To use it:
// generateThumbnails(from: yourVideoURL) { thumbnails in
//     // Use your thumbnails here (e.g., update UI)
// }

• No UI Freezes: All processing happens off the main thread, so your app stays responsive.
• Robust Error Handling: A single failed thumbnail won’t break the entire process—you can log errors and keep collecting the rest.
• Better Performance: AVFoundation optimizes batch processing in the background, which is faster than sequential synchronous calls.
• Cancelability: You can call imageGenerator.cancelAllCGImageGeneration() if you no longer need the thumbnails (e.g., user navigates away).

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