|
|
import AVFoundation
|
|
|
import CoreMedia
|
|
|
|
|
|
/// Erzeugt winzige, echte Videodateien zur Laufzeit für die Tests — statt
|
|
|
/// Binärdateien einzuchecken. Passt zur "textbasiert, merge-freundlich"-
|
|
|
/// Philosophie des Repos und hält die Tests hermetisch reproduzierbar.
|
|
|
enum TestVideoFactory {
|
|
|
struct GeneratedVideo {
|
|
|
let url: URL
|
|
|
let size: CGSize
|
|
|
let seconds: Double
|
|
|
let hasAudio: Bool
|
|
|
}
|
|
|
|
|
|
/// Bildinhalt der erzeugten Frames.
|
|
|
enum Pattern {
|
|
|
/// Ganze Fläche einfarbig grau, Helligkeit wechselt von Frame zu Frame.
|
|
|
case flatByFrameIndex
|
|
|
/// Obere Bildhälfte weiß, untere schwarz — damit lässt sich prüfen,
|
|
|
/// welcher vertikale Ausschnitt tatsächlich gerendert wurde.
|
|
|
case brightTopDarkBottom
|
|
|
/// Linke Bildhälfte weiß, rechte schwarz — für quer gespeicherte,
|
|
|
/// per Transformation gedrehte Clips (iPhone).
|
|
|
case brightLeftDarkRight
|
|
|
}
|
|
|
|
|
|
enum FactoryError: Error {
|
|
|
case writerSetupFailed(underlying: Error?)
|
|
|
case pixelBufferPoolUnavailable
|
|
|
case pixelBufferCreationFailed
|
|
|
case audioBufferCreationFailed
|
|
|
}
|
|
|
|
|
|
/// 9:16-Clip, Standardgröße 216×384 (kleinstmögliches Vielfaches, das
|
|
|
/// exakt 9:16 trifft und für Tests schnell zu erzeugen/verarbeiten ist).
|
|
|
static func makeNineBySixteenClip(
|
|
|
frameRate: Int32 = 10,
|
|
|
seconds: Double = 2,
|
|
|
includeAudio: Bool = true,
|
|
|
pattern: Pattern = .flatByFrameIndex,
|
|
|
fileName: String? = nil,
|
|
|
in directory: URL
|
|
|
) throws -> GeneratedVideo {
|
|
|
try makeClip(
|
|
|
size: CGSize(width: 216, height: 384),
|
|
|
frameRate: frameRate,
|
|
|
seconds: seconds,
|
|
|
includeAudio: includeAudio,
|
|
|
pattern: pattern,
|
|
|
fileName: fileName,
|
|
|
in: directory
|
|
|
)
|
|
|
}
|
|
|
|
|
|
static func makeClip(
|
|
|
size: CGSize,
|
|
|
frameRate: Int32 = 10,
|
|
|
seconds: Double = 2,
|
|
|
includeAudio: Bool = true,
|
|
|
pattern: Pattern = .flatByFrameIndex,
|
|
|
transform: CGAffineTransform = .identity,
|
|
|
fileName: String? = nil,
|
|
|
in directory: URL
|
|
|
) throws -> GeneratedVideo {
|
|
|
let url = fileName.map { directory.appendingPathComponent($0) }
|
|
|
?? directory.appendingPathComponent(UUID().uuidString).appendingPathExtension("mov")
|
|
|
|
|
|
let writer: AVAssetWriter
|
|
|
do {
|
|
|
writer = try AVAssetWriter(outputURL: url, fileType: .mov)
|
|
|
} catch {
|
|
|
throw FactoryError.writerSetupFailed(underlying: error)
|
|
|
}
|
|
|
|
|
|
let videoSettings: [String: Any] = [
|
|
|
AVVideoCodecKey: AVVideoCodecType.h264,
|
|
|
AVVideoWidthKey: Int(size.width),
|
|
|
AVVideoHeightKey: Int(size.height)
|
|
|
]
|
|
|
let videoInput = AVAssetWriterInput(mediaType: .video, outputSettings: videoSettings)
|
|
|
videoInput.expectsMediaDataInRealTime = false
|
|
|
videoInput.transform = transform
|
|
|
|
|
|
let pixelBufferAttributes: [String: Any] = [
|
|
|
kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_32BGRA,
|
|
|
kCVPixelBufferWidthKey as String: Int(size.width),
|
|
|
kCVPixelBufferHeightKey as String: Int(size.height)
|
|
|
]
|
|
|
let adaptor = AVAssetWriterInputPixelBufferAdaptor(
|
|
|
assetWriterInput: videoInput,
|
|
|
sourcePixelBufferAttributes: pixelBufferAttributes
|
|
|
)
|
|
|
guard writer.canAdd(videoInput) else {
|
|
|
throw FactoryError.writerSetupFailed(underlying: nil)
|
|
|
}
|
|
|
writer.add(videoInput)
|
|
|
|
|
|
var audioInput: AVAssetWriterInput?
|
|
|
if includeAudio {
|
|
|
let audioSettings: [String: Any] = [
|
|
|
AVFormatIDKey: kAudioFormatLinearPCM,
|
|
|
AVSampleRateKey: 44_100,
|
|
|
AVNumberOfChannelsKey: 1,
|
|
|
AVLinearPCMBitDepthKey: 16,
|
|
|
AVLinearPCMIsFloatKey: false,
|
|
|
AVLinearPCMIsBigEndianKey: false,
|
|
|
AVLinearPCMIsNonInterleaved: false
|
|
|
]
|
|
|
let input = AVAssetWriterInput(mediaType: .audio, outputSettings: audioSettings)
|
|
|
input.expectsMediaDataInRealTime = false
|
|
|
guard writer.canAdd(input) else {
|
|
|
throw FactoryError.writerSetupFailed(underlying: nil)
|
|
|
}
|
|
|
writer.add(input)
|
|
|
audioInput = input
|
|
|
}
|
|
|
|
|
|
guard writer.startWriting() else {
|
|
|
throw FactoryError.writerSetupFailed(underlying: writer.error)
|
|
|
}
|
|
|
writer.startSession(atSourceTime: .zero)
|
|
|
|
|
|
let frameCount = Int(seconds * Double(frameRate))
|
|
|
try appendFrames(count: frameCount, frameRate: frameRate, pattern: pattern, input: videoInput, adaptor: adaptor)
|
|
|
|
|
|
if let audioInput {
|
|
|
try appendAudio(seconds: seconds, sampleRate: 44_100, input: audioInput)
|
|
|
}
|
|
|
|
|
|
let semaphore = DispatchSemaphore(value: 0)
|
|
|
writer.finishWriting { semaphore.signal() }
|
|
|
semaphore.wait()
|
|
|
|
|
|
guard writer.status == .completed else {
|
|
|
throw FactoryError.writerSetupFailed(underlying: writer.error)
|
|
|
}
|
|
|
|
|
|
return GeneratedVideo(url: url, size: size, seconds: seconds, hasAudio: includeAudio)
|
|
|
}
|
|
|
|
|
|
// MARK: - Video
|
|
|
|
|
|
/// Wichtig: `isReadyForMoreMediaData` wird bei `expectsMediaDataInRealTime
|
|
|
/// = false` erst durch `requestMediaDataWhenReady` überhaupt getrieben —
|
|
|
/// ein reines Polling auf das Flag ohne diesen Callback bleibt für immer
|
|
|
/// bei `false` hängen. Selbe Technik wie in `CropEngine`, nur synchron
|
|
|
/// per Semaphore statt async/await gebrückt.
|
|
|
private static func appendFrames(
|
|
|
count: Int,
|
|
|
frameRate: Int32,
|
|
|
pattern: Pattern,
|
|
|
input: AVAssetWriterInput,
|
|
|
adaptor: AVAssetWriterInputPixelBufferAdaptor
|
|
|
) throws {
|
|
|
let queue = DispatchQueue(label: "dev.zielke.droptwo.testvideofactory.video")
|
|
|
let semaphore = DispatchSemaphore(value: 0)
|
|
|
var thrownError: Error?
|
|
|
var nextFrameIndex = 0
|
|
|
|
|
|
input.requestMediaDataWhenReady(on: queue) {
|
|
|
while input.isReadyForMoreMediaData {
|
|
|
guard nextFrameIndex < count else {
|
|
|
input.markAsFinished()
|
|
|
semaphore.signal()
|
|
|
return
|
|
|
}
|
|
|
guard let pool = adaptor.pixelBufferPool else {
|
|
|
thrownError = FactoryError.pixelBufferPoolUnavailable
|
|
|
input.markAsFinished()
|
|
|
semaphore.signal()
|
|
|
return
|
|
|
}
|
|
|
var pixelBufferOut: CVPixelBuffer?
|
|
|
CVPixelBufferPoolCreatePixelBuffer(nil, pool, &pixelBufferOut)
|
|
|
guard let pixelBuffer = pixelBufferOut else {
|
|
|
thrownError = FactoryError.pixelBufferCreationFailed
|
|
|
input.markAsFinished()
|
|
|
semaphore.signal()
|
|
|
return
|
|
|
}
|
|
|
fill(pixelBuffer: pixelBuffer, frameIndex: nextFrameIndex, pattern: pattern)
|
|
|
let presentationTime = CMTime(value: CMTimeValue(nextFrameIndex), timescale: frameRate)
|
|
|
adaptor.append(pixelBuffer, withPresentationTime: presentationTime)
|
|
|
nextFrameIndex += 1
|
|
|
}
|
|
|
}
|
|
|
|
|
|
semaphore.wait()
|
|
|
if let thrownError {
|
|
|
throw thrownError
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private static func fill(pixelBuffer: CVPixelBuffer, frameIndex: Int, pattern: Pattern) {
|
|
|
CVPixelBufferLockBaseAddress(pixelBuffer, [])
|
|
|
defer { CVPixelBufferUnlockBaseAddress(pixelBuffer, []) }
|
|
|
guard let base = CVPixelBufferGetBaseAddress(pixelBuffer) else { return }
|
|
|
let bytesPerRow = CVPixelBufferGetBytesPerRow(pixelBuffer)
|
|
|
let height = CVPixelBufferGetHeight(pixelBuffer)
|
|
|
switch pattern {
|
|
|
case .flatByFrameIndex:
|
|
|
let value = Int32(UInt8((frameIndex * 37) % 256))
|
|
|
memset(base, value, bytesPerRow * height)
|
|
|
case .brightTopDarkBottom:
|
|
|
let topRows = height / 2
|
|
|
memset(base, 255, bytesPerRow * topRows)
|
|
|
memset(base + bytesPerRow * topRows, 0, bytesPerRow * (height - topRows))
|
|
|
case .brightLeftDarkRight:
|
|
|
let width = CVPixelBufferGetWidth(pixelBuffer)
|
|
|
for row in 0..<height {
|
|
|
let rowStart = base + row * bytesPerRow
|
|
|
memset(rowStart, 255, (width / 2) * 4)
|
|
|
memset(rowStart + (width / 2) * 4, 0, bytesPerRow - (width / 2) * 4)
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// MARK: - Auswertung
|
|
|
|
|
|
/// Mittlere Helligkeit (0…1) des Frames bei `seconds` — gerechnet über
|
|
|
/// alle Pixel, auf ein kleines Graubild heruntergerechnet.
|
|
|
static func averageBrightness(of url: URL, at seconds: Double) async throws -> Double {
|
|
|
let generator = AVAssetImageGenerator(asset: AVURLAsset(url: url))
|
|
|
generator.requestedTimeToleranceBefore = .zero
|
|
|
generator.requestedTimeToleranceAfter = .zero
|
|
|
let time = CMTime(seconds: seconds, preferredTimescale: 600)
|
|
|
let image = try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<CGImage, Error>) in
|
|
|
generator.generateCGImagesAsynchronously(forTimes: [NSValue(time: time)]) { _, image, _, _, error in
|
|
|
if let image {
|
|
|
continuation.resume(returning: image)
|
|
|
} else {
|
|
|
continuation.resume(throwing: error ?? FactoryError.pixelBufferCreationFailed)
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
let side = 16
|
|
|
var pixels = [UInt8](repeating: 0, count: side * side)
|
|
|
let drawn = pixels.withUnsafeMutableBytes { buffer -> Bool in
|
|
|
guard let context = CGContext(
|
|
|
data: buffer.baseAddress,
|
|
|
width: side,
|
|
|
height: side,
|
|
|
bitsPerComponent: 8,
|
|
|
bytesPerRow: side,
|
|
|
space: CGColorSpaceCreateDeviceGray(),
|
|
|
bitmapInfo: CGImageAlphaInfo.none.rawValue
|
|
|
) else { return false }
|
|
|
context.draw(image, in: CGRect(x: 0, y: 0, width: side, height: side))
|
|
|
return true
|
|
|
}
|
|
|
guard drawn else { throw FactoryError.pixelBufferCreationFailed }
|
|
|
return Double(pixels.reduce(0) { $0 + Int($1) }) / Double(pixels.count * 255)
|
|
|
}
|
|
|
|
|
|
// MARK: - Audio
|
|
|
|
|
|
private static func appendAudio(seconds: Double, sampleRate: Double, input: AVAssetWriterInput) throws {
|
|
|
let frameCount = AVAudioFrameCount(seconds * sampleRate)
|
|
|
guard let format = AVAudioFormat(commonFormat: .pcmFormatInt16, sampleRate: sampleRate, channels: 1, interleaved: true),
|
|
|
let pcmBuffer = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: frameCount) else {
|
|
|
throw FactoryError.audioBufferCreationFailed
|
|
|
}
|
|
|
pcmBuffer.frameLength = frameCount
|
|
|
guard let channelData = pcmBuffer.int16ChannelData else {
|
|
|
throw FactoryError.audioBufferCreationFailed
|
|
|
}
|
|
|
|
|
|
let frequency = 440.0
|
|
|
for frame in 0..<Int(frameCount) {
|
|
|
let sample = sin(2.0 * .pi * frequency * Double(frame) / sampleRate)
|
|
|
channelData[0][frame] = Int16(sample * Double(Int16.max) * 0.2)
|
|
|
}
|
|
|
|
|
|
guard let formatDescription = format.formatDescription as CMFormatDescription? else {
|
|
|
throw FactoryError.audioBufferCreationFailed
|
|
|
}
|
|
|
|
|
|
var timing = CMSampleTimingInfo(
|
|
|
duration: CMTime(value: 1, timescale: Int32(sampleRate)),
|
|
|
presentationTimeStamp: .zero,
|
|
|
decodeTimeStamp: .invalid
|
|
|
)
|
|
|
var sampleBuffer: CMSampleBuffer?
|
|
|
let createStatus = CMSampleBufferCreate(
|
|
|
allocator: kCFAllocatorDefault,
|
|
|
dataBuffer: nil,
|
|
|
dataReady: false,
|
|
|
makeDataReadyCallback: nil,
|
|
|
refcon: nil,
|
|
|
formatDescription: formatDescription,
|
|
|
sampleCount: CMItemCount(frameCount),
|
|
|
sampleTimingEntryCount: 1,
|
|
|
sampleTimingArray: &timing,
|
|
|
sampleSizeEntryCount: 0,
|
|
|
sampleSizeArray: nil,
|
|
|
sampleBufferOut: &sampleBuffer
|
|
|
)
|
|
|
guard createStatus == noErr, let buffer = sampleBuffer else {
|
|
|
throw FactoryError.audioBufferCreationFailed
|
|
|
}
|
|
|
|
|
|
let setDataStatus = CMSampleBufferSetDataBufferFromAudioBufferList(
|
|
|
buffer,
|
|
|
blockBufferAllocator: kCFAllocatorDefault,
|
|
|
blockBufferMemoryAllocator: kCFAllocatorDefault,
|
|
|
flags: 0,
|
|
|
bufferList: pcmBuffer.mutableAudioBufferList
|
|
|
)
|
|
|
guard setDataStatus == noErr else {
|
|
|
throw FactoryError.audioBufferCreationFailed
|
|
|
}
|
|
|
|
|
|
let queue = DispatchQueue(label: "dev.zielke.droptwo.testvideofactory.audio")
|
|
|
let semaphore = DispatchSemaphore(value: 0)
|
|
|
var didAppend = false
|
|
|
|
|
|
input.requestMediaDataWhenReady(on: queue) {
|
|
|
guard input.isReadyForMoreMediaData, !didAppend else { return }
|
|
|
didAppend = true
|
|
|
input.append(buffer)
|
|
|
input.markAsFinished()
|
|
|
semaphore.signal()
|
|
|
}
|
|
|
|
|
|
semaphore.wait()
|
|
|
}
|
|
|
}
|
