mirror of
https://github.com/Swiftgram/Telegram-iOS.git
synced 2025-06-15 21:45:19 +00:00
888 lines
36 KiB
Swift
888 lines
36 KiB
Swift
import Foundation
|
|
import AVFoundation
|
|
import MetalKit
|
|
import SwiftSignalKit
|
|
import TelegramCore
|
|
import Postbox
|
|
|
|
enum ExportWriterStatus {
|
|
case unknown
|
|
case writing
|
|
case completed
|
|
case failed
|
|
case cancelled
|
|
}
|
|
|
|
protocol MediaEditorVideoExportWriter {
|
|
func setup(configuration: MediaEditorVideoExport.Configuration, outputPath: String)
|
|
func setupVideoInput(configuration: MediaEditorVideoExport.Configuration, preferredTransform: CGAffineTransform?, sourceFrameRate: Float)
|
|
func setupAudioInput(configuration: MediaEditorVideoExport.Configuration)
|
|
|
|
func startWriting() -> Bool
|
|
func startSession(atSourceTime time: CMTime)
|
|
|
|
func finishWriting(completion: @escaping () -> Void)
|
|
func cancelWriting()
|
|
|
|
func requestVideoDataWhenReady(on queue: DispatchQueue, using block: @escaping () -> Void)
|
|
func requestAudioDataWhenReady(on queue: DispatchQueue, using block: @escaping () -> Void)
|
|
|
|
var isReadyForMoreVideoData: Bool { get }
|
|
func appendVideoBuffer(_ buffer: CMSampleBuffer) -> Bool
|
|
func appendPixelBuffer(_ buffer: CVPixelBuffer, at time: CMTime) -> Bool
|
|
func markVideoAsFinished()
|
|
|
|
var pixelBufferPool: CVPixelBufferPool? { get }
|
|
|
|
var isReadyForMoreAudioData: Bool { get }
|
|
func appendAudioBuffer(_ buffer: CMSampleBuffer) -> Bool
|
|
func markAudioAsFinished()
|
|
|
|
var status: ExportWriterStatus { get }
|
|
|
|
var error: Error? { get }
|
|
}
|
|
|
|
public final class MediaEditorVideoExport {
|
|
public enum Subject {
|
|
case image(image: UIImage)
|
|
case video(asset: AVAsset, isStory: Bool)
|
|
}
|
|
|
|
public struct Configuration {
|
|
public var shouldOptimizeForNetworkUse: Bool = true
|
|
public var videoSettings: [String: Any]
|
|
public var audioSettings: [String: Any]
|
|
public var values: MediaEditorValues
|
|
public var frameRate: Float
|
|
|
|
public init(
|
|
videoSettings: [String: Any],
|
|
audioSettings: [String: Any],
|
|
values: MediaEditorValues,
|
|
frameRate: Float
|
|
) {
|
|
self.videoSettings = videoSettings
|
|
self.audioSettings = audioSettings
|
|
self.values = values
|
|
self.frameRate = frameRate
|
|
}
|
|
|
|
var isSticker: Bool {
|
|
if let codec = self.videoSettings[AVVideoCodecKey] as? String, codec == "VP9" {
|
|
return true
|
|
} else {
|
|
return false
|
|
}
|
|
}
|
|
|
|
var timeRange: CMTimeRange? {
|
|
if let videoTrimRange = self.values.videoTrimRange {
|
|
return CMTimeRange(start: CMTime(seconds: videoTrimRange.lowerBound, preferredTimescale: CMTimeScale(NSEC_PER_SEC)), end: CMTime(seconds: videoTrimRange.upperBound, preferredTimescale: CMTimeScale(NSEC_PER_SEC)))
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
var additionalVideoTimeRange: CMTimeRange? {
|
|
if let videoTrimRange = self.values.additionalVideoTrimRange {
|
|
return CMTimeRange(start: CMTime(seconds: videoTrimRange.lowerBound, preferredTimescale: CMTimeScale(NSEC_PER_SEC)), end: CMTime(seconds: videoTrimRange.upperBound, preferredTimescale: CMTimeScale(NSEC_PER_SEC)))
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
var additionalVideoStartTime: CMTime {
|
|
let lowerBound = self.values.additionalVideoTrimRange?.lowerBound ?? 0.0
|
|
let offset = -min(0.0, self.values.additionalVideoOffset ?? 0.0)
|
|
if !lowerBound.isZero || !offset.isZero {
|
|
return CMTime(seconds: offset + lowerBound, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
|
|
} else {
|
|
return .zero
|
|
}
|
|
}
|
|
|
|
var audioTimeRange: CMTimeRange? {
|
|
if let audioTrack = self.values.audioTrack {
|
|
let offset = max(0.0, self.values.audioTrackOffset ?? 0.0)
|
|
if let range = self.values.audioTrackTrimRange {
|
|
return CMTimeRange(
|
|
start: CMTime(seconds: offset + range.lowerBound, preferredTimescale: CMTimeScale(NSEC_PER_SEC)),
|
|
end: CMTime(seconds: offset + range.upperBound, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
|
|
)
|
|
} else {
|
|
return CMTimeRange(
|
|
start: CMTime(seconds: offset, preferredTimescale: CMTimeScale(NSEC_PER_SEC)),
|
|
end: CMTime(seconds: offset + min(15.0, audioTrack.duration), preferredTimescale: CMTimeScale(NSEC_PER_SEC))
|
|
)
|
|
}
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
var audioStartTime: CMTime {
|
|
if let range = self.values.audioTrackTrimRange {
|
|
let offset = -min(0.0, self.values.audioTrackOffset ?? 0.0)
|
|
return CMTime(seconds: offset + range.lowerBound, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
|
|
} else {
|
|
return .zero
|
|
}
|
|
}
|
|
|
|
var composerDimensions: CGSize {
|
|
if self.values.isStory || self.values.isSticker {
|
|
return CGSize(width: 1080.0, height: 1920.0)
|
|
} else {
|
|
let maxSize = CGSize(width: 1920.0, height: 1920.0)
|
|
return targetSize(cropSize: self.values.originalDimensions.cgSize.aspectFitted(maxSize))
|
|
}
|
|
}
|
|
|
|
var dimensions: CGSize {
|
|
if let width = self.videoSettings[AVVideoWidthKey] as? Int, let height = self.videoSettings[AVVideoHeightKey] as? Int {
|
|
return CGSize(width: width, height: height)
|
|
} else {
|
|
return CGSize(width: 1920.0, height: 1080.0)
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum Status {
|
|
case idle
|
|
case paused
|
|
case exporting
|
|
case finished
|
|
}
|
|
|
|
public enum ExportError {
|
|
case noTracksFound
|
|
case addVideoOutput
|
|
case addAudioOutput
|
|
case writing(Error?)
|
|
case reading(Error?)
|
|
case invalid
|
|
case cancelled
|
|
}
|
|
|
|
public enum ExportStatus {
|
|
case unknown
|
|
case progress(Float)
|
|
case completed
|
|
case failed(ExportError)
|
|
}
|
|
|
|
public private(set) var internalStatus: Status = .idle
|
|
|
|
private let queue = Queue()
|
|
private let postbox: Postbox
|
|
private let subject: Subject
|
|
private let configuration: Configuration
|
|
private let textScale: CGFloat
|
|
private let outputPath: String
|
|
|
|
private var reader: AVAssetReader?
|
|
private var videoOutput: AVAssetReaderOutput?
|
|
private var textureRotation: TextureRotation = .rotate0Degrees
|
|
private var frameRate: Float?
|
|
|
|
private var additionalVideoOutput: AVAssetReaderOutput?
|
|
private var additionalTextureRotation: TextureRotation = .rotate0Degrees
|
|
private var additionalFrameRate: Float?
|
|
private var additionalVideoDuration: Double?
|
|
|
|
private var mainComposeFramerate: Float?
|
|
|
|
private var audioOutput: AVAssetReaderOutput?
|
|
|
|
private var writer: MediaEditorVideoExportWriter?
|
|
private var composer: MediaEditorComposer?
|
|
|
|
private let duration = ValuePromise<CMTime>()
|
|
private var durationValue: CMTime? {
|
|
didSet {
|
|
if let durationValue = self.durationValue {
|
|
self.duration.set(durationValue)
|
|
}
|
|
}
|
|
}
|
|
|
|
private var imageArguments: (frameRate: Double, position: CMTime)?
|
|
|
|
private let pauseDispatchGroup = DispatchGroup()
|
|
private var cancelled = false
|
|
|
|
private var startTimestamp = CACurrentMediaTime()
|
|
|
|
private let semaphore = DispatchSemaphore(value: 0)
|
|
|
|
public init(postbox: Postbox, subject: Subject, configuration: Configuration, outputPath: String, textScale: CGFloat = 1.0) {
|
|
self.postbox = postbox
|
|
self.subject = subject
|
|
self.configuration = configuration
|
|
self.outputPath = outputPath
|
|
self.textScale = textScale
|
|
|
|
if FileManager.default.fileExists(atPath: outputPath) {
|
|
try? FileManager.default.removeItem(atPath: outputPath)
|
|
}
|
|
self.setup()
|
|
|
|
let _ = NotificationCenter.default.addObserver(forName: UIApplication.willEnterForegroundNotification, object: nil, queue: nil, using: { [weak self] _ in
|
|
guard let self else {
|
|
return
|
|
}
|
|
self.resume()
|
|
})
|
|
let _ = NotificationCenter.default.addObserver(forName: UIApplication.didEnterBackgroundNotification, object: nil, queue: nil, using: { [weak self] _ in
|
|
guard let self else {
|
|
return
|
|
}
|
|
self.pause()
|
|
})
|
|
}
|
|
|
|
enum Input {
|
|
case image(UIImage)
|
|
case video(AVAsset)
|
|
|
|
var isVideo: Bool {
|
|
if case .video = self {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
}
|
|
|
|
private func setup() {
|
|
var mainAsset: AVAsset?
|
|
|
|
var additionalAsset: AVAsset?
|
|
if let additionalPath = self.configuration.values.additionalVideoPath {
|
|
additionalAsset = AVURLAsset(url: URL(fileURLWithPath: additionalPath))
|
|
}
|
|
|
|
var audioAsset: AVAsset?
|
|
if let audioTrack = self.configuration.values.audioTrack {
|
|
let audioPath = fullDraftPath(peerId: self.configuration.values.peerId, path: audioTrack.path)
|
|
audioAsset = AVURLAsset(url: URL(fileURLWithPath: audioPath))
|
|
}
|
|
|
|
var mainInput: Input
|
|
let additionalInput: Input? = additionalAsset.flatMap { .video($0) }
|
|
var isStory = true
|
|
|
|
switch self.subject {
|
|
case let .video(asset, isStoryValue):
|
|
mainAsset = asset
|
|
mainInput = .video(asset)
|
|
isStory = isStoryValue
|
|
case let .image(image):
|
|
mainInput = .image(image)
|
|
}
|
|
|
|
let duration: CMTime
|
|
if self.configuration.isSticker {
|
|
duration = CMTime(seconds: 3.0, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
|
|
} else if let mainAsset {
|
|
if let trimmedDuration = self.configuration.timeRange?.duration {
|
|
duration = trimmedDuration
|
|
} else {
|
|
if isStory && mainAsset.duration.seconds > 60.0 {
|
|
duration = CMTime(seconds: 60.0, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
|
|
} else {
|
|
duration = mainAsset.duration
|
|
}
|
|
}
|
|
} else if let additionalAsset {
|
|
if let trimmedDuration = self.configuration.additionalVideoTimeRange?.duration {
|
|
duration = trimmedDuration
|
|
} else {
|
|
if additionalAsset.duration.seconds > 60.0 {
|
|
duration = CMTime(seconds: 60.0, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
|
|
} else {
|
|
duration = additionalAsset.duration
|
|
}
|
|
}
|
|
} else {
|
|
if let audioDuration = self.configuration.audioTimeRange?.duration {
|
|
duration = audioDuration
|
|
} else {
|
|
duration = CMTime(seconds: 5.0, preferredTimescale: CMTimeScale(NSEC_PER_SEC))
|
|
}
|
|
}
|
|
self.durationValue = duration
|
|
|
|
self.setupWithInputs(main: mainInput, additional: additionalInput, audio: audioAsset, isStory: isStory)
|
|
}
|
|
|
|
private func setupComposer() {
|
|
guard self.composer == nil else {
|
|
return
|
|
}
|
|
|
|
var duration = self.durationValue?.seconds
|
|
if case .image = self.subject {
|
|
duration = nil
|
|
}
|
|
|
|
self.composer = MediaEditorComposer(
|
|
postbox: self.postbox,
|
|
values: self.configuration.values,
|
|
dimensions: self.configuration.composerDimensions,
|
|
outputDimensions: self.configuration.dimensions,
|
|
textScale: self.textScale,
|
|
videoDuration: duration,
|
|
additionalVideoDuration: self.additionalVideoDuration
|
|
)
|
|
}
|
|
|
|
private func setupWithInputs(main: Input, additional: Input?, audio: AVAsset?, isStory: Bool) {
|
|
var hasVideoOrAudio = false
|
|
if main.isVideo || additional?.isVideo == true || audio != nil {
|
|
hasVideoOrAudio = true
|
|
}
|
|
|
|
var composition: AVMutableComposition?
|
|
var mainVideoTrack: AVMutableCompositionTrack?
|
|
var additionalVideoTrack: AVMutableCompositionTrack?
|
|
var audioMix: AVMutableAudioMix?
|
|
|
|
if hasVideoOrAudio, let duration = self.durationValue {
|
|
composition = AVMutableComposition()
|
|
var audioMixParameters: [AVMutableAudioMixInputParameters] = []
|
|
|
|
let wholeRange: CMTimeRange = CMTimeRangeMake(start: .zero, duration: duration)
|
|
func clampedRange(trackDuration: CMTime, trackTrimRange: CMTimeRange?, trackStart: CMTime, maxDuration: CMTime) -> CMTimeRange {
|
|
var result = CMTimeRange(start: .zero, duration: trackDuration)
|
|
if let trackTrimRange {
|
|
result = trackTrimRange
|
|
}
|
|
if trackStart + result.duration > maxDuration {
|
|
result = CMTimeRange(start: result.start, duration: maxDuration - trackStart)
|
|
}
|
|
return result
|
|
}
|
|
|
|
var readerRange = wholeRange
|
|
if case let .video(asset) = main {
|
|
self.textureRotation = textureRotatonForAVAsset(asset)
|
|
if let videoAssetTrack = asset.tracks(withMediaType: .video).first {
|
|
if let compositionTrack = composition?.addMutableTrack(withMediaType: .video, preferredTrackID: kCMPersistentTrackID_Invalid) {
|
|
mainVideoTrack = compositionTrack
|
|
compositionTrack.preferredTransform = videoAssetTrack.preferredTransform
|
|
|
|
try? compositionTrack.insertTimeRange(CMTimeRange(start: .zero, duration: asset.duration), of: videoAssetTrack, at: .zero)
|
|
}
|
|
}
|
|
if let audioAssetTrack = asset.tracks(withMediaType: .audio).first, !self.configuration.values.videoIsMuted {
|
|
if let compositionTrack = composition?.addMutableTrack(withMediaType: .audio, preferredTrackID: kCMPersistentTrackID_Invalid) {
|
|
try? compositionTrack.insertTimeRange(CMTimeRange(start: .zero, duration: asset.duration), of: audioAssetTrack, at: .zero)
|
|
|
|
if let volume = self.configuration.values.videoVolume, volume != 1.0 {
|
|
let trackParameters = AVMutableAudioMixInputParameters(track: compositionTrack)
|
|
trackParameters.trackID = compositionTrack.trackID
|
|
trackParameters.setVolume(Float(volume), at: .zero)
|
|
audioMixParameters.append(trackParameters)
|
|
}
|
|
}
|
|
}
|
|
if let timeRange = self.configuration.timeRange {
|
|
readerRange = timeRange
|
|
}
|
|
}
|
|
if let additional, case let .video(asset) = additional {
|
|
self.additionalTextureRotation = textureRotatonForAVAsset(asset, mirror: true)
|
|
self.additionalVideoDuration = asset.duration.seconds
|
|
|
|
let startTime: CMTime
|
|
let timeRange: CMTimeRange
|
|
if mainVideoTrack == nil {
|
|
startTime = .zero
|
|
timeRange = CMTimeRange(start: .zero, end: asset.duration)
|
|
} else {
|
|
startTime = self.configuration.additionalVideoStartTime
|
|
timeRange = clampedRange(trackDuration: asset.duration, trackTrimRange: self.configuration.additionalVideoTimeRange, trackStart: startTime, maxDuration: readerRange.end)
|
|
}
|
|
|
|
if let videoAssetTrack = asset.tracks(withMediaType: .video).first {
|
|
if let compositionTrack = composition?.addMutableTrack(withMediaType: .video, preferredTrackID: kCMPersistentTrackID_Invalid) {
|
|
additionalVideoTrack = compositionTrack
|
|
compositionTrack.preferredTransform = videoAssetTrack.preferredTransform
|
|
|
|
try? compositionTrack.insertTimeRange(timeRange, of: videoAssetTrack, at: startTime)
|
|
}
|
|
}
|
|
if let audioAssetTrack = asset.tracks(withMediaType: .audio).first, self.configuration.values.additionalVideoVolume ?? 1.0 > 0.01 {
|
|
if let compositionTrack = composition?.addMutableTrack(withMediaType: .audio, preferredTrackID: kCMPersistentTrackID_Invalid) {
|
|
try? compositionTrack.insertTimeRange(timeRange, of: audioAssetTrack, at: startTime)
|
|
|
|
if let volume = self.configuration.values.additionalVideoVolume, volume != 1.0 {
|
|
let trackParameters = AVMutableAudioMixInputParameters(track: compositionTrack)
|
|
trackParameters.trackID = compositionTrack.trackID
|
|
trackParameters.setVolume(Float(volume), at: .zero)
|
|
audioMixParameters.append(trackParameters)
|
|
}
|
|
}
|
|
}
|
|
if mainVideoTrack == nil, let timeRange = self.configuration.additionalVideoTimeRange {
|
|
readerRange = timeRange
|
|
}
|
|
}
|
|
if let audio, let audioAssetTrack = audio.tracks(withMediaType: .audio).first {
|
|
let startTime: CMTime
|
|
if mainVideoTrack == nil && additionalVideoTrack == nil {
|
|
startTime = .zero
|
|
} else {
|
|
startTime = self.configuration.audioStartTime
|
|
}
|
|
let timeRange = clampedRange(trackDuration: audio.duration, trackTrimRange: self.configuration.audioTimeRange, trackStart: startTime, maxDuration: readerRange.end)
|
|
|
|
if let compositionTrack = composition?.addMutableTrack(withMediaType: .audio, preferredTrackID: kCMPersistentTrackID_Invalid) {
|
|
try? compositionTrack.insertTimeRange(timeRange, of: audioAssetTrack, at: startTime)
|
|
|
|
if let volume = self.configuration.values.audioTrackVolume, volume != 1.0 {
|
|
let trackParameters = AVMutableAudioMixInputParameters(track: compositionTrack)
|
|
trackParameters.trackID = compositionTrack.trackID
|
|
trackParameters.setVolume(Float(volume), at: .zero)
|
|
audioMixParameters.append(trackParameters)
|
|
}
|
|
}
|
|
}
|
|
|
|
if !audioMixParameters.isEmpty {
|
|
audioMix = AVMutableAudioMix()
|
|
audioMix?.inputParameters = audioMixParameters
|
|
}
|
|
|
|
if let composition {
|
|
self.reader = try? AVAssetReader(asset: composition)
|
|
self.reader?.timeRange = readerRange
|
|
}
|
|
}
|
|
|
|
if self.configuration.isSticker {
|
|
self.writer = MediaEditorVideoFFMpegWriter()
|
|
} else {
|
|
self.writer = MediaEditorVideoAVAssetWriter()
|
|
}
|
|
|
|
guard let writer = self.writer else {
|
|
return
|
|
}
|
|
writer.setup(configuration: self.configuration, outputPath: self.outputPath)
|
|
self.setupComposer()
|
|
|
|
if let reader {
|
|
let colorProperties: [String: Any] = [
|
|
AVVideoColorPrimariesKey: AVVideoColorPrimaries_ITU_R_709_2,
|
|
AVVideoTransferFunctionKey: AVVideoTransferFunction_ITU_R_709_2,
|
|
AVVideoYCbCrMatrixKey: AVVideoYCbCrMatrix_ITU_R_709_2
|
|
]
|
|
let outputSettings: [String: Any] = [
|
|
kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_420YpCbCr8BiPlanarFullRange,
|
|
kCVPixelBufferMetalCompatibilityKey as String: true,
|
|
AVVideoColorPropertiesKey: colorProperties
|
|
]
|
|
if let mainVideoTrack {
|
|
let videoOutput = AVAssetReaderTrackOutput(track: mainVideoTrack, outputSettings: outputSettings)
|
|
videoOutput.alwaysCopiesSampleData = true
|
|
if reader.canAdd(videoOutput) {
|
|
reader.add(videoOutput)
|
|
} else {
|
|
self.internalStatus = .finished
|
|
self.statusValue = .failed(.addVideoOutput)
|
|
}
|
|
self.videoOutput = videoOutput
|
|
}
|
|
if let additionalVideoTrack {
|
|
let videoOutput = AVAssetReaderTrackOutput(track: additionalVideoTrack, outputSettings: outputSettings)
|
|
videoOutput.alwaysCopiesSampleData = true
|
|
if reader.canAdd(videoOutput) {
|
|
reader.add(videoOutput)
|
|
} else {
|
|
self.internalStatus = .finished
|
|
self.statusValue = .failed(.addVideoOutput)
|
|
}
|
|
self.additionalVideoOutput = videoOutput
|
|
}
|
|
}
|
|
|
|
func frameRate(for track: AVCompositionTrack) -> Float {
|
|
if track.nominalFrameRate > 0.0 {
|
|
return track.nominalFrameRate
|
|
} else if track.minFrameDuration.seconds > 0.0 {
|
|
return Float(1.0 / track.minFrameDuration.seconds)
|
|
}
|
|
return 30.0
|
|
}
|
|
|
|
if let mainVideoTrack {
|
|
self.frameRate = frameRate(for: mainVideoTrack)
|
|
}
|
|
if let additionalVideoTrack {
|
|
self.additionalFrameRate = frameRate(for: additionalVideoTrack)
|
|
}
|
|
let sourceFrameRate: Float = (self.frameRate ?? self.additionalFrameRate) ?? 30.0
|
|
self.mainComposeFramerate = round(sourceFrameRate / 30.0) * 30.0
|
|
writer.setupVideoInput(configuration: self.configuration, preferredTransform: nil, sourceFrameRate: sourceFrameRate)
|
|
|
|
if let reader {
|
|
let audioTracks = composition?.tracks(withMediaType: .audio) ?? []
|
|
if audioTracks.count > 0 {
|
|
let audioOutput = AVAssetReaderAudioMixOutput(audioTracks: audioTracks, audioSettings: nil)
|
|
audioOutput.audioMix = audioMix
|
|
audioOutput.alwaysCopiesSampleData = false
|
|
if reader.canAdd(audioOutput) {
|
|
reader.add(audioOutput)
|
|
} else {
|
|
self.internalStatus = .finished
|
|
self.statusValue = .failed(.addAudioOutput)
|
|
}
|
|
self.audioOutput = audioOutput
|
|
|
|
writer.setupAudioInput(configuration: self.configuration)
|
|
}
|
|
}
|
|
}
|
|
|
|
private var skippingAdditionalCopyUpdate = false
|
|
|
|
private func encodeVideo() -> Bool {
|
|
guard let writer = self.writer else {
|
|
return false
|
|
}
|
|
|
|
var appendFailed = false
|
|
while writer.isReadyForMoreVideoData {
|
|
if appendFailed {
|
|
return false
|
|
}
|
|
|
|
if let reader = self.reader, reader.status != .reading {
|
|
writer.markVideoAsFinished()
|
|
return false
|
|
}
|
|
if writer.status != .writing {
|
|
writer.markVideoAsFinished()
|
|
return false
|
|
}
|
|
self.pauseDispatchGroup.wait()
|
|
|
|
var updatedProgress = false
|
|
|
|
var mainInput: MediaEditorComposer.Input?
|
|
var additionalInput: MediaEditorComposer.Input?
|
|
var mainTimestamp: CMTime?
|
|
if let videoOutput = self.videoOutput {
|
|
if let sampleBuffer = videoOutput.copyNextSampleBuffer() {
|
|
if let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) {
|
|
let timestamp = CMSampleBufferGetPresentationTimeStamp(sampleBuffer)
|
|
mainTimestamp = timestamp
|
|
mainInput = .videoBuffer(VideoPixelBuffer(
|
|
pixelBuffer: pixelBuffer,
|
|
rotation: self.textureRotation,
|
|
timestamp: timestamp
|
|
))
|
|
|
|
if let duration = self.durationValue {
|
|
let startTime = self.reader?.timeRange.start.seconds ?? 0.0
|
|
let progress = (timestamp.seconds - startTime) / duration.seconds
|
|
self.statusValue = .progress(Float(progress))
|
|
updatedProgress = true
|
|
}
|
|
}
|
|
} else {
|
|
writer.markVideoAsFinished()
|
|
return false
|
|
}
|
|
}
|
|
if let additionalVideoOutput = self.additionalVideoOutput {
|
|
if let mainTimestamp, mainTimestamp < self.configuration.additionalVideoStartTime {
|
|
|
|
} else {
|
|
if self.skippingAdditionalCopyUpdate {
|
|
self.skippingAdditionalCopyUpdate = false
|
|
} else if let sampleBuffer = additionalVideoOutput.copyNextSampleBuffer() {
|
|
if let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) {
|
|
let timestamp = CMSampleBufferGetPresentationTimeStamp(sampleBuffer)
|
|
additionalInput = .videoBuffer(VideoPixelBuffer(
|
|
pixelBuffer: pixelBuffer,
|
|
rotation: self.additionalTextureRotation,
|
|
timestamp: timestamp
|
|
))
|
|
|
|
if !updatedProgress, let duration = self.durationValue {
|
|
let startTime = self.reader?.timeRange.start.seconds ?? 0.0
|
|
let progress = (timestamp.seconds - startTime) / duration.seconds
|
|
self.statusValue = .progress(Float(progress))
|
|
updatedProgress = true
|
|
}
|
|
}
|
|
if let additionalFrameRate = self.additionalFrameRate, let mainComposeFramerate = self.mainComposeFramerate {
|
|
let additionalFrameRate = round(additionalFrameRate / 30.0) * 30.0
|
|
if Int(mainComposeFramerate) == Int(additionalFrameRate) * 2 {
|
|
self.skippingAdditionalCopyUpdate = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if case let .image(image) = self.subject, let texture = self.composer?.textureForImage(image) {
|
|
mainInput = .texture(texture, self.imageArguments?.position ?? .zero)
|
|
|
|
if !updatedProgress, let imageArguments = self.imageArguments, let duration = self.durationValue {
|
|
let progress = imageArguments.position.seconds / duration.seconds
|
|
self.statusValue = .progress(Float(progress))
|
|
updatedProgress = true
|
|
}
|
|
}
|
|
|
|
if let composer = self.composer {
|
|
let timestamp: CMTime?
|
|
if let imageArguments = self.imageArguments {
|
|
timestamp = imageArguments.position
|
|
} else {
|
|
if case .image = self.subject {
|
|
timestamp = additionalInput?.timestamp
|
|
} else {
|
|
timestamp = mainInput?.timestamp
|
|
}
|
|
}
|
|
guard let timestamp else {
|
|
writer.markVideoAsFinished()
|
|
return false
|
|
}
|
|
composer.process(
|
|
main: mainInput!,
|
|
additional: additionalInput,
|
|
timestamp: timestamp,
|
|
pool: writer.pixelBufferPool,
|
|
completion: { pixelBuffer in
|
|
if let pixelBuffer {
|
|
if !writer.appendPixelBuffer(pixelBuffer, at: timestamp) {
|
|
writer.markVideoAsFinished()
|
|
appendFailed = true
|
|
}
|
|
} else {
|
|
appendFailed = true
|
|
}
|
|
self.semaphore.signal()
|
|
}
|
|
)
|
|
self.semaphore.wait()
|
|
|
|
if let imageArguments = self.imageArguments, let duration = self.durationValue {
|
|
let position = imageArguments.position + CMTime(value: 1, timescale: Int32(imageArguments.frameRate))
|
|
self.imageArguments = (imageArguments.frameRate, position)
|
|
|
|
if position.seconds >= duration.seconds {
|
|
Logger.shared.log("VideoExport", "Video finished")
|
|
writer.markVideoAsFinished()
|
|
return false
|
|
}
|
|
}
|
|
} else {
|
|
// if !writer.appendVideoBuffer(sampleBuffer) {
|
|
// writer.markVideoAsFinished()
|
|
// return false
|
|
// }
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
private func encodeAudio() -> Bool {
|
|
guard let writer = self.writer, let output = self.audioOutput else {
|
|
return false
|
|
}
|
|
|
|
while writer.isReadyForMoreAudioData {
|
|
if writer.status != .writing {
|
|
writer.markAudioAsFinished()
|
|
return false
|
|
}
|
|
self.pauseDispatchGroup.wait()
|
|
if let buffer = output.copyNextSampleBuffer() {
|
|
if !writer.appendAudioBuffer(buffer) {
|
|
writer.markAudioAsFinished()
|
|
return false
|
|
}
|
|
} else {
|
|
writer.markAudioAsFinished()
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
public func start() {
|
|
guard self.internalStatus == .idle, let writer = self.writer else {
|
|
self.statusValue = .failed(.invalid)
|
|
return
|
|
}
|
|
|
|
guard writer.startWriting() else {
|
|
self.statusValue = .failed(.writing(nil))
|
|
return
|
|
}
|
|
|
|
if let reader = self.reader, !reader.startReading() {
|
|
self.statusValue = .failed(.reading(nil))
|
|
return
|
|
}
|
|
|
|
if case .image = self.subject, self.additionalVideoOutput == nil {
|
|
self.imageArguments = (Double(self.configuration.frameRate), CMTime(value: 0, timescale: Int32(self.configuration.frameRate)))
|
|
}
|
|
|
|
self.internalStatus = .exporting
|
|
|
|
writer.startSession(atSourceTime: self.reader?.timeRange.start ?? .zero)
|
|
|
|
var videoCompleted = false
|
|
var audioCompleted = false
|
|
var exportForVideoOutput: MediaEditorVideoExport? = self
|
|
writer.requestVideoDataWhenReady(on: self.queue.queue) {
|
|
guard let export = exportForVideoOutput else { return }
|
|
if !export.encodeVideo() {
|
|
videoCompleted = true
|
|
exportForVideoOutput = nil
|
|
if audioCompleted {
|
|
export.finish()
|
|
}
|
|
}
|
|
}
|
|
|
|
if let _ = self.audioOutput {
|
|
var exportForAudioOutput: MediaEditorVideoExport? = self
|
|
writer.requestAudioDataWhenReady(on: self.queue.queue) {
|
|
guard let export = exportForAudioOutput else { return }
|
|
if !export.encodeAudio() {
|
|
audioCompleted = true
|
|
exportForAudioOutput = nil
|
|
if videoCompleted {
|
|
export.finish()
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
audioCompleted = true
|
|
}
|
|
}
|
|
|
|
private func finish() {
|
|
assert(self.queue.isCurrent())
|
|
|
|
guard let writer = self.writer else {
|
|
return
|
|
}
|
|
|
|
let outputUrl = URL(fileURLWithPath: self.outputPath)
|
|
|
|
var cancelled = false
|
|
if let reader = self.reader, reader.status == .cancelled {
|
|
if writer.status != .cancelled {
|
|
writer.cancelWriting()
|
|
}
|
|
cancelled = true
|
|
}
|
|
|
|
if writer.status == .cancelled {
|
|
if let reader = self.reader, reader.status != .cancelled {
|
|
reader.cancelReading()
|
|
}
|
|
cancelled = true
|
|
}
|
|
|
|
if cancelled {
|
|
try? FileManager.default.removeItem(at: outputUrl)
|
|
self.internalStatus = .finished
|
|
self.statusValue = .failed(.cancelled)
|
|
return
|
|
}
|
|
|
|
if writer.status == .failed {
|
|
if let error = writer.error {
|
|
Logger.shared.log("VideoExport", "Failed with writer error \(error.localizedDescription)")
|
|
}
|
|
try? FileManager.default.removeItem(at: outputUrl)
|
|
self.internalStatus = .finished
|
|
self.statusValue = .failed(.writing(nil))
|
|
} else if let reader = self.reader, reader.status == .failed {
|
|
if let error = reader.error {
|
|
Logger.shared.log("VideoExport", "Failed with reader error \(error.localizedDescription)")
|
|
}
|
|
try? FileManager.default.removeItem(at: outputUrl)
|
|
writer.cancelWriting()
|
|
self.internalStatus = .finished
|
|
self.statusValue = .failed(.reading(reader.error))
|
|
} else {
|
|
writer.finishWriting {
|
|
self.queue.async {
|
|
if writer.status == .failed {
|
|
if let error = writer.error {
|
|
Logger.shared.log("VideoExport", "Failed after finishWriting with writer error \(error.localizedDescription)")
|
|
}
|
|
try? FileManager.default.removeItem(at: outputUrl)
|
|
self.internalStatus = .finished
|
|
self.statusValue = .failed(.writing(nil))
|
|
} else {
|
|
self.internalStatus = .finished
|
|
self.statusValue = .completed
|
|
|
|
let end = CACurrentMediaTime()
|
|
let _ = (self.duration.get()
|
|
|> take(1)).start(next: { duration in
|
|
let exportDuration = end - self.startTimestamp
|
|
print("video processing took \(exportDuration)s")
|
|
if duration.seconds > 0 {
|
|
Logger.shared.log("VideoExport", "Video processing took \(exportDuration / duration.seconds)")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func pause() {
|
|
guard self.internalStatus == .exporting && self.cancelled == false else {
|
|
return
|
|
}
|
|
self.internalStatus = .paused
|
|
self.pauseDispatchGroup.enter()
|
|
}
|
|
|
|
func resume() {
|
|
guard self.internalStatus == .paused && self.cancelled == false else {
|
|
return
|
|
}
|
|
self.internalStatus = .exporting
|
|
self.pauseDispatchGroup.leave()
|
|
}
|
|
|
|
public func cancel() {
|
|
if case .paused = self.internalStatus {
|
|
self.resume()
|
|
}
|
|
self.cancelled = true
|
|
|
|
self.queue.async {
|
|
if let reader = self.reader, reader.status == .reading {
|
|
reader.cancelReading()
|
|
}
|
|
}
|
|
}
|
|
|
|
private let statusPromise = Promise<ExportStatus>(.unknown)
|
|
private var statusValue: ExportStatus = .unknown {
|
|
didSet {
|
|
self.statusPromise.set(.single(self.statusValue))
|
|
}
|
|
}
|
|
public var status: Signal<ExportStatus, NoError> {
|
|
return self.statusPromise.get()
|
|
}
|
|
}
|