let5see/to-live-photo
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

feat(M1): 完成 MVP 核心功能，添加埋点和应用图标

Browse Source 
主要改动：
- 移除调试导出功能（exportToDocuments 及相关 UI）
- EditorView 添加封面帧预览和关键帧时间选择
- 新增 Analytics.swift 基础埋点模块（使用 os.Logger）
- 创建 Live Photo 风格应用图标（SVG → PNG）
- 优化 LivePhotoCore：简化代码结构，修复宽高比问题
- 添加单元测试资源文件 metadata.mov
- 更新 TASK.md 进度追踪

M1 MVP 闭环已完成：
✅ 5个核心页面（Home/Editor/Processing/Result/WallpaperGuide）
✅ 时长裁剪 + 封面帧选择
✅ 完整生成管线 + 相册保存 + 系统验证
✅ 壁纸设置引导（iOS 16/17+ 差异化文案）
✅ 基础埋点事件追踪

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
empty
2025-12-14 20:34:20 +08:00
parent 299415a530
commit a8b334ef39
14 changed files with 930 additions and 475 deletions
Download Patch File Download Diff File Expand all files Collapse all files

578
Sources/LivePhotoCore/LivePhotoCore.swift
View File

@@ -5,6 +5,7 @@ import os
import Photos
import UIKit
import UniformTypeIdentifiers
import VideoToolbox
public enum LivePhotoBuildStage: String, Codable, Sendable {
case normalize
@@ -349,23 +350,6 @@ public struct LivePhotoBuildOutput: Sendable, Hashable {
self.pairedImageURL = pairedImageURL
self.pairedVideoURL = pairedVideoURL
}
/// 将生成的文件导出到文档目录（方便调试）
public func exportToDocuments() throws -> (photoURL: URL, videoURL: URL) {
let docs = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
let photoDestURL = docs.appendingPathComponent("debug_photo.heic")
let videoDestURL = docs.appendingPathComponent("debug_video.mov")
// 删除旧文件
try? FileManager.default.removeItem(at: photoDestURL)
try? FileManager.default.removeItem(at: videoDestURL)
// 复制新文件
try FileManager.default.copyItem(at: pairedImageURL, to: photoDestURL)
try FileManager.default.copyItem(at: pairedVideoURL, to: videoDestURL)
return (photoDestURL, videoDestURL)
}
}
public actor LivePhotoBuilder {
@@ -395,23 +379,23 @@ public actor LivePhotoBuilder {
destinationURL: paths.workDir.appendingPathComponent("trimmed.mov")
)
let trimmedDuration = exportParams.trimEnd - exportParams.trimStart
let relativeKeyFrameTime = min(max(0, exportParams.keyFrameTime - exportParams.trimStart), trimmedDuration)
// 计算 LivePhotoVideoIndex（需要视频的帧率信息）
let nominalFrameRateForIndex: Float = {
let asset = AVURLAsset(url: trimmedVideoURL)
let rate = asset.tracks(withMediaType: .video).first?.nominalFrameRate ?? 30
return (rate.isFinite && rate > 0) ? rate : 30
}()
let livePhotoVideoIndex = Self.makeLivePhotoVideoIndex(
stillImageTimeSeconds: relativeKeyFrameTime,
nominalFrameRate: nominalFrameRateForIndex
// 关键：将视频变速到约 1 秒，与 metadata.mov 的时间标记匹配
// live-wallpaper 项目使用 CMTimeMake(550, 600) = 0.917 秒
// 我们使用 1 秒以完全匹配 metadata.mov 的时长
let targetDuration = CMTimeMake(value: 550, timescale: 600) // ~0.917 秒，与 live-wallpaper 一致
progress?(LivePhotoBuildProgress(stage: .normalize, fraction: 0.5))
let scaledVideoURL = try await scaleVideoToTargetDuration(
sourceURL: trimmedVideoURL,
targetDuration: targetDuration,
destinationURL: paths.workDir.appendingPathComponent("scaled.mov")
)
// 计算关键帧时间：目标视频的中间位置（0.5 秒处，与 metadata.mov 的 still-image-time 匹配）
let relativeKeyFrameTime = 0.5 // 固定为 0.5 秒，与 metadata.mov 匹配
progress?(LivePhotoBuildProgress(stage: .extractKeyFrame, fraction: 0))
let keyPhotoURL = try await resolveKeyPhotoURL(
videoURL: trimmedVideoURL,
videoURL: scaledVideoURL,
coverImageURL: coverImageURL,
keyFrameTime: relativeKeyFrameTime,
destinationURL: paths.workDir.appendingPathComponent("keyPhoto").appendingPathExtension("heic")
@@ -421,14 +405,13 @@ public actor LivePhotoBuilder {
guard let pairedImageURL = addAssetID(
assetIdentifier,
toImage: keyPhotoURL,
saveTo: paths.photoURL,
livePhotoVideoIndex: livePhotoVideoIndex
saveTo: paths.photoURL
) else {
throw AppError(code: "LPB-201", stage: .writePhotoMetadata, message: "封面生成失败", underlyingErrorDescription: nil, suggestedActions: ["缩短时长", "降低分辨率", "重试"])
}
progress?(LivePhotoBuildProgress(stage: .writeVideoMetadata, fraction: 0))
let pairedVideoURL = try await addAssetID(assetIdentifier, toVideo: trimmedVideoURL, saveTo: paths.pairedVideoURL, stillImageTimeSeconds: relativeKeyFrameTime, progress: { p in
let pairedVideoURL = try await addAssetID(assetIdentifier, toVideo: scaledVideoURL, saveTo: paths.pairedVideoURL, stillImageTimeSeconds: relativeKeyFrameTime, progress: { p in
progress?(LivePhotoBuildProgress(stage: .writeVideoMetadata, fraction: p))
})
@@ -495,6 +478,149 @@ public actor LivePhotoBuilder {
return destinationURL
}
/// 将视频处理为 Live Photo 所需的格式
/// 包括：时长变速到 ~0.917 秒、尺寸调整到 1080x1920（或保持比例）、帧率转换为 60fps
/// 完全对齐 live-wallpaper 项目的 accelerateVideo + resizeVideo 流程
private func scaleVideoToTargetDuration(
sourceURL: URL,
targetDuration: CMTime,
destinationURL: URL
) async throws -> URL {
let asset = AVURLAsset(url: sourceURL)
if FileManager.default.fileExists(atPath: destinationURL.path) {
try FileManager.default.removeItem(at: destinationURL)
}
guard let videoTrack = try await asset.loadTracks(withMediaType: .video).first else {
throw AppError(code: "LPB-101", stage: .normalize, message: "视频轨道不存在", suggestedActions: ["选择其他视频"])
}
let originalDuration = try await asset.load(.duration)
let naturalSize = try await videoTrack.load(.naturalSize)
let preferredTransform = try await videoTrack.load(.preferredTransform)
// 计算应用 transform 后的尺寸（与 live-wallpaper resizeVideo 一致）
let originalSize = CGSize(width: naturalSize.width, height: naturalSize.height)
let transformedSize = originalSize.applying(preferredTransform)
let absoluteSize = CGSize(width: abs(transformedSize.width), height: abs(transformedSize.height))
// 根据源视频方向决定输出尺寸
// 横屏视频 -> 1920x1080，竖屏视频 -> 1080x1920
let isLandscape = absoluteSize.width > absoluteSize.height
let livePhotoSize = isLandscape ? CGSize(width: 1920, height: 1080) : CGSize(width: 1080, height: 1920)
// 步骤1：先变速到目标时长（对应 live-wallpaper 的 accelerateVideo）
let acceleratedURL = destinationURL.deletingLastPathComponent().appendingPathComponent("accelerated.mov")
if FileManager.default.fileExists(atPath: acceleratedURL.path) {
try FileManager.default.removeItem(at: acceleratedURL)
}
let composition = AVMutableComposition()
guard let compositionVideoTrack = composition.addMutableTrack(withMediaType: .video, preferredTrackID: kCMPersistentTrackID_Invalid) else {
throw AppError(code: "LPB-101", stage: .normalize, message: "无法创建视频轨道", suggestedActions: ["重试"])
}
try compositionVideoTrack.insertTimeRange(CMTimeRange(start: .zero, duration: originalDuration), of: videoTrack, at: .zero)
// 变速：将原始时长缩放到目标时长（与 live-wallpaper accelerateVideo 第 287-288 行一致）
compositionVideoTrack.scaleTimeRange(CMTimeRange(start: .zero, duration: originalDuration), toDuration: targetDuration)
compositionVideoTrack.preferredTransform = preferredTransform
guard let accelerateExport = AVAssetExportSession(asset: composition, presetName: AVAssetExportPresetHighestQuality) else {
throw AppError(code: "LPB-101", stage: .normalize, message: "无法创建导出会话", suggestedActions: ["重试"])
}
accelerateExport.outputURL = acceleratedURL
accelerateExport.outputFileType = .mov
await accelerateExport.export()
guard accelerateExport.status == .completed else {
throw AppError(code: "LPB-101", stage: .normalize, message: "视频变速失败", underlyingErrorDescription: accelerateExport.error?.localizedDescription, suggestedActions: ["重试"])
}
// 步骤2：调整尺寸和帧率（对应 live-wallpaper 的 resizeVideo）
let acceleratedAsset = AVURLAsset(url: acceleratedURL)
guard let acceleratedVideoTrack = try await acceleratedAsset.loadTracks(withMediaType: .video).first else {
return acceleratedURL
}
let acceleratedDuration = try await acceleratedAsset.load(.duration)
// 加载加速后视频轨道的属性
let acceleratedNaturalSize = try await acceleratedVideoTrack.load(.naturalSize)
let acceleratedTransform = try await acceleratedVideoTrack.load(.preferredTransform)
guard let resizeExport = AVAssetExportSession(asset: acceleratedAsset, presetName: AVAssetExportPresetHighestQuality) else {
return acceleratedURL
}
// 关键：使用 AVMutableVideoComposition 设置输出尺寸和帧率
let videoComposition = AVMutableVideoComposition()
videoComposition.renderSize = livePhotoSize
// 关键：设置 60fps
videoComposition.frameDuration = CMTime(value: 1, timescale: 60)
let instruction = AVMutableVideoCompositionInstruction()
instruction.timeRange = CMTimeRange(start: .zero, duration: acceleratedDuration)
let layerInstruction = AVMutableVideoCompositionLayerInstruction(assetTrack: acceleratedVideoTrack)
// 关键修复：正确计算变换
// 变换需要将 naturalSize 坐标系的像素映射到 livePhotoSize 坐标系
// 步骤：
// 1. 应用 preferredTransform 旋转视频到正确方向
// 2. 根据旋转后的实际尺寸计算缩放和居中
// 计算旋转后的实际尺寸（用于确定缩放比例）
let rotatedSize = acceleratedNaturalSize.applying(acceleratedTransform)
let rotatedAbsoluteSize = CGSize(width: abs(rotatedSize.width), height: abs(rotatedSize.height))
// 基于旋转后尺寸重新计算缩放因子
let actualWidthRatio = livePhotoSize.width / rotatedAbsoluteSize.width
let actualHeightRatio = livePhotoSize.height / rotatedAbsoluteSize.height
let actualScaleFactor = min(actualWidthRatio, actualHeightRatio)
let scaledWidth = rotatedAbsoluteSize.width * actualScaleFactor
let scaledHeight = rotatedAbsoluteSize.height * actualScaleFactor
// 居中偏移
let centerX = (livePhotoSize.width - scaledWidth) / 2
let centerY = (livePhotoSize.height - scaledHeight) / 2
// 构建最终变换：
// 对于 preferredTransform，它通常包含旋转+平移，平移部分是为了将旋转后的内容移到正坐标
// 变换组合顺序（从右到左应用）：
// 1. 先应用 preferredTransform（旋转+平移到正坐标）
// 2. 再缩放
// 3. 最后平移到目标中心
//
// 使用 concatenating: A.concatenating(B) 表示先应用 A，再应用 B
let scaleTransform = CGAffineTransform(scaleX: actualScaleFactor, y: actualScaleFactor)
let translateToCenter = CGAffineTransform(translationX: centerX, y: centerY)
let finalTransform = acceleratedTransform.concatenating(scaleTransform).concatenating(translateToCenter)
layerInstruction.setTransform(finalTransform, at: .zero)
instruction.layerInstructions = [layerInstruction]
videoComposition.instructions = [instruction]
resizeExport.videoComposition = videoComposition
resizeExport.outputURL = destinationURL
resizeExport.outputFileType = .mov
resizeExport.shouldOptimizeForNetworkUse = true
await resizeExport.export()
// 清理临时文件
try? FileManager.default.removeItem(at: acceleratedURL)
guard resizeExport.status == .completed else {
throw AppError(code: "LPB-101", stage: .normalize, message: "视频尺寸调整失败", underlyingErrorDescription: resizeExport.error?.localizedDescription, suggestedActions: ["重试"])
}
return destinationURL
}
private func resolveKeyPhotoURL(
videoURL: URL,
coverImageURL: URL?,
@@ -575,18 +701,10 @@ public actor LivePhotoBuilder {
return destinationURL
}
/// 计算 LivePhotoVideoIndex：逆向工程推测为 Float32 帧索引的 bitPattern
private static func makeLivePhotoVideoIndex(stillImageTimeSeconds: Double, nominalFrameRate: Float) -> Int64 {
let safeFrameRate: Float = (nominalFrameRate.isFinite && nominalFrameRate > 0) ? nominalFrameRate : 30
let frameIndex = Float(stillImageTimeSeconds) * safeFrameRate
return Int64(frameIndex.bitPattern)
}
private func addAssetID(
_ assetIdentifier: String,
toImage imageURL: URL,
saveTo destinationURL: URL,
livePhotoVideoIndex: Int64
saveTo destinationURL: URL
) -> URL? {
let useHEIC = true
let imageType = useHEIC ? UTType.heic.identifier : UTType.jpeg.identifier
@@ -646,7 +764,13 @@ public actor LivePhotoBuilder {
stillImageTimeSeconds: Double,
progress: @Sendable @escaping (Double) -> Void
) async throws -> URL {
try await withCheckedThrowingContinuation { continuation in
// 关键修复：完全对齐 live-wallpaper 项目的实现
// 使用 AVAssetReaderTrackOutput + videoInput.transform，而非 AVAssetReaderVideoCompositionOutput
guard let metadataURL = Self.metadataMovURL else {
throw AppError(code: "LPB-301", stage: .writeVideoMetadata, message: "缺少 metadata.mov 资源文件", suggestedActions: ["重新安装应用"])
}
return try await withCheckedThrowingContinuation { continuation in
let queue = DispatchQueue(label: "LivePhotoCore.VideoPairing")
queue.async {
do {
@@ -655,6 +779,8 @@ public actor LivePhotoBuilder {
}
let videoAsset = AVURLAsset(url: videoURL)
let metadataAsset = AVURLAsset(url: metadataURL)
guard let videoTrack = videoAsset.tracks(withMediaType: .video).first else {
continuation.resume(throwing: AppError(code: "LPB-301", stage: .writeVideoMetadata, message: "视频处理失败", underlyingErrorDescription: "缺少视频轨", suggestedActions: ["更换一个视频", "重试"]))
return
@@ -664,165 +790,129 @@ public actor LivePhotoBuilder {
let nominalFrameRate = videoTrack.nominalFrameRate > 0 ? videoTrack.nominalFrameRate : 30
let frameCount = max(1, Int(durationSeconds * Double(nominalFrameRate)))
// 关键修复：竞品视频没有 rotation，是烘焙到正向画面的
// 计算应用 transform 后的实际尺寸
let transform = videoTrack.preferredTransform
let naturalSize = videoTrack.naturalSize
// 判断是否有 90度/270度 旋转（需要交换宽高）
let isRotated90or270 = abs(transform.b) == 1.0 && abs(transform.c) == 1.0
let transformedSize: CGSize
if isRotated90or270 {
transformedSize = CGSize(width: naturalSize.height, height: naturalSize.width)
} else {
transformedSize = naturalSize
}
// 计算输出尺寸，限制最大边为 1920（对标竞品 1080p）
let maxDimension: CGFloat = 1920
let maxSide = max(transformedSize.width, transformedSize.height)
let scale: CGFloat = maxSide > maxDimension ? maxDimension / maxSide : 1.0
let outputWidth = Int(transformedSize.width * scale)
let outputHeight = Int(transformedSize.height * scale)
let assetWriter = try AVAssetWriter(outputURL: destinationURL, fileType: .mov)
// 创建 readers 和 writer
let videoReader = try AVAssetReader(asset: videoAsset)
let metadataReader = try AVAssetReader(asset: metadataAsset)
let assetWriter = try AVAssetWriter(outputURL: destinationURL, fileType: .mov)
let videoReaderSettings: [String: Any] = [
let writingGroup = DispatchGroup()
// 关键：使用 AVAssetReaderTrackOutput（与 live-wallpaper 完全一致）
// 而不是 AVAssetReaderVideoCompositionOutput
let videoReaderOutput = AVAssetReaderTrackOutput(track: videoTrack, outputSettings: [
kCVPixelBufferPixelFormatTypeKey as String: NSNumber(value: kCVPixelFormatType_32BGRA as UInt32)
]
let videoReaderOutput = AVAssetReaderTrackOutput(track: videoTrack, outputSettings: videoReaderSettings)
])
videoReader.add(videoReaderOutput)
// 使用 HEVC (H.265) 编码 - iPhone 原生 Live Photo 使用的格式
// 关键：使用 track.naturalSize 作为输出尺寸（与 live-wallpaper 一致）
// 视频方向通过 videoInput.transform 控制
let videoWriterInput = AVAssetWriterInput(
mediaType: .video,
outputSettings: [
AVVideoCodecKey: AVVideoCodecType.hevc,
AVVideoWidthKey: Int(naturalSize.width * scale),
AVVideoHeightKey: Int(naturalSize.height * scale),
AVVideoCompressionPropertiesKey: [
AVVideoAverageBitRateKey: 8_000_000,
AVVideoQualityKey: 0.8
]
AVVideoCodecKey: AVVideoCodecType.h264,
AVVideoWidthKey: videoTrack.naturalSize.width,
AVVideoHeightKey: videoTrack.naturalSize.height
]
)
// 保留原始 transform
videoWriterInput.transform = transform
videoWriterInput.expectsMediaDataInRealTime = false
// 关键：通过 transform 属性设置视频方向（与 live-wallpaper 第 108 行完全一致）
videoWriterInput.transform = videoTrack.preferredTransform
// 关键：设置 expectsMediaDataInRealTime = true（与 live-wallpaper 第 109 行一致）
videoWriterInput.expectsMediaDataInRealTime = true
assetWriter.add(videoWriterInput)
var audioReader: AVAssetReader?
var audioReaderOutput: AVAssetReaderOutput?
var audioWriterInput: AVAssetWriterInput?
// 设置 metadata track 的 reader/writer（从 metadata.mov 复制）
// 关键：不传 sourceFormatHint，与 live-wallpaper 项目保持一致
var metadataIOs = [(AVAssetWriterInput, AVAssetReaderTrackOutput)]()
let metadataTracks = metadataAsset.tracks(withMediaType: .metadata)
for track in metadataTracks {
let trackReaderOutput = AVAssetReaderTrackOutput(track: track, outputSettings: nil)
metadataReader.add(trackReaderOutput)
if let audioTrack = videoAsset.tracks(withMediaType: .audio).first {
let _audioReader = try AVAssetReader(asset: videoAsset)
let _audioReaderOutput = AVAssetReaderTrackOutput(track: audioTrack, outputSettings: nil)
_audioReader.add(_audioReaderOutput)
audioReader = _audioReader
audioReaderOutput = _audioReaderOutput
let metadataInput = AVAssetWriterInput(mediaType: .metadata, outputSettings: nil)
assetWriter.add(metadataInput)
let _audioWriterInput = AVAssetWriterInput(mediaType: .audio, outputSettings: nil)
_audioWriterInput.expectsMediaDataInRealTime = false
assetWriter.add(_audioWriterInput)
audioWriterInput = _audioWriterInput
metadataIOs.append((metadataInput, trackReaderOutput))
}
let assetIdentifierMetadata = Self.metadataForAssetID(assetIdentifier)
let stillImageTimeMetadataAdapter = Self.createMetadataAdaptorForStillImageTime()
// 只写入必要的 Content Identifier
assetWriter.metadata = [assetIdentifierMetadata]
// 只添加 still-image-time track（回退到稳定版本，移除 live-photo-info）
assetWriter.add(stillImageTimeMetadataAdapter.assetWriterInput)
// 设置顶级元数据
assetWriter.metadata = [Self.metadataForAssetID(assetIdentifier)]
assetWriter.startWriting()
videoReader.startReading()
metadataReader.startReading()
assetWriter.startSession(atSourceTime: .zero)
// still-image-time track: 只写入一个 item（回退到稳定版本）
let stillTimeRange = videoAsset.makeStillImageTimeRange(seconds: stillImageTimeSeconds, frameCountHint: frameCount)
stillImageTimeMetadataAdapter.append(AVTimedMetadataGroup(
items: [Self.metadataItemForStillImageTime()],
timeRange: stillTimeRange
))
var writingVideoFinished = false
var writingAudioFinished = audioReader == nil
var currentFrameCount = 0
func didCompleteWriting() {
guard writingAudioFinished && writingVideoFinished else { return }
assetWriter.finishWriting {
if assetWriter.status == .completed {
continuation.resume(returning: destinationURL)
// 写入视频帧
writingGroup.enter()
videoWriterInput.requestMediaDataWhenReady(on: DispatchQueue(label: "LivePhotoCore.VideoWriterInput")) {
while videoWriterInput.isReadyForMoreMediaData {
if let sampleBuffer = videoReaderOutput.copyNextSampleBuffer() {
currentFrameCount += 1
let pct = Double(currentFrameCount) / Double(frameCount)
progress(pct)
videoWriterInput.append(sampleBuffer)
} else {
continuation.resume(throwing: AppError(code: "LPB-301", stage: .writeVideoMetadata, message: "视频处理失败", underlyingErrorDescription: assetWriter.error?.localizedDescription, suggestedActions: ["切换到 H.264 兼容导出", "关闭音频", "重试"]))
videoWriterInput.markAsFinished()
writingGroup.leave()
break
}
}
}
if videoReader.startReading() {
videoWriterInput.requestMediaDataWhenReady(on: DispatchQueue(label: "LivePhotoCore.VideoWriterInput")) {
while videoWriterInput.isReadyForMoreMediaData {
guard videoReader.status == .reading else {
videoWriterInput.markAsFinished()
writingVideoFinished = true
didCompleteWriting()
break
}
if let sampleBuffer = videoReaderOutput.copyNextSampleBuffer() {
currentFrameCount += 1
let pct = Double(currentFrameCount) / Double(frameCount)
progress(pct)
// 写入视频帧
if !videoWriterInput.append(sampleBuffer) {
videoReader.cancelReading()
}
// 复制 metadata track 的 sample buffer（关键！）
for (metadataInput, metadataOutput) in metadataIOs {
writingGroup.enter()
metadataInput.requestMediaDataWhenReady(on: DispatchQueue(label: "LivePhotoCore.MetadataWriterInput")) {
while metadataInput.isReadyForMoreMediaData {
if let sampleBuffer = metadataOutput.copyNextSampleBuffer() {
metadataInput.append(sampleBuffer)
} else {
videoWriterInput.markAsFinished()
writingVideoFinished = true
didCompleteWriting()
metadataInput.markAsFinished()
writingGroup.leave()
break
}
}
}
} else {
writingVideoFinished = true
didCompleteWriting()
}
if let audioReader, let audioWriterInput, audioReader.startReading() {
audioWriterInput.requestMediaDataWhenReady(on: DispatchQueue(label: "LivePhotoCore.AudioWriterInput")) {
while audioWriterInput.isReadyForMoreMediaData {
guard audioReader.status == .reading else {
audioWriterInput.markAsFinished()
writingAudioFinished = true
didCompleteWriting()
return
writingGroup.notify(queue: .main) {
if videoReader.status == .completed && metadataReader.status == .completed && assetWriter.status == .writing {
assetWriter.finishWriting {
if assetWriter.status == .completed {
continuation.resume(returning: destinationURL)
} else {
continuation.resume(throwing: AppError(code: "LPB-301", stage: .writeVideoMetadata, message: "视频处理失败", underlyingErrorDescription: assetWriter.error?.localizedDescription, suggestedActions: ["重试"]))
}
guard let sampleBuffer = audioReaderOutput?.copyNextSampleBuffer() else {
audioWriterInput.markAsFinished()
writingAudioFinished = true
didCompleteWriting()
return
}
_ = audioWriterInput.append(sampleBuffer)
}
} else {
let errorDesc = videoReader.error?.localizedDescription ?? metadataReader.error?.localizedDescription ?? assetWriter.error?.localizedDescription ?? "未知错误"
continuation.resume(throwing: AppError(code: "LPB-301", stage: .writeVideoMetadata, message: "视频处理失败", underlyingErrorDescription: errorDesc, suggestedActions: ["重试"]))
}
} else {
writingAudioFinished = true
didCompleteWriting()
}
} catch {
continuation.resume(throwing: AppError(code: "LPB-301", stage: .writeVideoMetadata, message: "视频处理失败", underlyingErrorDescription: error.localizedDescription, suggestedActions: ["切换到 H.264 兼容导出", "关闭音频", "重试"]))
continuation.resume(throwing: AppError(code: "LPB-301", stage: .writeVideoMetadata, message: "视频处理失败", underlyingErrorDescription: error.localizedDescription, suggestedActions: ["重试"]))
}
}
}
}
/// 获取 metadata.mov 资源文件的 URL
private static var metadataMovURL: URL? {
// 首先尝试从 Bundle 获取（用于 App）
if let bundleURL = Bundle.main.url(forResource: "metadata", withExtension: "mov") {
return bundleURL
}
// 然后尝试从 module bundle 获取（用于 SPM package）
#if SWIFT_PACKAGE
if let moduleURL = Bundle.module.url(forResource: "metadata", withExtension: "mov") {
return moduleURL
}
#endif
return nil
}
private static func metadataForAssetID(_ assetIdentifier: String) -> AVMetadataItem {
let item = AVMutableMetadataItem()
item.key = "com.apple.quicktime.content.identifier" as (NSCopying & NSObjectProtocol)
@@ -831,153 +921,6 @@ public actor LivePhotoBuilder {
item.dataType = "com.apple.metadata.datatype.UTF-8"
return item
}
private static func createMetadataAdaptorForStillImageTime() -> AVAssetWriterInputMetadataAdaptor {
let keySpace = "mdta"
let keyStill = "com.apple.quicktime.still-image-time"
// 只声明 still-image-time 一个 key（回退到稳定版本）
let spec: NSDictionary = [
kCMMetadataFormatDescriptionMetadataSpecificationKey_Identifier as NSString: "\(keySpace)/\(keyStill)",
kCMMetadataFormatDescriptionMetadataSpecificationKey_DataType as NSString: "com.apple.metadata.datatype.int8"
]
var desc: CMFormatDescription?
CMMetadataFormatDescriptionCreateWithMetadataSpecifications(
allocator: kCFAllocatorDefault,
metadataType: kCMMetadataFormatType_Boxed,
metadataSpecifications: [spec] as CFArray,
formatDescriptionOut: &desc
)
let input = AVAssetWriterInput(mediaType: .metadata, outputSettings: nil, sourceFormatHint: desc)
return AVAssetWriterInputMetadataAdaptor(assetWriterInput: input)
}
/// 对标竞品 89 字节 still-image-time 数据
/// 结构：item1 (9B: still-image-time=-1) + item2 (80B: transform 3x3矩阵)
private static func metadataItemForStillImageTimeWithTransform() -> AVMetadataItem {
let item = AVMutableMetadataItem()
item.key = "com.apple.quicktime.still-image-time" as (NSCopying & NSObjectProtocol)
item.keySpace = AVMetadataKeySpace(rawValue: "mdta")
item.dataType = "com.apple.metadata.datatype.raw-data"
item.value = stillImageTime89BytesPayload() as NSData
return item
}
/// 构建 89 字节 payload（对标竞品格式）
private static func stillImageTime89BytesPayload() -> Data {
var data = Data()
// Item 1: still-image-time (9 bytes)
// size: 4 bytes (0x00000009)
data.append(contentsOf: [0x00, 0x00, 0x00, 0x09])
// keyIndex: 4 bytes (0x00000001)
data.append(contentsOf: [0x00, 0x00, 0x00, 0x01])
// value: 1 byte (0xFF = -1)
data.append(0xFF)
// Item 2: transform (80 bytes)
// size: 4 bytes (0x00000050 = 80)
data.append(contentsOf: [0x00, 0x00, 0x00, 0x50])
// keyIndex: 4 bytes (0x00000002)
data.append(contentsOf: [0x00, 0x00, 0x00, 0x02])
// 3x3 identity matrix as big-endian Float64 (72 bytes)
let matrix: [Double] = [1, 0, 0, 0, 1, 0, 0, 0, 1]
for value in matrix {
var bigEndian = value.bitPattern.bigEndian
withUnsafeBytes(of: &bigEndian) { data.append(contentsOf: $0) }
}
return data // 89 bytes total
}
private static func metadataItemForStillImageTime() -> AVMetadataItem {
let item = AVMutableMetadataItem()
item.key = "com.apple.quicktime.still-image-time" as (NSCopying & NSObjectProtocol)
item.keySpace = AVMetadataKeySpace(rawValue: "mdta")
// 竞品使用 0xFF (-1)，但之前测试 0 也不行，现在改回 -1 对标竞品
item.value = NSNumber(value: Int8(-1)) as (NSCopying & NSObjectProtocol)
item.dataType = "com.apple.metadata.datatype.int8"
return item
}
/// 3x3 单位矩阵变换数据（72 字节，大端序 Float64）
private static func metadataItemForStillImageTransform() -> AVMetadataItem {
let item = AVMutableMetadataItem()
item.key = "com.apple.quicktime.live-photo-still-image-transform" as (NSCopying & NSObjectProtocol)
item.keySpace = AVMetadataKeySpace(rawValue: "mdta")
item.dataType = "com.apple.metadata.datatype.raw-data"
item.value = livePhotoStillImageTransformIdentityData() as NSData
return item
}
/// 生成 3x3 单位矩阵的大端序 Float64 数据
private static func livePhotoStillImageTransformIdentityData() -> Data {
// 单位矩阵：[1,0,0, 0,1,0, 0,0,1]
let matrix: [Double] = [1, 0, 0, 0, 1, 0, 0, 0, 1]
var data = Data()
data.reserveCapacity(matrix.count * 8)
for value in matrix {
var bigEndian = value.bitPattern.bigEndian
withUnsafeBytes(of: &bigEndian) { data.append(contentsOf: $0) }
}
return data // 72 字节
}
// MARK: - Live Photo Info Track (逐帧 timed metadata，对标竞品)
/// live-photo-info 数据暂时不写入，先确保基本功能正常
/// 设为空数据，跳过 live-photo-info track
private static let livePhotoInfoPayload: Data = Data()
private static func createMetadataAdaptorForLivePhotoInfo() -> AVAssetWriterInputMetadataAdaptor {
let key = "com.apple.quicktime.live-photo-info"
let keySpace = "mdta"
let spec: NSDictionary = [
kCMMetadataFormatDescriptionMetadataSpecificationKey_Identifier as NSString: "\(keySpace)/\(key)",
kCMMetadataFormatDescriptionMetadataSpecificationKey_DataType as NSString: "com.apple.metadata.datatype.raw-data"
]
var desc: CMFormatDescription?
CMMetadataFormatDescriptionCreateWithMetadataSpecifications(
allocator: kCFAllocatorDefault,
metadataType: kCMMetadataFormatType_Boxed,
metadataSpecifications: [spec] as CFArray,
formatDescriptionOut: &desc
)
let input = AVAssetWriterInput(mediaType: .metadata, outputSettings: nil, sourceFormatHint: desc)
return AVAssetWriterInputMetadataAdaptor(assetWriterInput: input)
}
private static func metadataItemForLivePhotoInfo() -> AVMetadataItem {
let item = AVMutableMetadataItem()
item.key = "com.apple.quicktime.live-photo-info" as (NSCopying & NSObjectProtocol)
item.keySpace = AVMetadataKeySpace(rawValue: "mdta")
item.value = livePhotoInfoPayload as NSData
item.dataType = "com.apple.metadata.datatype.raw-data"
return item
}
private static func metadataForSampleTime() -> AVMetadataItem {
let item = AVMutableMetadataItem()
item.key = "Sample Time" as (NSCopying & NSObjectProtocol)
item.keySpace = AVMetadataKeySpace(rawValue: "mdta")
item.value = "0 s" as (NSCopying & NSObjectProtocol)
item.dataType = "com.apple.metadata.datatype.UTF-8"
return item
}
private static func metadataForSampleDuration() -> AVMetadataItem {
let item = AVMutableMetadataItem()
item.key = "Sample Duration" as (NSCopying & NSObjectProtocol)
item.keySpace = AVMetadataKeySpace(rawValue: "mdta")
item.value = "0.03 s" as (NSCopying & NSObjectProtocol)
item.dataType = "com.apple.metadata.datatype.UTF-8"
return item
}
}
public struct LivePhotoWorkflowResult: Sendable, Hashable {
@@ -1033,15 +976,6 @@ public actor LivePhotoWorkflow {
progress: progress
)
// 调试：导出文件到文档目录
#if DEBUG
if let (debugPhoto, debugVideo) = try? output.exportToDocuments() {
print("[DEBUG] Exported files to Documents:")
print(" Photo: \(debugPhoto.path)")
print(" Video: \(debugVideo.path)")
}
#endif
progress?(LivePhotoBuildProgress(stage: .validate, fraction: 0))
let resourceOK = await validator.canCreateLivePhotoFromResources(
photoURL: output.pairedImageURL,
@@ -1086,19 +1020,3 @@ public actor LivePhotoWorkflow {
)
}
}
private extension AVAsset {
func makeStillImageTimeRange(seconds: Double, frameCountHint: Int) -> CMTimeRange {
let duration = self.duration
let clampedSeconds = max(0, min(seconds, max(0, duration.seconds - 0.001)))
var time = CMTime(seconds: clampedSeconds, preferredTimescale: duration.timescale)
if time > duration {
time = duration
}
// 关键修复：竞品使用 duration_ts=1（最小 tick），而不是一帧时长
// 壁纸校验比相册更严格，需要 still-image-time 是"瞬时标记"而非"一帧区间"
return CMTimeRange(start: time, duration: CMTime(value: 1, timescale: duration.timescale))
}
}