iOS - 创建多个延时实时摄像机预览视图

Question

我已经进行了大量的研究，但由于多种原因，我还没有找到可行的解决方案，我将在下面概述。

---

问题

在我的 iOS 应用中，我希望三个视图无限期地显示设备相机的延迟实时预览。

例如，视图 1 将显示相机视图，延迟 5 秒，视图 2 将显示相同的相机视图，延迟 20 秒，视图 3 将显示相同的相机视图，延迟 30 秒。

这将用于记录自己进行某种活动，例如锻炼，然后在几秒钟后观察自己，以完善给定锻炼的形式。

尝试的解决方案

我尝试并研究了几种不同的解决方案，但都有问题。

1。使用AVFoundation 和AVCaptureMovieFileOutput：

• 使用AVCaptureSession 和AVCaptureMovieFileOutput 将短片记录到设备存储中。短片是必需的，因为您不能从一个 URL 播放视频，并同时写入同一个 URL。
• 拥有 3 个 AVPlayer 和 AVPlayerLayer 实例，它们都以所需的时间延迟播放录制的短片段。
• 问题：
  1. 使用AVPlayer.replaceCurrentItem(_:) 切换剪辑时，剪辑之间存在非常明显的延迟。这需要平稳过渡。
  2. 虽然很旧，但由于设备限制，here 的评论建议不要创建多个 AVPlayer 实例。我无法找到确认或否认这一说法的信息。 E：来自 Jake G 的评论 - 10 个AVPlayer 实例适用于 iPhone 5 及更新版本。

2。使用AVFoundation 和AVCaptureVideoDataOutput：

• 使用AVCaptureSession 和AVCaptureVideoDataOutput 使用didOutputSampleBuffer 委托方法流式传输和处理相机的每一帧。
• 在 OpenGL 视图上绘制每一帧（例如GLKViewWithBounds）。这解决了来自Solution 1. 的多个AVPlayer 实例的问题。
• 问题：存储每一帧以便以后显示它们需要大量内存（这在 iOS 设备上是不可行的）或磁盘空间。如果我想以每秒 30 帧的速度存储 2 分钟的视频，那就是 3600 帧，如果直接从 didOutputSampleBuffer 复制，总计超过 12GB。也许有一种方法可以在不损失质量的情况下压缩每帧 x1000，让我可以将这些数据保存在内存中。如果有这样的方法，我一直找不到。

可能的第三种解决方案

如果有办法同时读取和写入文件，我相信下面的解决方案会是理想的。

• 将视频录制为循环流。例如，对于 2 分钟的视频缓冲区，我将创建一个文件输出流，该流将写入两分钟的帧。一旦达到 2 分钟标记，流将从头开始重新开始，覆盖原始帧。
• 随着这个文件输出流的不断运行，我将在同一个录制的视频文件上有 3 个输入流。每个流将指向流中的不同帧（实际上比写入流晚 X 秒）。然后每个帧将显示在输入流上相应的UIView。

当然，这还是有存储空间的问题。如果帧被存储为压缩的 JPEG 图像，我们谈论的是较低质量的 2 分钟视频需要多个 GB 的存储空间。

问题

1. 有人知道实现我想要的有效方法吗？
2. 如何解决我已经尝试过的解决方案中的一些问题？

Answer 1

自从接受答案后，情况发生了变化。现在有一个替代分段 AVCaptureMovieFileOutput 的替代方法，它不会在您创建新分段时在 iOS 上丢帧，而该替代方法是 AVAssetWriter！

从 iOS 14 开始，AVAssetWriter 可以创建分段的 MPEG4，它们本质上是内存中的 mpeg 4 文件。它适用于 HLS 流应用程序，但也是一种非常方便的缓存视频和音频内容的方法。

Takayuki Mizuno 在 WWDC 2020 会议Author fragmented MPEG-4 content with AVAssetWriter 中描述了这项新功能。

有了碎片化的 mp4 AVAssetWriter，通过将 mp4 片段写入磁盘并使用多个 AVQueuePlayers 以所需的时间偏移量播放它们来创建解决此问题的方法并不难。

所以这将是第四个解决方案：使用AVAssetWriter 的.mpeg4AppleHLS 输出配置文件捕获摄像机流并将其作为碎片mp4 写入磁盘，并使用AVQueuePlayers 和@987654333 以不同的延迟播放视频@。

如果您需要支持 iOS 13 及更低版本，则必须替换分段的AVAssetWriter，这会很快获得技术支持，尤其是如果您也想编写音频。谢谢，水野孝之！

import UIKit
import AVFoundation
import UniformTypeIdentifiers

class ViewController: UIViewController {
    let playbackDelays:[Int] = [5, 20, 30]
    let segmentDuration = CMTime(value: 2, timescale: 1)

    var assetWriter: AVAssetWriter!
    var videoInput: AVAssetWriterInput!
    var startTime: CMTime!

    var writerStarted = false
    
    let session = AVCaptureSession()
    
    var segment = 0
    var outputDir: URL!
    var initializationData = Data()
    
