|
|
import AVFoundation
|
|
|
import CoreImage
|
|
|
import CoreMedia
|
|
|
import CoreVideo
|
|
|
|
|
|
/// Schneidet eine 9:16-Quelle auf 4:5 zu und schreibt sie als MP4/H.264/AAC —
|
|
|
/// das feste Zielformat für die Meta-Ads-Veröffentlichung, unabhängig vom
|
|
|
/// Quellcodec (ProRes, H.264, HEVC, …). Läuft über `AVAssetReader`/
|
|
|
/// `AVAssetWriter` statt `AVAssetExportSession`, weil das die volle Kontrolle
|
|
|
/// über Zielbitrate und Profil gibt, die Presets nicht bieten.
|
|
|
///
|
|
|
/// Bekannte Grenzen dieser Implementierung:
|
|
|
/// - Der Crop läuft über eine 32BGRA-Zwischenstufe (CoreImage). Bei 10-Bit-
|
|
|
/// Quellen bedeutet das eine Requantisierung auf 8 Bit während des Crops —
|
|
|
/// für ein H.264-Ad-Deliverable ohnehin die Zielfarbtiefe, also keine
|
|
|
/// Einschränkung mehr wie bei einem codec-erhaltenden Export.
|
|
|
/// - Ziel ist ausschließlich `.mp4`; alles andere wird abgelehnt.
|
|
|
/// - Bitrate/Profil sind eine Faustregel an gängigen Meta-Ads-Empfehlungen
|
|
|
/// orientiert (H.264 High Profile, resolutionsabhängige Zielbitrate,
|
|
|
/// AAC-LC 128 kbit/s), keine von Meta veröffentlichte Formel — bei Bedarf
|
|
|
/// über `Options.videoBitRate`/`Options.audioBitRate` überschreibbar.
|
|
|
public enum CropEngine {
|
|
|
public struct Options {
|
|
|
/// -1...1, 0 = vertikal zentriert. Platzhalter für den in der README
|
|
|
/// als "Offene Punkte" genannten, später pro Datei einstellbaren Offset.
|
|
|
public var verticalOffset: CGFloat
|
|
|
/// false = eine bestehende Zieldatei wird nie stillschweigend überschrieben.
|
|
|
public var overwrite: Bool
|
|
|
/// Video-Zielbitrate in bit/s. nil = automatisch aus Auflösung und
|
|
|
/// Framerate berechnet.
|
|
|
public var videoBitRate: Int?
|
|
|
/// Audio-Zielbitrate in bit/s für AAC. nil = 128 kbit/s.
|
|
|
public var audioBitRate: Int?
|
|
|
|
|
|
public init(
|
|
|
verticalOffset: CGFloat = 0,
|
|
|
overwrite: Bool = false,
|
|
|
videoBitRate: Int? = nil,
|
|
|
audioBitRate: Int? = nil
|
|
|
) {
|
|
|
self.verticalOffset = verticalOffset
|
|
|
self.overwrite = overwrite
|
|
|
self.videoBitRate = videoBitRate
|
|
|
self.audioBitRate = audioBitRate
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// Reine Geometrie, kein AVFoundation-Zugriff — pur testbar.
|
|
|
/// Breite bleibt, Höhe = Breite × 5⁄4, auf eine gerade Zahl gerundet.
|
|
|
public static func targetSize(forSourceSize sourceSize: CGSize) -> CGSize {
|
|
|
let rawHeight = sourceSize.width * 5 / 4
|
|
|
let evenHeight = (rawHeight / 2).rounded() * 2
|
|
|
return CGSize(width: sourceSize.width, height: evenHeight)
|
|
|
}
|
|
|
|
|
|
public static func crop(
|
|
|
sourceURL: URL,
|
|
|
destinationURL: URL,
|
|
|
options: Options = Options(),
|
|
|
progress: ((Double) -> Void)? = nil
|
|
|
) async throws {
|
|
|
if !options.overwrite && FileManager.default.fileExists(atPath: destinationURL.path) {
|
|
|
throw CropEngineError.destinationAlreadyExists
|
|
|
}
|
|
|
let outputFileType = try fileType(forExtension: destinationURL.pathExtension)
|
|
|
|
|
|
let info = try await VideoInspector.inspect(sourceURL)
|
|
|
guard info.isNineBySixteen else {
|
|
|
throw CropEngineError.sourceNotNineBySixteen(actualSize: info.pixelSize)
|
|
|
}
|
|
|
|
|
|
let cropSize = targetSize(forSourceSize: info.pixelSize)
|
|
|
let cropOriginY = verticalCropOrigin(
|
|
|
sourceHeight: info.pixelSize.height,
|
|
|
targetHeight: cropSize.height,
|
|
|
verticalOffset: options.verticalOffset
|
|
|
)
|
|
|
let cropRect = CGRect(x: 0, y: cropOriginY, width: cropSize.width, height: cropSize.height)
|
|
|
|
|
|
let asset = AVURLAsset(url: sourceURL)
|
|
|
let tracks = try await asset.load(.tracks)
|
|
|
guard let videoTrack = tracks.first(where: { $0.mediaType == .video }) else {
|
|
|
throw CropEngineError.readerSetupFailed(underlying: VideoInspectorError.noVideoTrack)
|
|
|
}
|
|
|
let audioTrack = tracks.first(where: { $0.mediaType == .audio })
|
|
|
let videoSettings = videoEncoderSettings(size: cropSize, frameRate: info.frameRate, bitRateOverride: options.videoBitRate)
|
|
|
|
|
|
if options.overwrite {
|
|
|
try? FileManager.default.removeItem(at: destinationURL)
|
|
|
}
|
|
|
|
|
|
let reader: AVAssetReader
|
|
|
do {
|
|
|
reader = try AVAssetReader(asset: asset)
|
|
|
} catch {
|
|
|
throw CropEngineError.readerSetupFailed(underlying: error)
|
|
|
}
|
|
|
|
|
|
let videoReaderSettings: [String: Any] = [
|
|
|
kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA
|
|
|
]
|
|
|
let videoOutput = AVAssetReaderTrackOutput(track: videoTrack, outputSettings: videoReaderSettings)
|
|
|
videoOutput.alwaysCopiesSampleData = false
|
|
|
guard reader.canAdd(videoOutput) else {
|
|
|
throw CropEngineError.readerSetupFailed(underlying: nil)
|
|
|
}
|
|
|
reader.add(videoOutput)
|
|
|
|
|
|
var audioOutput: AVAssetReaderTrackOutput?
|
|
|
if let audioTrack {
|
|
|
// Decodiert zu PCM — der Writer-Input unten enkodiert das dann nach AAC.
|
|
|
let audioReaderSettings: [String: Any] = [AVFormatIDKey: kAudioFormatLinearPCM]
|
|
|
let output = AVAssetReaderTrackOutput(track: audioTrack, outputSettings: audioReaderSettings)
|
|
|
output.alwaysCopiesSampleData = false
|
|
|
guard reader.canAdd(output) else {
|
|
|
throw CropEngineError.readerSetupFailed(underlying: nil)
|
|
|
}
|
|
|
reader.add(output)
|
|
|
audioOutput = output
|
|
|
}
|
|
|
|
|
|
let writer: AVAssetWriter
|
|
|
do {
|
|
|
writer = try AVAssetWriter(outputURL: destinationURL, fileType: outputFileType)
|
|
|
} catch {
|
|
|
throw CropEngineError.writerSetupFailed(underlying: error)
|
|
|
}
|
|
|
|
|
|
let videoInput = AVAssetWriterInput(mediaType: .video, outputSettings: videoSettings)
|
|
|
videoInput.expectsMediaDataInRealTime = false
|
|
|
guard writer.canAdd(videoInput) else {
|
|
|
throw CropEngineError.writerSetupFailed(underlying: nil)
|
|
|
}
|
|
|
writer.add(videoInput)
|
|
|
|
|
|
let pixelBufferAttributes: [String: Any] = [
|
|
|
kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA,
|
|
|
kCVPixelBufferWidthKey as String: Int(cropSize.width),
|
|
|
kCVPixelBufferHeightKey as String: Int(cropSize.height)
|
|
|
]
|
|
|
let pixelBufferAdaptor = AVAssetWriterInputPixelBufferAdaptor(
|
|
|
assetWriterInput: videoInput,
|
|
|
sourcePixelBufferAttributes: pixelBufferAttributes
|
|
|
)
|
|
|
|
|
|
var audioInput: AVAssetWriterInput?
|
|
|
if audioOutput != nil, let audioTrack {
|
|
|
let sourceChannelCount = try await audioTrack.load(.formatDescriptions)
|
|
|
.first
|
|
|
.flatMap { CMAudioFormatDescriptionGetStreamBasicDescription($0)?.pointee.mChannelsPerFrame }
|
|
|
.map(Int.init) ?? 2
|
|
|
let audioSettings = audioEncoderSettings(sourceChannelCount: sourceChannelCount, bitRateOverride: options.audioBitRate)
|
|
|
let input = AVAssetWriterInput(mediaType: .audio, outputSettings: audioSettings)
|
|
|
input.expectsMediaDataInRealTime = false
|
|
|
guard writer.canAdd(input) else {
|
|
|
throw CropEngineError.writerSetupFailed(underlying: nil)
|
|
|
}
|
|
|
writer.add(input)
|
|
|
audioInput = input
|
|
|
}
|
|
|
|
|
|
guard reader.startReading() else {
|
|
|
throw CropEngineError.readerSetupFailed(underlying: reader.error)
|
|
|
}
|
|
|
guard writer.startWriting() else {
|
|
|
throw CropEngineError.writerSetupFailed(underlying: writer.error)
|
|
|
}
|
|
|
writer.startSession(atSourceTime: .zero)
|
|
|
|
|
|
do {
|
|
|
let durationSeconds = CMTimeGetSeconds(info.duration)
|
|
|
let ciContext = CIContext()
|
|
|
|
|
|
try await withThrowingTaskGroup(of: Void.self) { group in
|
|
|
group.addTask {
|
|
|
try await processVideo(
|
|
|
output: videoOutput,
|
|
|
input: videoInput,
|
|
|
adaptor: pixelBufferAdaptor,
|
|
|
cropRect: cropRect,
|
|
|
ciContext: ciContext,
|
|
|
durationSeconds: durationSeconds,
|
|
|
progress: progress
|
|
|
)
|
|
|
}
|
|
|
if let audioOutput, let audioInput {
|
|
|
group.addTask {
|
|
|
try await transcodeAudio(output: audioOutput, input: audioInput)
|
|
|
}
|
|
|
}
|
|
|
try await group.waitForAll()
|
|
|
}
|
|
|
|
|
|
await writer.finishWriting()
|
|
|
guard writer.status == .completed else {
|
|
|
throw CropEngineError.processingFailed(underlying: writer.error)
|
|
|
}
|
|
|
} catch {
|
|
|
reader.cancelReading()
|
|
|
writer.cancelWriting()
|
|
|
try? FileManager.default.removeItem(at: destinationURL)
|
|
|
throw error
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// MARK: - Geometrie
|
|
|
|
|
|
private static func verticalCropOrigin(sourceHeight: CGFloat, targetHeight: CGFloat, verticalOffset: CGFloat) -> CGFloat {
|
|
|
let slack = max(sourceHeight - targetHeight, 0)
|
|
|
let centered = slack / 2
|
|
|
let shifted = centered + (verticalOffset * slack / 2)
|
|
|
let clamped = min(max(shifted, 0), slack)
|
|
|
return (clamped / 2).rounded() * 2
|
|
|
}
|
|
|
|
|
|
// MARK: - Container & Codec
|
|
|
|
|
|
/// Nur MP4 — das ist das feste Zielformat für die Meta-Ads-Auslieferung.
|
|
|
private static func fileType(forExtension fileExtension: String) throws -> AVFileType {
|
|
|
switch fileExtension.lowercased() {
|
|
|
case "mp4":
|
|
|
return .mp4
|
|
|
default:
|
|
|
throw CropEngineError.unsupportedContainer(fileExtension: fileExtension)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private static func videoEncoderSettings(size: CGSize, frameRate: Float, bitRateOverride: Int?) -> [String: Any] {
|
|
|
let width = Int(size.width)
|
|
|
let height = Int(size.height)
|
|
|
let bitRate = bitRateOverride ?? recommendedVideoBitRate(width: width, height: height, frameRate: frameRate)
|
|
|
let keyFrameInterval = max(Int(frameRate.rounded()) * 2, 1)
|
|
|
|
|
|
return [
|
|
|
AVVideoCodecKey: AVVideoCodecType.h264,
|
|
|
AVVideoWidthKey: width,
|
|
|
AVVideoHeightKey: height,
|
|
|
AVVideoCompressionPropertiesKey: [
|
|
|
AVVideoAverageBitRateKey: bitRate,
|
|
|
AVVideoProfileLevelKey: AVVideoProfileLevelH264HighAutoLevel,
|
|
|
AVVideoMaxKeyFrameIntervalKey: keyFrameInterval
|
|
|
]
|
|
|
]
|
|
|
}
|
|
|
|
|
|
/// Faustregel für eine Meta-Ads-taugliche H.264-Qualität: ~0.1 Bit pro
|
|
|
/// Pixel und Frame, geklemmt auf einen sinnvollen Korridor. Orientiert an
|
|
|
/// Metas Empfehlung von grob mindestens 8 Mbit/s für 1080-Klasse-Vertikal-
|
|
|
/// /4:5-Formate — keine von Meta veröffentlichte Formel, im Zweifel gegen
|
|
|
/// die aktuelle Meta-Spec-Seite prüfen.
|
|
|
private static func recommendedVideoBitRate(width: Int, height: Int, frameRate: Float) -> Int {
|
|
|
let pixelsPerSecond = Double(width * height) * Double(frameRate)
|
|
|
let bitsPerPixel = 0.1
|
|
|
let raw = Int(pixelsPerSecond * bitsPerPixel)
|
|
|
return min(max(raw, 6_000_000), 25_000_000)
|
|
|
}
|
|
|
|
|
|
/// AAC-LC, 48 kHz, Metas Empfehlung von mindestens 128 kbit/s für Stereo.
|
|
|
/// Kanalzahl folgt der Quelle (max. Stereo).
|
|
|
private static func audioEncoderSettings(sourceChannelCount: Int, bitRateOverride: Int?) -> [String: Any] {
|
|
|
let channels = min(max(sourceChannelCount, 1), 2)
|
|
|
return [
|
|
|
AVFormatIDKey: kAudioFormatMPEG4AAC,
|
|
|
AVSampleRateKey: 48_000,
|
|
|
AVNumberOfChannelsKey: channels,
|
|
|
AVEncoderBitRateKey: bitRateOverride ?? 128_000
|
|
|
]
|
|
|
}
|
|
|
|
|
|
// MARK: - Verarbeitung
|
|
|
|
|
|
private static func processVideo(
|
|
|
output: AVAssetReaderTrackOutput,
|
|
|
input: AVAssetWriterInput,
|
|
|
adaptor: AVAssetWriterInputPixelBufferAdaptor,
|
|
|
cropRect: CGRect,
|
|
|
ciContext: CIContext,
|
|
|
durationSeconds: Double,
|
|
|
progress: ((Double) -> Void)?
|
|
|
) async throws {
|
|
|
let queue = DispatchQueue(label: "dev.zielke.droptwo.cropengine.video")
|
|
|
try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
|
|
|
var didResume = false
|
|
|
func finish(throwing error: Error? = nil) {
|
|
|
guard !didResume else { return }
|
|
|
didResume = true
|
|
|
input.markAsFinished()
|
|
|
if let error {
|
|
|
continuation.resume(throwing: error)
|
|
|
} else {
|
|
|
continuation.resume()
|
|
|
}
|
|
|
}
|
|
|
|
|
|
input.requestMediaDataWhenReady(on: queue) {
|
|
|
while input.isReadyForMoreMediaData {
|
|
|
guard let sampleBuffer = output.copyNextSampleBuffer() else {
|
|
|
finish()
|
|
|
return
|
|
|
}
|
|
|
guard let sourceBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { continue }
|
|
|
let presentationTime = CMSampleBufferGetPresentationTimeStamp(sampleBuffer)
|
|
|
|
|
|
guard let pool = adaptor.pixelBufferPool else {
|
|
|
finish(throwing: CropEngineError.processingFailed(underlying: nil))
|
|
|
return
|
|
|
}
|
|
|
var pixelBufferOut: CVPixelBuffer?
|
|
|
let status = CVPixelBufferPoolCreatePixelBuffer(nil, pool, &pixelBufferOut)
|
|
|
guard status == kCVReturnSuccess, let outBuffer = pixelBufferOut else {
|
|
|
finish(throwing: CropEngineError.processingFailed(underlying: nil))
|
|
|
return
|
|
|
}
|
|
|
|
|
|
let croppedImage = CIImage(cvPixelBuffer: sourceBuffer)
|
|
|
.cropped(to: cropRect)
|
|
|
.transformed(by: CGAffineTransform(translationX: -cropRect.origin.x, y: -cropRect.origin.y))
|
|
|
ciContext.render(croppedImage, to: outBuffer)
|
|
|
|
|
|
if !adaptor.append(outBuffer, withPresentationTime: presentationTime) {
|
|
|
finish(throwing: CropEngineError.processingFailed(underlying: nil))
|
|
|
return
|
|
|
}
|
|
|
|
|
|
if durationSeconds > 0 {
|
|
|
progress?(min(CMTimeGetSeconds(presentationTime) / durationSeconds, 1.0))
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// Liest decodierte PCM-Samples und reicht sie an den Writer-Input durch;
|
|
|
/// der enkodiert sie anhand seiner `outputSettings` nach AAC. Kein
|
|
|
/// manuelles Audio-Graph-Setup nötig — das ist Standard-AVFoundation-
|
|
|
/// Verhalten für nicht-passthrough Writer-Inputs.
|
|
|
private static func transcodeAudio(output: AVAssetReaderTrackOutput, input: AVAssetWriterInput) async throws {
|
|
|
let queue = DispatchQueue(label: "dev.zielke.droptwo.cropengine.audio")
|
|
|
try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
|
|
|
var didResume = false
|
|
|
input.requestMediaDataWhenReady(on: queue) {
|
|
|
while input.isReadyForMoreMediaData {
|
|
|
guard let sampleBuffer = output.copyNextSampleBuffer() else {
|
|
|
guard !didResume else { return }
|
|
|
didResume = true
|
|
|
input.markAsFinished()
|
|
|
continuation.resume()
|
|
|
return
|
|
|
}
|
|
|
if !input.append(sampleBuffer) {
|
|
|
guard !didResume else { return }
|
|
|
didResume = true
|
|
|
input.markAsFinished()
|
|
|
continuation.resume(throwing: CropEngineError.processingFailed(underlying: nil))
|
|
|
return
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public enum CropEngineError: Error {
|
|
|
case sourceNotNineBySixteen(actualSize: CGSize)
|
|
|
case destinationAlreadyExists
|
|
|
case unsupportedContainer(fileExtension: String)
|
|
|
case readerSetupFailed(underlying: Error?)
|
|
|
case writerSetupFailed(underlying: Error?)
|
|
|
case processingFailed(underlying: Error?)
|
|
|
}
|
