Timer Label Overlay about videoio HOT 10 CLOSED

import UIKit
import VideoIO
import MetalPetal
import AVFoundation
import SnapKit
import RxSwift
import RxCocoa

class MetalPetalViewController: UIViewController {
    
    private let filter = MTIBlendFilter(blendMode: .overlay)
    private var recorder: MovieRecorder?
    private var camera: Camera!

    private let queue: DispatchQueue = DispatchQueue(label: "org.metalpetal.capture")
    private var isRecording = BehaviorRelay<Bool>(value: false)
    private let disposeBag = DisposeBag()
    
    private var cameraOutputView = MTIImageView()
    private let recordButton = UIButton()
    private let overlayView = UIView()
    private let timerLabel = UILabel()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupLayout()
        setupCamera()
        
        recordButton.rx.tap
            .bind {
                self.isRecording.value ? self.stopRecording() : self.startRecording()
            }.disposed(by: disposeBag)
        
        isRecording.map { $0 ? UIColor.blue : UIColor.red }
            .bind(to: recordButton.rx.backgroundColor)
            .disposed(by: disposeBag)
        
        let countDown = 100
        Observable<Int>.timer(.seconds(0), period: .seconds(1), scheduler: MainScheduler.instance)
            .take(countDown + 1)
            .subscribe(onNext: { timePassed in
                self.timerLabel.text = "\(timePassed)"
            }, onCompleted: {
                print("count down complete")
            }).disposed(by: disposeBag)
    }
    
    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        startRunningCaptureSession()
    }
    
    override func viewDidDisappear(_ animated: Bool) {
        super.viewDidDisappear(animated)
        stopRunningCaptureSession()
    }
    
    private func setupLayout() {
        view.addSubview(cameraOutputView)
        cameraOutputView.snp.makeConstraints {
            $0.edges.equalToSuperview()
        }
        
        overlayView.backgroundColor = .clear
        view.addSubview(overlayView)
        overlayView.snp.makeConstraints {
            $0.edges.equalToSuperview()
        }
        
        timerLabel.textColor = .white
        timerLabel.font = .systemFont(ofSize: 20)
        overlayView.addSubview(timerLabel)
        timerLabel.snp.makeConstraints {
            $0.center.equalToSuperview()
        }
        
        recordButton.layer.cornerRadius = 25
        view.addSubview(recordButton)
        recordButton.snp.makeConstraints {
            $0.size.equalTo(50)
            $0.bottom.equalToSuperview().inset(60)
            $0.centerX.equalToSuperview()
        }
    }
    
    private func setupCamera() {
        self.camera = Camera(captureSessionPreset: .hd1920x1080, configurator: .portraitFrontMirroredVideoOutput)
        try? camera.enableVideoDataOutput(on: queue, delegate: self)
        try? camera.enableAudioDataOutput(on: queue, delegate: self)
        
        camera.videoDataOutput?.videoSettings = [kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_420YpCbCr8BiPlanarFullRange]
    }
    
    private func startRunningCaptureSession() {
        queue.async {
            self.camera.startRunningCaptureSession()
        }
    }
    
    private func stopRunningCaptureSession() {
        queue.async {
            self.camera.stopRunningCaptureSession()
        }
    }
    
    private func startRecording() {
        let sessionID = UUID()
        let url = FileManager.default.temporaryDirectory.appendingPathComponent("\(sessionID.uuidString).mp4")
        let hasAudio = self.camera.audioDataOutput != nil
        do {
            let recorder = try MovieRecorder(url: url, configuration: MovieRecorder.Configuration(hasAudio: hasAudio))
            self.isRecording.accept(true)
            queue.async {
                self.recorder = recorder
            }
        } catch {
            handleError(error)
        }
    }
    
    private func stopRecording() {
        if let recorder = recorder {
            recorder.stopRecording(completion: { error in
                self.isRecording.accept(false)
                if let error = error {
                    self.handleError(error)
                } else {
                    self.handleFinishRecording(videoURL: recorder.url)
                }
            })
            queue.async {
                self.recorder = nil
            }
        }
    }
    
    private func handleFinishRecording(videoURL: URL) {
        navigationController?.pushViewController(VideoPlayerVC(url: videoURL), animated: true)
    }
    
    private func handleError(_ error: Error) {
        let alert = UIAlertController(title: "Error",
                                      message: error.localizedDescription,
                                      preferredStyle: .alert)
        alert.addAction(.init(title: "OK", style: .cancel))
        present(alert, animated: true)
    }
}

extension MetalPetalViewController: AVCaptureVideoDataOutputSampleBufferDelegate, AVCaptureAudioDataOutputSampleBufferDelegate {
    func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
        guard let formatDescription = sampleBuffer.formatDescription else {
            return
        }
        switch formatDescription.mediaType {
        case .audio:
            do {
                try self.recorder?.appendSampleBuffer(sampleBuffer)
            } catch {
                print(error)
            }
        case .video:
            guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }
            filter.inputBackgroundImage = MTIImage(cvPixelBuffer: pixelBuffer,
                                                   alphaType: .nonPremultiplied)
            let inputImage = overlayView.asImage()
            filter.inputImage = .init(image: inputImage)
            DispatchQueue.main.async {
                self.cameraOutputView.image = self.filter.outputImage
            }
        default:
            break
        }
    }
}

extension UIView {
    func asImage() -> UIImage {
        let renderer = UIGraphicsImageRenderer(bounds: bounds)
        return renderer.image { rendererContext in
            layer.render(in: rendererContext.cgContext)
        }
    }
}

  func captureOutput(_ output: AVCaptureOutput, didOutput sampleBuffer: CMSampleBuffer, from connection: AVCaptureConnection) {
        guard let formatDescription = sampleBuffer.formatDescription else {
            return
        }
        switch formatDescription.mediaType {
        case .audio:
            do {
                try self.recorder?.appendSampleBuffer(sampleBuffer)
            } catch {
                handleError(error)
            }
        case .video:
            guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }
            
            DispatchQueue.main.async {
                self.cameraOutputView.image = MTIImage(cvPixelBuffer: pixelBuffer,
                                                       alphaType: .alphaIsOne)
                
                let overlayPixelBuffer = try! self.viewSnapshoter.snapshot(
                    self.overlayView,
                    afterScreenUpdates: true,
                    renderScale: 1
                )
                
                //need to merge?
                
                try? self.recorder?.appendSampleBuffer(
                    SampleBufferUtilities.makeSampleBufferByReplacingImageBuffer(of: sampleBuffer, with: pixelBuffer)!
                )
            }
        default:
            break
        }
    }