    var layers: [AVPlayerLayer] = []
    var players: [AVQueuePlayer] = []

    override func viewDidLoad() {
        super.viewDidLoad()
        
        for _ in 0..<playbackDelays.count {
            let player = AVQueuePlayer()
            player.automaticallyWaitsToMinimizeStalling = false
            let layer = AVPlayerLayer(player: player)
            layer.videoGravity = .resizeAspectFill
            layers.append(layer)
            players.append(player)
            view.layer.addSublayer(layer)
        }
        
        outputDir = FileManager.default.urls(for: .documentDirectory, in:.userDomainMask).first!
    
        assetWriter = AVAssetWriter(contentType: UTType.mpeg4Movie)
        assetWriter.outputFileTypeProfile = .mpeg4AppleHLS // fragmented mp4 output!
        assetWriter.preferredOutputSegmentInterval = segmentDuration
        assetWriter.initialSegmentStartTime = .zero
        assetWriter.delegate = self
        
        let videoOutputSettings: [String : Any] = [
            AVVideoCodecKey: AVVideoCodecType.h264,
            AVVideoWidthKey: 1024,
            AVVideoHeightKey: 720
        ]
        videoInput = AVAssetWriterInput(mediaType: .video, outputSettings: videoOutputSettings)
        videoInput.expectsMediaDataInRealTime = true

        assetWriter.add(videoInput)

        // capture session
        let videoDevice = AVCaptureDevice.default(for: .video)!
        let videoInput = try! AVCaptureDeviceInput(device: videoDevice)
        session.addInput(videoInput)
        
        let videoOutput = AVCaptureVideoDataOutput()
        videoOutput.setSampleBufferDelegate(self, queue: DispatchQueue.main)
        session.addOutput(videoOutput)
        
        session.startRunning()
    }
    
    override func viewDidLayoutSubviews() {
        let size = view.bounds.size
        let layerWidth = size.width / CGFloat(layers.count)
        for i in 0..<layers.count {
            let layer = layers[i]
            layer.frame = CGRect(x: CGFloat(i)*layerWidth, y: 0, width: layerWidth, height: size.height)
        }
    }
    
    override var supportedInterfaceOrientations: UIInterfaceOrientationMask {
        return .landscape
    }
}

extension ViewController: AVCaptureVideoDataOutputSampleBufferDelegate {
    func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
        
        if startTime == nil {
            let success = assetWriter.startWriting()
            assert(success)
            startTime = sampleBuffer.presentationTimeStamp
            assetWriter.startSession(atSourceTime: startTime)
        }
        
        if videoInput.isReadyForMoreMediaData {
            videoInput.append(sampleBuffer)
        }
    }
}

extension ViewController: AVAssetWriterDelegate {
    func assetWriter(_ writer: AVAssetWriter, didOutputSegmentData segmentData: Data, segmentType: AVAssetSegmentType) {
        print("segmentType: \(segmentType.rawValue) - size: \(segmentData.count)")
        
        switch segmentType {
        case .initialization:
            initializationData = segmentData
        case .separable:
            let fileURL = outputDir.appendingPathComponent(String(format: "%.4i.mp4", segment))
            segment += 1

            let mp4Data = initializationData + segmentData
            try! mp4Data.write(to: fileURL)

            let asset = AVAsset(url: fileURL)

            for i in 0..<players.count {
                let player = players[i]
                let playerItem = AVPlayerItem(asset: asset)
                player.insert(playerItem, after: nil)
                
                if player.rate == 0 && player.status == .readyToPlay {
                    let hostStartTime: CMTime = startTime + CMTime(value: CMTimeValue(playbackDelays[i]), timescale: 1)

                    player.preroll(atRate: 1) { prerolled in
                        guard prerolled else { return }
                        player.setRate(1, time: .invalid, atHostTime: hostStartTime)
                    }
                }
            }
            
        @unknown default:
            break
        }
    }
}

结果是这样的

而且性能还算合理：我的 2019 年 iPod 占用 10-14% 的 cpu 和 38MB 的内存。

Answer 2

1. 在 iOS 上 AVCaptureMovieFileOutput 在切换文件时丢帧。在 osx 上不会发生这种情况。头文件中有关于这个的讨论，见captureOutputShouldProvideSampleAccurateRecordingStart。

您的 2. 和 3. 的组合应该可以工作。您需要使用AVCaptureVideoDataOutput 和AVAssetWriter 而不是AVCaptureMovieFileOutput 将视频文件分块写入，这样您就不会丢帧。添加 3 个具有足够存储空间的环形缓冲区以跟上播放，使用 GLES 或金属来显示缓冲区（使用 YUV 而不是 RGBA 使用的内存少 4/1.5 倍）。

在强大的 iPhone 4s 和 iPad 2 时代，我尝试了一个更温和的版本。它显示（我认为）现在和过去 10 年代。我猜测因为你可以以 3x 实时编码 30fps，所以我应该能够对块进行编码并仅使用 2/3 的硬件容量来读取之前的块。可悲的是，要么我的想法错误，要么硬件存在非线性，要么代码错误，编码器一直落后。