797 lines
32 KiB
Swift
797 lines
32 KiB
Swift
import AVFoundation
|
||
import CoreMedia
|
||
import MediaToolbox
|
||
import Foundation
|
||
#if os(macOS)
|
||
import AppKit
|
||
|
||
// MARK: - 全局音频 Tap 上下文（C 回调无法访问 Swift 对象）
|
||
|
||
private nonisolated(unsafe) var gTapContext: AudioTapContext?
|
||
|
||
class AudioTapContext {
|
||
nonisolated(unsafe) var writerInput: AVAssetWriterInput?
|
||
nonisolated(unsafe) var isRecording: Bool = false
|
||
nonisolated(unsafe) var formatDescription: CMAudioFormatDescription?
|
||
nonisolated(unsafe) var sampleRate: Double = 0
|
||
nonisolated(unsafe) var channelsPerFrame: UInt32 = 0
|
||
nonisolated(unsafe) var appendCount: Int = 0
|
||
nonisolated(unsafe) var processCallCount: Int = 0
|
||
nonisolated(unsafe) var firstAppendLogged: Bool = false
|
||
nonisolated(unsafe) var totalFramesWritten: Int64 = 0
|
||
|
||
/// 双缓冲区（消除数据竞争：写A时async读B，交替使用）
|
||
nonisolated(unsafe) var dataBuffers: (UnsafeMutableRawPointer?, UnsafeMutableRawPointer?) = (nil, nil)
|
||
nonisolated(unsafe) var dataBufferSizes: (Int, Int) = (0, 0)
|
||
nonisolated(unsafe) var writeIndex: Int = 0
|
||
|
||
// === 诊断统计 ===
|
||
nonisolated(unsafe) var peakAmplitude: Float = 0 // 全局峰值
|
||
nonisolated(unsafe) var silentCallCount: Int = 0 // 静音回调次数
|
||
nonisolated(unsafe) var activeCallCount: Int = 0 // 有声音的回调次数
|
||
nonisolated(unsafe) var skippedNotRecording: Int = 0 // isRecording=false 跳过次数
|
||
nonisolated(unsafe) var skippedNoFormat: Int = 0 // formatDescription 为空跳过次数
|
||
nonisolated(unsafe) var skippedNoData: Int = 0 // buffer 无数据跳过次数
|
||
nonisolated(unsafe) var appendFailCount: Int = 0 // append 失败次数
|
||
nonisolated(unsafe) var notReadyCount: Int = 0 // writerInput not ready 次数
|
||
nonisolated(unsafe) var lastActiveTimestamp: Double = 0 // 最后一次有声音的时间(秒)
|
||
nonisolated(unsafe) var recordStartTime: Date? // 录制开始时间
|
||
|
||
let audioQueue = DispatchQueue(label: "miniplayer.audioTap")
|
||
}
|
||
|
||
// MARK: - MTAudioProcessingTap C 回调
|
||
|
||
private func tapInit(
|
||
_ tap: MTAudioProcessingTap,
|
||
_ clientInfo: UnsafeMutableRawPointer?,
|
||
_ tapStorageOut: UnsafeMutablePointer<UnsafeMutableRawPointer?>
|
||
) {
|
||
tapStorageOut.pointee = clientInfo
|
||
}
|
||
|
||
private func tapFinalize(_ tap: MTAudioProcessingTap) {
|
||
// Context lifecycle managed elsewhere
|
||
}
|
||
|
||
private func tapPrepare(
|
||
_ tap: MTAudioProcessingTap,
|
||
_ maxFrames: CMItemCount,
|
||
_ processingFormat: UnsafePointer<AudioStreamBasicDescription>
|
||
) {
|
||
let asbd = processingFormat.pointee
|
||
NSLog("[Recorder] Tap prepare: rate=%.0f ch=%u formatFlags=0x%x",
|
||
asbd.mSampleRate, asbd.mChannelsPerFrame, asbd.mFormatFlags)
|
||
|
||
let storage = MTAudioProcessingTapGetStorage(tap)
|
||
let ctx = Unmanaged<AudioTapContext>.fromOpaque(storage).takeUnretainedValue()
|
||
ctx.sampleRate = asbd.mSampleRate
|
||
ctx.channelsPerFrame = asbd.mChannelsPerFrame
|
||
|
||
var fmtDesc: CMAudioFormatDescription?
|
||
var mutableASBD = asbd
|
||
CMAudioFormatDescriptionCreate(
|
||
allocator: kCFAllocatorDefault,
|
||
asbd: &mutableASBD,
|
||
layoutSize: 0, layout: nil,
|
||
magicCookieSize: 0, magicCookie: nil,
|
||
extensions: nil,
|
||
formatDescriptionOut: &fmtDesc
|
||
)
|
||
ctx.formatDescription = fmtDesc
|
||
NSLog("[Recorder] Tap format ready: %@", fmtDesc != nil ? "OK" : "FAILED")
|
||
}
|
||
|
||
private func tapUnprepare(_ tap: MTAudioProcessingTap) {
|
||
NSLog("[Recorder] Tap unprepare")
|
||
}
|
||
|
||
private func tapProcess(
|
||
_ tap: MTAudioProcessingTap,
|
||
_ numberFrames: Int,
|
||
_ flags: UInt32,
|
||
_ bufferListInOut: UnsafeMutablePointer<AudioBufferList>,
|
||
_ bufferListSizeOut: UnsafeMutablePointer<Int>,
|
||
_ flagsOut: UnsafeMutablePointer<UInt32>
|
||
) {
|
||
bufferListSizeOut.pointee = 1
|
||
flagsOut.pointee = flags
|
||
|
||
let storage = MTAudioProcessingTapGetStorage(tap)
|
||
let ctx = Unmanaged<AudioTapContext>.fromOpaque(storage).takeUnretainedValue()
|
||
|
||
ctx.processCallCount += 1
|
||
guard ctx.isRecording else { ctx.skippedNotRecording += 1; return }
|
||
guard let _ = ctx.writerInput else { ctx.skippedNoFormat += 1; return }
|
||
guard let _ = ctx.formatDescription else { ctx.skippedNoFormat += 1; return }
|
||
|
||
let ablPtr = UnsafeMutableAudioBufferListPointer(bufferListInOut)
|
||
|
||
// 计算总数据量
|
||
var totalSize: Int = 0
|
||
for i in 0..<ablPtr.count {
|
||
if ablPtr[i].mData != nil && ablPtr[i].mDataByteSize > 0 {
|
||
totalSize += Int(ablPtr[i].mDataByteSize)
|
||
}
|
||
}
|
||
guard totalSize > 0 else { ctx.skippedNoData += 1; return }
|
||
|
||
// === 诊断: 计算峰值音量 ===
|
||
var bufferPeak: Float = 0
|
||
for i in 0..<ablPtr.count {
|
||
guard let data = ablPtr[i].mData, ablPtr[i].mDataByteSize > 0 else { continue }
|
||
let floatPtr = data.assumingMemoryBound(to: Float.self)
|
||
let sampleCount = Int(ablPtr[i].mDataByteSize) / MemoryLayout<Float>.size
|
||
for s in stride(from: 0, to: sampleCount, by: 16) { // 每16个采样检查一次，避免性能问题
|
||
let absVal = abs(floatPtr[s])
|
||
if absVal > bufferPeak { bufferPeak = absVal }
|
||
}
|
||
}
|
||
if bufferPeak > ctx.peakAmplitude { ctx.peakAmplitude = bufferPeak }
|
||
|
||
// 静音阈值: float PCM < 0.001 ≈ -60dB
|
||
let isActive = bufferPeak > 0.001
|
||
if isActive {
|
||
ctx.activeCallCount += 1
|
||
if let start = ctx.recordStartTime {
|
||
ctx.lastActiveTimestamp = Date().timeIntervalSince(start)
|
||
}
|
||
} else {
|
||
ctx.silentCallCount += 1
|
||
}
|
||
|
||
// 双缓冲：写当前槽，async读另一个槽（消除数据竞争）
|
||
let wi = ctx.writeIndex
|
||
ctx.writeIndex = 1 - wi // 切换槽位
|
||
|
||
if ctx.dataBufferSizes.0 < totalSize || ctx.dataBufferSizes.1 < totalSize {
|
||
// 只在需要时扩容（不会在实时路径频繁触发）
|
||
let newSize = max(totalSize, 65536) // 至少64KB
|
||
if wi == 0 {
|
||
if let existing = ctx.dataBuffers.0 { free(existing) }
|
||
ctx.dataBuffers.0 = malloc(newSize)
|
||
ctx.dataBufferSizes.0 = newSize
|
||
} else {
|
||
if let existing = ctx.dataBuffers.1 { free(existing) }
|
||
ctx.dataBuffers.1 = malloc(newSize)
|
||
ctx.dataBufferSizes.1 = newSize
|
||
}
|
||
}
|
||
|
||
let dest: UnsafeMutableRawPointer?
|
||
if wi == 0 { dest = ctx.dataBuffers.0 } else { dest = ctx.dataBuffers.1 }
|
||
guard let dest = dest else { return }
|
||
|
||
var offset = 0
|
||
for i in 0..<ablPtr.count {
|
||
if let src = ablPtr[i].mData, ablPtr[i].mDataByteSize > 0 {
|
||
let sz = Int(ablPtr[i].mDataByteSize)
|
||
memcpy(dest + offset, src, sz)
|
||
offset += sz
|
||
}
|
||
}
|
||
|
||
let frameCount = Int64(numberFrames)
|
||
let startFrame = ctx.totalFramesWritten
|
||
let readWi = wi // async 读取的是刚写完的槽
|
||
|
||
// 在串行队列创建 CMSampleBuffer 并写入
|
||
ctx.audioQueue.async {
|
||
guard ctx.isRecording,
|
||
let writerInput = ctx.writerInput,
|
||
let fd = ctx.formatDescription else { return }
|
||
|
||
// 从已写完的槽读取（此时实时线程正在写另一个槽，安全）
|
||
let readDest: UnsafeMutableRawPointer?
|
||
if readWi == 0 { readDest = ctx.dataBuffers.0 } else { readDest = ctx.dataBuffers.1 }
|
||
guard let readDest = readDest else { return }
|
||
|
||
var blockBuffer: CMBlockBuffer?
|
||
let blockStatus = CMBlockBufferCreateWithMemoryBlock(
|
||
allocator: kCFAllocatorDefault, memoryBlock: nil,
|
||
blockLength: totalSize, blockAllocator: kCFAllocatorDefault,
|
||
customBlockSource: nil, offsetToData: 0,
|
||
dataLength: totalSize,
|
||
flags: kCMBlockBufferAssureMemoryNowFlag,
|
||
blockBufferOut: &blockBuffer
|
||
)
|
||
guard blockStatus == kCMBlockBufferNoErr, let bb = blockBuffer else { return }
|
||
|
||
let replaceStatus = CMBlockBufferReplaceDataBytes(
|
||
with: readDest, blockBuffer: bb,
|
||
offsetIntoDestination: 0, dataLength: totalSize
|
||
)
|
||
guard replaceStatus == kCMBlockBufferNoErr else { return }
|
||
|
||
// PTS 基于累计帧数计算
|
||
let pts = CMTime(
|
||
value: CMTimeValue(startFrame),
|
||
timescale: Int32(ctx.sampleRate)
|
||
)
|
||
var timingInfo = CMSampleTimingInfo(
|
||
duration: CMTime(value: CMTimeValue(frameCount), timescale: Int32(ctx.sampleRate)),
|
||
presentationTimeStamp: pts,
|
||
decodeTimeStamp: .invalid
|
||
)
|
||
|
||
var sampleBuffer: CMSampleBuffer?
|
||
let createStatus = CMSampleBufferCreateReady(
|
||
allocator: kCFAllocatorDefault,
|
||
dataBuffer: bb,
|
||
formatDescription: fd,
|
||
sampleCount: Int(frameCount),
|
||
sampleTimingEntryCount: 1,
|
||
sampleTimingArray: &timingInfo,
|
||
sampleSizeEntryCount: 0,
|
||
sampleSizeArray: nil,
|
||
sampleBufferOut: &sampleBuffer
|
||
)
|
||
guard createStatus == noErr, let sb = sampleBuffer else {
|
||
NSLog("[Recorder] ⚠️ SampleBuffer create failed: %d", createStatus)
|
||
return
|
||
}
|
||
|
||
if writerInput.isReadyForMoreMediaData {
|
||
if writerInput.append(sb) {
|
||
ctx.appendCount += 1
|
||
ctx.totalFramesWritten += frameCount
|
||
if !ctx.firstAppendLogged {
|
||
ctx.firstAppendLogged = true
|
||
NSLog("[Recorder] ✓ First audio captured: pts=%.3fs, frames=%lld, size=%d, peak=%.4f",
|
||
pts.seconds, frameCount, totalSize, bufferPeak)
|
||
}
|
||
} else {
|
||
ctx.appendFailCount += 1
|
||
}
|
||
} else {
|
||
ctx.notReadyCount += 1
|
||
}
|
||
}
|
||
}
|
||
|
||
// MARK: - RecorderState
|
||
|
||
enum RecorderState {
|
||
static nonisolated(unsafe) var isFinalizing: Bool = false
|
||
static nonisolated(unsafe) var pendingTerminate: Bool = false
|
||
}
|
||
|
||
// MARK: - 诊断统计快照
|
||
|
||
struct AudioDiagStats {
|
||
let videoFrames: Int
|
||
let processCallCount: Int
|
||
let appendCount: Int
|
||
let totalFramesWritten: Int64
|
||
let peakAmplitude: Float
|
||
let activeCallCount: Int
|
||
let silentCallCount: Int
|
||
let skippedNotRecording: Int
|
||
let skippedNoFormat: Int
|
||
let skippedNoData: Int
|
||
let appendFailCount: Int
|
||
let notReadyCount: Int
|
||
let lastActiveTimestamp: Double
|
||
let sampleRate: Double
|
||
let channelsPerFrame: UInt32
|
||
}
|
||
|
||
// MARK: - PlayerRecorder
|
||
|
||
@MainActor
|
||
final class PlayerRecorder: NSObject {
|
||
|
||
private var writer: AVAssetWriter?
|
||
private var videoInput: AVAssetWriterInput?
|
||
private var audioInput: AVAssetWriterInput?
|
||
private var captureTimer: Timer?
|
||
private var durationTimer: Timer?
|
||
private var startDate: Date?
|
||
private weak var weakOutput: AVPlayerItemVideoOutput?
|
||
nonisolated(unsafe) private var isRunning = false
|
||
|
||
private var lastPixelBuffer: CVPixelBuffer?
|
||
private var captureFrameCount: Int = 0
|
||
|
||
// Audio Tap
|
||
private var tapContext: AudioTapContext?
|
||
private weak var currentPlayerItem: AVPlayerItem?
|
||
|
||
nonisolated(unsafe) private var recordStartTime: CMTime = .zero
|
||
|
||
@Published var isRecording = false
|
||
@Published var durationText = "00:00"
|
||
|
||
var onRecordingSaved: ((URL) -> Void)?
|
||
var onError: ((String) -> Void)?
|
||
|
||
private var tempURL: URL?
|
||
|
||
private var saveDirectory: URL {
|
||
let movies = FileManager.default.urls(for: .moviesDirectory, in: .userDomainMask).first!
|
||
let dir = movies.appendingPathComponent("MiniPlayer", isDirectory: true)
|
||
try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
|
||
return dir
|
||
}
|
||
|
||
// MARK: - Audio Tap Setup
|
||
|
||
/// 在录制开始时安装音频 Tap 到 playerItem
|
||
private func installAudioTap(on playerItem: AVPlayerItem) {
|
||
// 确保全局上下文存在
|
||
if gTapContext == nil {
|
||
gTapContext = AudioTapContext()
|
||
}
|
||
guard let ctx = gTapContext else { return }
|
||
|
||
// 同步获取音频 track（录制时 asset 已经加载完毕）
|
||
let audioTracks = playerItem.asset.tracks(withMediaType: .audio)
|
||
guard let audioTrack = audioTracks.first else {
|
||
NSLog("[Recorder] ⚠️ No audio track found (tried %d tracks)", audioTracks.count)
|
||
return
|
||
}
|
||
|
||
NSLog("[Recorder] Found audio track: ID=%d, formatDescriptions=%d",
|
||
audioTrack.trackID, audioTrack.formatDescriptions.count)
|
||
|
||
// 创建 MTAudioProcessingTap
|
||
var callbacks = MTAudioProcessingTapCallbacks(
|
||
version: kMTAudioProcessingTapCallbacksVersion_0,
|
||
clientInfo: Unmanaged.passUnretained(ctx).toOpaque(),
|
||
init: tapInit,
|
||
finalize: tapFinalize,
|
||
prepare: tapPrepare,
|
||
unprepare: tapUnprepare,
|
||
process: tapProcess
|
||
)
|
||
|
||
var tap: MTAudioProcessingTap?
|
||
let status = MTAudioProcessingTapCreate(
|
||
kCFAllocatorDefault, &callbacks,
|
||
kMTAudioProcessingTapCreationFlag_PreEffects,
|
||
&tap
|
||
)
|
||
guard status == noErr, let tapRef = tap else {
|
||
NSLog("[Recorder] ⚠️ MTAudioProcessingTapCreate failed: %d", status)
|
||
return
|
||
}
|
||
|
||
// 创建 AudioMix — 必须用实际 trackID
|
||
// kCMPersistentTrackID_Invalid (=0) 实测不会触发 tap
|
||
let inputParams = AVMutableAudioMixInputParameters()
|
||
inputParams.trackID = audioTrack.trackID
|
||
inputParams.audioTapProcessor = tapRef
|
||
|
||
let audioMix = AVMutableAudioMix()
|
||
audioMix.inputParameters = [inputParams]
|
||
|
||
playerItem.audioMix = audioMix
|
||
NSLog("[Recorder] ✓ Audio tap installed: trackID=%d, asset tracks=%d, playerItem.audioMix set",
|
||
audioTrack.trackID, playerItem.asset.tracks.count)
|
||
}
|
||
|
||
// MARK: - 开始录制
|
||
|
||
func startRecording(from output: AVPlayerItemVideoOutput, playerItem: AVPlayerItem, startTime: CMTime) {
|
||
guard !isRecording else { return }
|
||
|
||
weakOutput = output
|
||
currentPlayerItem = playerItem
|
||
lastPixelBuffer = nil
|
||
captureFrameCount = 0
|
||
isRunning = false
|
||
recordStartTime = startTime
|
||
|
||
// 安装音频 Tap（录制时 asset 已加载，同步获取 track）
|
||
installAudioTap(on: playerItem)
|
||
|
||
let tempFilename = "temp_recording_\(Int(Date().timeIntervalSince1970)).mp4"
|
||
let url = saveDirectory.appendingPathComponent(tempFilename)
|
||
try? FileManager.default.removeItem(at: url)
|
||
tempURL = url
|
||
|
||
// 获取 tap context（可能还没有 format，先用默认值）
|
||
let ctx = gTapContext ?? AudioTapContext()
|
||
if gTapContext == nil { gTapContext = ctx }
|
||
self.tapContext = ctx
|
||
|
||
do {
|
||
writer = try AVAssetWriter(outputURL: url, fileType: .mp4)
|
||
} catch {
|
||
onError?("Cannot create writer: \(error.localizedDescription)")
|
||
return
|
||
}
|
||
|
||
guard let writer = writer else { return }
|
||
|
||
// 视频输入（H264）
|
||
let videoSettings: [String: Any] = [
|
||
AVVideoCodecKey: AVVideoCodecType.h264,
|
||
AVVideoWidthKey: 1920,
|
||
AVVideoHeightKey: 1080
|
||
]
|
||
let vInput = AVAssetWriterInput(mediaType: .video, outputSettings: videoSettings)
|
||
vInput.expectsMediaDataInRealTime = true
|
||
if writer.canAdd(vInput) {
|
||
writer.add(vInput)
|
||
videoInput = vInput
|
||
}
|
||
|
||
// 音频输入（AAC 编码）— 在 startWriting 之前添加
|
||
// 使用 tap 已知的格式，或默认值
|
||
let audioRate = ctx.sampleRate > 0 ? ctx.sampleRate : 48000.0
|
||
let audioCh = ctx.channelsPerFrame > 0 ? ctx.channelsPerFrame : 2
|
||
|
||
var sourceFmtDesc: CMAudioFormatDescription?
|
||
if let tapFmt = ctx.formatDescription {
|
||
sourceFmtDesc = tapFmt
|
||
} else {
|
||
// Tap 还没有 prepare，创建默认格式描述
|
||
var asbd = AudioStreamBasicDescription(
|
||
mSampleRate: audioRate,
|
||
mFormatID: kAudioFormatLinearPCM,
|
||
mFormatFlags: kAudioFormatFlagIsFloat | kAudioFormatFlagIsPacked | kAudioFormatFlagIsNonInterleaved,
|
||
mBytesPerPacket: 4,
|
||
mFramesPerPacket: 1,
|
||
mBytesPerFrame: 4,
|
||
mChannelsPerFrame: audioCh,
|
||
mBitsPerChannel: 32,
|
||
mReserved: 0
|
||
)
|
||
CMAudioFormatDescriptionCreate(
|
||
allocator: kCFAllocatorDefault,
|
||
asbd: &asbd, layoutSize: 0, layout: nil,
|
||
magicCookieSize: 0, magicCookie: nil,
|
||
extensions: nil, formatDescriptionOut: &sourceFmtDesc
|
||
)
|
||
}
|
||
|
||
if let fmtDesc = sourceFmtDesc {
|
||
let audioSettings: [String: Any] = [
|
||
AVFormatIDKey: kAudioFormatMPEG4AAC,
|
||
AVSampleRateKey: audioRate,
|
||
AVNumberOfChannelsKey: audioCh,
|
||
AVEncoderBitRateKey: 128_000
|
||
]
|
||
let aInput = AVAssetWriterInput(mediaType: .audio, outputSettings: audioSettings, sourceFormatHint: fmtDesc)
|
||
aInput.expectsMediaDataInRealTime = true
|
||
if writer.canAdd(aInput) {
|
||
writer.add(aInput)
|
||
audioInput = aInput
|
||
NSLog("[Recorder] AudioInput added: AAC rate=%.0f ch=%u", audioRate, audioCh)
|
||
}
|
||
}
|
||
|
||
guard writer.startWriting() else {
|
||
NSLog("[Recorder] startWriting failed: %@", writer.error?.localizedDescription ?? "unknown")
|
||
onError?("Cannot start writer: \(writer.error?.localizedDescription ?? "unknown")")
|
||
return
|
||
}
|
||
|
||
writer.startSession(atSourceTime: .zero)
|
||
NSLog("[Recorder] Writer started, writing to: %@", url.lastPathComponent)
|
||
|
||
// 重置 tap context 录制状态
|
||
ctx.isRecording = true
|
||
ctx.writerInput = audioInput
|
||
ctx.appendCount = 0
|
||
ctx.totalFramesWritten = 0
|
||
ctx.firstAppendLogged = false
|
||
ctx.processCallCount = 0
|
||
|
||
// 重置诊断统计
|
||
ctx.peakAmplitude = 0
|
||
ctx.silentCallCount = 0
|
||
ctx.activeCallCount = 0
|
||
ctx.skippedNotRecording = 0
|
||
ctx.skippedNoFormat = 0
|
||
ctx.skippedNoData = 0
|
||
ctx.appendFailCount = 0
|
||
ctx.notReadyCount = 0
|
||
ctx.lastActiveTimestamp = 0
|
||
ctx.recordStartTime = Date()
|
||
|
||
isRecording = true
|
||
isRunning = true
|
||
startCaptureLoop()
|
||
startDurationTimer()
|
||
}
|
||
|
||
// MARK: - 停止录制
|
||
|
||
func stopRecording() {
|
||
guard isRecording else { return }
|
||
isRecording = false
|
||
isRunning = false
|
||
RecorderState.isFinalizing = true
|
||
captureTimer?.invalidate()
|
||
captureTimer = nil
|
||
stopDurationTimer()
|
||
|
||
// 停止音频 tap 写入
|
||
tapContext?.isRecording = false
|
||
|
||
// 快照诊断数据（tap 停止后不会再更新）
|
||
let statsSnapshot = AudioDiagStats(
|
||
videoFrames: captureFrameCount,
|
||
processCallCount: tapContext?.processCallCount ?? 0,
|
||
appendCount: tapContext?.appendCount ?? 0,
|
||
totalFramesWritten: tapContext?.totalFramesWritten ?? 0,
|
||
peakAmplitude: tapContext?.peakAmplitude ?? 0,
|
||
activeCallCount: tapContext?.activeCallCount ?? 0,
|
||
silentCallCount: tapContext?.silentCallCount ?? 0,
|
||
skippedNotRecording: tapContext?.skippedNotRecording ?? 0,
|
||
skippedNoFormat: tapContext?.skippedNoFormat ?? 0,
|
||
skippedNoData: tapContext?.skippedNoData ?? 0,
|
||
appendFailCount: tapContext?.appendFailCount ?? 0,
|
||
notReadyCount: tapContext?.notReadyCount ?? 0,
|
||
lastActiveTimestamp: tapContext?.lastActiveTimestamp ?? 0,
|
||
sampleRate: tapContext?.sampleRate ?? 0,
|
||
channelsPerFrame: tapContext?.channelsPerFrame ?? 0
|
||
)
|
||
|
||
NSLog("[Recorder] Stopping: videoFrames=%d, audioProcessCalls=%d, audioAppended=%d, peak=%.4f, active=%d, silent=%d",
|
||
statsSnapshot.videoFrames, statsSnapshot.processCallCount, statsSnapshot.appendCount,
|
||
statsSnapshot.peakAmplitude, statsSnapshot.activeCallCount, statsSnapshot.silentCallCount)
|
||
|
||
currentPlayerItem = nil
|
||
|
||
videoInput?.markAsFinished()
|
||
audioInput?.markAsFinished()
|
||
|
||
writer?.finishWriting { [weak self] in
|
||
NSLog("[Recorder] finishWriting callback invoked")
|
||
DispatchQueue.main.async {
|
||
RecorderState.isFinalizing = false
|
||
|
||
guard let self = self, let w = self.writer else {
|
||
NSLog("[Recorder] ⚠️ self or writer is nil in finishWriting callback")
|
||
if RecorderState.pendingTerminate {
|
||
RecorderState.pendingTerminate = false
|
||
NSApp.reply(toApplicationShouldTerminate: true)
|
||
}
|
||
return
|
||
}
|
||
NSLog("[Recorder] finishWriting: status=%d, error=%@, videoFrames=%d, audioFrames=%d",
|
||
w.status.rawValue,
|
||
w.error?.localizedDescription ?? "none",
|
||
statsSnapshot.videoFrames, statsSnapshot.appendCount)
|
||
|
||
if w.status == .completed, let tempURL = self.tempURL {
|
||
if FileManager.default.fileExists(atPath: tempURL.path) {
|
||
let size = (try? FileManager.default.attributesOfItem(atPath: tempURL.path)[.size] as? UInt64) ?? 0
|
||
NSLog("[Recorder] ✓ Temp file exists: %@, size=%llu bytes", tempURL.lastPathComponent, size)
|
||
// 写诊断报告（与 mp4 同目录）
|
||
self.writeDiagnosticReport(stats: statsSnapshot, videoURL: tempURL)
|
||
self.showSaveDialog(tempURL: tempURL)
|
||
} else {
|
||
NSLog("[Recorder] ⚠️ Temp file missing: %@", tempURL.path)
|
||
self.onError?("Recording file missing")
|
||
self.checkPendingTerminate()
|
||
}
|
||
} else {
|
||
NSLog("[Recorder] ✗ finishWriting failed: status=%d, error=%@",
|
||
w.status.rawValue, w.error?.localizedDescription ?? "unknown")
|
||
self.onError?("Recording failed: \(w.error?.localizedDescription ?? "unknown (status=\(w.status.rawValue))")")
|
||
if let url = self.tempURL {
|
||
try? FileManager.default.removeItem(at: url)
|
||
}
|
||
self.checkPendingTerminate()
|
||
}
|
||
}
|
||
}
|
||
|
||
lastPixelBuffer = nil
|
||
}
|
||
|
||
// MARK: - 视频抓帧 (30fps Timer)
|
||
|
||
private func startCaptureLoop() {
|
||
captureTimer = Timer.scheduledTimer(withTimeInterval: 1.0 / 30.0, repeats: true) { [weak self] _ in
|
||
Task { @MainActor in
|
||
self?.captureVideoFrame()
|
||
}
|
||
}
|
||
}
|
||
|
||
private func captureVideoFrame() {
|
||
guard isRunning, let output = weakOutput, let input = videoInput,
|
||
input.isReadyForMoreMediaData else { return }
|
||
|
||
let hostTime = CACurrentMediaTime()
|
||
let itemTime = output.itemTime(forHostTime: hostTime)
|
||
|
||
if let pb = output.copyPixelBuffer(forItemTime: itemTime, itemTimeForDisplay: nil) {
|
||
lastPixelBuffer = pb
|
||
}
|
||
|
||
guard let pb = lastPixelBuffer else { return }
|
||
|
||
let relativeTime = CMTimeSubtract(itemTime, recordStartTime)
|
||
guard relativeTime.seconds >= 0 else { return }
|
||
|
||
if let sb = Self.createSampleBuffer(from: pb, time: relativeTime) {
|
||
if input.append(sb) {
|
||
captureFrameCount += 1
|
||
}
|
||
}
|
||
}
|
||
|
||
private static func createSampleBuffer(from pixelBuffer: CVPixelBuffer, time: CMTime) -> CMSampleBuffer? {
|
||
var info = CMSampleTimingInfo()
|
||
info.presentationTimeStamp = time
|
||
info.duration = CMTime(value: 1, timescale: 30)
|
||
info.decodeTimeStamp = .invalid
|
||
|
||
var formatDescription: CMFormatDescription?
|
||
CMVideoFormatDescriptionCreateForImageBuffer(
|
||
allocator: kCFAllocatorDefault,
|
||
imageBuffer: pixelBuffer,
|
||
formatDescriptionOut: &formatDescription
|
||
)
|
||
|
||
guard let fd = formatDescription else { return nil }
|
||
|
||
var sampleBuffer: CMSampleBuffer?
|
||
CMSampleBufferCreateReadyWithImageBuffer(
|
||
allocator: kCFAllocatorDefault,
|
||
imageBuffer: pixelBuffer,
|
||
formatDescription: fd,
|
||
sampleTiming: &info,
|
||
sampleBufferOut: &sampleBuffer
|
||
)
|
||
|
||
return sampleBuffer
|
||
}
|
||
|
||
// MARK: - 录制时长显示
|
||
|
||
private func startDurationTimer() {
|
||
startDate = Date()
|
||
durationTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
|
||
Task { @MainActor in
|
||
self?.updateDuration()
|
||
}
|
||
}
|
||
}
|
||
|
||
private func stopDurationTimer() {
|
||
durationTimer?.invalidate()
|
||
durationTimer = nil
|
||
}
|
||
|
||
private func updateDuration() {
|
||
guard let start = startDate else { return }
|
||
let elapsed = Int(Date().timeIntervalSince(start))
|
||
let min = elapsed / 60
|
||
let sec = elapsed % 60
|
||
durationText = String(format: "%02d:%02d", min, sec)
|
||
}
|
||
|
||
// MARK: - 诊断报告
|
||
|
||
/// 录制完成后生成诊断报告文件（.txt），与 mp4 同目录
|
||
private func writeDiagnosticReport(stats: AudioDiagStats, videoURL: URL) {
|
||
let reportURL = videoURL.deletingPathExtension().appendingPathExtension("txt")
|
||
|
||
let videoDuration = Double(stats.videoFrames) / 30.0 // 30fps
|
||
let audioDuration = stats.sampleRate > 0 ? Double(stats.totalFramesWritten) / stats.sampleRate : 0
|
||
|
||
let peakDB = stats.peakAmplitude > 0 ? 20 * log10(stats.peakAmplitude) : -Float.infinity
|
||
|
||
var verdict: String
|
||
if stats.processCallCount == 0 {
|
||
verdict = "FAIL: tap never called — audioMix not attached or wrong trackID"
|
||
} else if stats.activeCallCount == 0 && stats.silentCallCount > 0 {
|
||
verdict = "FAIL: tap called \(stats.processCallCount)x but ALL silent — source is muted or tap bound to wrong track"
|
||
} else if stats.appendCount == 0 {
|
||
verdict = "FAIL: tap active (\(stats.activeCallCount) calls) but 0 appends — writerInput issue (skippedNotRecording=\(stats.skippedNotRecording), appendFail=\(stats.appendFailCount), notReady=\(stats.notReadyCount))"
|
||
} else if stats.activeCallCount > 0 && audioDuration < videoDuration * 0.5 {
|
||
verdict = "WARN: audio \(String(format: "%.1f", audioDuration))s < video \(String(format: "%.1f", videoDuration))s — tap stopped mid-recording (HLS variant switch?)"
|
||
} else if stats.peakAmplitude < 0.001 {
|
||
verdict = "FAIL: peak \(String(format: "%.6f", stats.peakAmplitude)) (\(String(format: "%.1f", peakDB))dB) — effectively silent"
|
||
} else {
|
||
verdict = "OK"
|
||
}
|
||
|
||
let lines = [
|
||
"=== MiniPlayer Recording Diagnostic Report ===",
|
||
"Generated: \(Date())",
|
||
"Video file: \(videoURL.lastPathComponent)",
|
||
"",
|
||
"--- Verdict ---",
|
||
verdict,
|
||
"",
|
||
"--- Video ---",
|
||
"Frames: \(stats.videoFrames)",
|
||
"Duration: \(String(format: "%.2f", videoDuration))s (@ 30fps)",
|
||
"",
|
||
"--- Audio Tap Stats ---",
|
||
"processCallCount: \(stats.processCallCount) (total tap callbacks)",
|
||
"activeCallCount: \(stats.activeCallCount) (had audio signal, peak > -60dB)",
|
||
"silentCallCount: \(stats.silentCallCount) (silence detected)",
|
||
"appendCount: \(stats.appendCount) (samples written to AVAssetWriter)",
|
||
"totalFramesWritten: \(stats.totalFramesWritten)",
|
||
"audioDuration: \(String(format: "%.2f", audioDuration))s",
|
||
"lastActiveAt: \(String(format: "%.2f", stats.lastActiveTimestamp))s (time from record start)",
|
||
"",
|
||
"--- Audio Format ---",
|
||
"sampleRate: \(String(format: "%.0f", stats.sampleRate)) Hz",
|
||
"channelsPerFrame: \(stats.channelsPerFrame)",
|
||
"peakAmplitude: \(String(format: "%.6f", stats.peakAmplitude)) (\(String(format: "%.1f", peakDB)) dB)",
|
||
"",
|
||
"--- Skip/Error Counts ---",
|
||
"skippedNotRecording: \(stats.skippedNotRecording) (isRecording was false)",
|
||
"skippedNoFormat: \(stats.skippedNoFormat) (formatDescription was nil)",
|
||
"skippedNoData: \(stats.skippedNoData) (buffer had no data)",
|
||
"appendFailCount: \(stats.appendFailCount) (writerInput.append returned false)",
|
||
"notReadyCount: \(stats.notReadyCount) (writerInput not ready for data)",
|
||
"",
|
||
"--- How to Read ---",
|
||
"processCallCount=0 → audioMix never reached the tap (check trackID / variant switch)",
|
||
"activeCallCount=0 + silentCallCount>0 → tap gets data but it's all zeros (wrong track / muted source)",
|
||
"appendCount=0 + activeCallCount>0 → data captured but writer rejected it (format mismatch)",
|
||
"audioDuration << videoDuration → tap worked initially then stopped (HLS variant switch mid-recording)",
|
||
"peakAmplitude < 0.001 → effectively silent output",
|
||
]
|
||
|
||
let report = lines.joined(separator: "\n")
|
||
do {
|
||
try report.write(to: reportURL, atomically: true, encoding: .utf8)
|
||
NSLog("[Recorder] ✓ Diagnostic report: %@", reportURL.path)
|
||
print(report) // 也输出到终端
|
||
} catch {
|
||
NSLog("[Recorder] ⚠️ Failed to write diagnostic report: %@", error.localizedDescription)
|
||
}
|
||
}
|
||
|
||
// MARK: - 保存对话框
|
||
|
||
private func showSaveDialog(tempURL: URL) {
|
||
let reportURL = tempURL.deletingPathExtension().appendingPathExtension("txt")
|
||
let panel = NSSavePanel()
|
||
panel.allowedContentTypes = [.mpeg4Movie]
|
||
panel.nameFieldStringValue = tempURL.lastPathComponent
|
||
panel.directoryURL = saveDirectory
|
||
|
||
panel.begin { [weak self] response in
|
||
if response == .OK, let url = panel.url {
|
||
do {
|
||
if FileManager.default.fileExists(atPath: url.path) {
|
||
try FileManager.default.removeItem(at: url)
|
||
}
|
||
try FileManager.default.moveItem(at: tempURL, to: url)
|
||
NSLog("[Recorder] ✓ Saved: %@", url.path)
|
||
|
||
// 诊断报告也移到同目录
|
||
if FileManager.default.fileExists(atPath: reportURL.path) {
|
||
let reportDest = url.deletingPathExtension().appendingPathExtension("txt")
|
||
if FileManager.default.fileExists(atPath: reportDest.path) {
|
||
try FileManager.default.removeItem(at: reportDest)
|
||
}
|
||
try FileManager.default.moveItem(at: reportURL, to: reportDest)
|
||
NSLog("[Recorder] ✓ Diagnostic report saved: %@", reportDest.path)
|
||
}
|
||
|
||
self?.onRecordingSaved?(url)
|
||
} catch {
|
||
NSLog("[Recorder] ✗ Save failed: %@", error.localizedDescription)
|
||
self?.onError?("Save failed: \(error.localizedDescription)")
|
||
}
|
||
} else {
|
||
try? FileManager.default.removeItem(at: tempURL)
|
||
try? FileManager.default.removeItem(at: reportURL)
|
||
}
|
||
self?.checkPendingTerminate()
|
||
}
|
||
}
|
||
|
||
private func checkPendingTerminate() {
|
||
if RecorderState.pendingTerminate {
|
||
RecorderState.pendingTerminate = false
|
||
NSApp.reply(toApplicationShouldTerminate: true)
|
||
}
|
||
}
|
||
}
|
||
#endif
|