iOS音视频原理

编码格式（Codec）：定义数据怎么压缩
  视频：H.264、H.265、VP9、AV1
  音频：AAC、MP3、Opus、FLAC

封装格式（Container）：定义压缩后的数据怎么组织存储
  MP4、MOV、FLV、MKV、TS

两者是独立的，可以自由组合:
  MP4容器 + H.264视频 + AAC音频  （最常见的组合）
  MOV容器 + H.265视频 + AAC音频  （iPhone录制默认）
  FLV容器 + H.264视频 + AAC音频  （直播推流常用）
  MKV容器 + AV1视频  + Opus音频  （新一代免费组合）

同一段1080p 30fps视频:
H.264编码: 约 4~8 Mbps 可达到较好画质
H.265编码: 约 2~4 Mbps 即可达到相同画质（码率减半）

码率与文件大小的关系:
文件大小(MB) = 码率(Mbps) x 时长(秒) / 8

例: 4Mbps码率的10分钟视频
4 x 600 / 8 = 300 MB

数据量(bits) = 采样率 x 位深 x 声道数 x 时长(秒)
例：44100 x 16 x 2 x 60 = 84,672,000 bits ≈ 10.1MB/min

对比不同规格:
CD质量 (44.1kHz/16bit/立体声):  ≈ 10.1 MB/min
高清音频 (96kHz/24bit/立体声):  ≈ 33.0 MB/min
电话语音 (8kHz/8bit/单声道):    ≈ 0.46 MB/min

YUV与RGB的转换关系:

BT.601标准（标清SD, 分辨率 <= 720p）:
Y  =  0.299R + 0.587G + 0.114B
Cb = -0.169R - 0.331G + 0.500B + 128
Cr =  0.500R - 0.419G - 0.081B + 128

BT.709标准（高清HD, 720p ~ 1080p）:
Y  =  0.2126R + 0.7152G + 0.0722B
Cb = -0.1146R - 0.3854G + 0.5000B + 128
Cr =  0.5000R - 0.6142G - 0.0858B + 128

注意：使用错误的转换矩阵会导致偏色

I420 (kCVPixelFormatType_420YpCbCr8Planar):
[YYYYYYYY...] [UUUU...] [VVVV...]
 Y平面(WxH)   U平面(W/2xH/2)  V平面(W/2xH/2)

YV12: 与I420类似，但U和V的顺序互换
[YYYYYYYY...] [VVVV...] [UUUU...]

NV12 (kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange):
[YYYYYYYY...] [UVUVUV...]
 Y平面(WxH)   UV交错平面(W/2xH/2, 每个位置2字节)

NV21: 与NV12类似，但UV交错顺序为VU
[YYYYYYYY...] [VUVUVU...]

1080p 30fps YUV420视频:
1920 x 1080 x 1.5(YUV420每像素字节) x 30 = 93,312,000 Bytes/s ≈ 711 Mbps

1080p 30fps RGB视频:
1920 x 1080 x 3(RGB每像素字节) x 30 = 186,624,000 Bytes/s ≈ 1.43 Gbps

一部90分钟的1080p电影(YUV420):
711 Mbps x 5400s ≈ 480 GB

典型GOP结构 (GOP=12): I B B P B B P B B P B B I
                       |<--------  一个GOP  -------->|

显示顺序(PTS): I0  B1  B2  P3  B4  B5  P6
解码顺序(DTS): I0  P3  B1  B2  P6  B4  B5
                ↑         ↑
         先解码P3，因为B1、B2要参考P3

16x16宏块的划分方式:
┌────────┐  ┌────┬────┐  ┌────┬────┐  ┌──┬──┬──┬──┐
│        │  │    │    │  │    │    │  │  │  │  │  │
│ 16x16  │  │16x8│16x8│  │ 8  │ 8  │  │  │  │  │  │
│        │  │    │    │  │ x  │ x  │  │8x8 8x8 8x8 8x8│
│        │  ├────┼────┤  │16  │16  │  │  │  │  │  │
│        │  │    │    │  │    │    │  ├──┼──┼──┼──┤
│        │  │    │    │  │    │    │  │  │  │  │  │
└────────┘  └────┴────┘  └────┴────┘  └──┴──┴──┴──┘
  1个分区      2个分区      2个分区      4个分区

平坦区域 → 大分区（16x16），一个预测就够
复杂区域 → 小分区（4x4），精细预测减少残差

H.264帧内预测模式（4x4亮度块，共9种模式）:

模式0: 垂直        模式1: 水平        模式2: DC(均值)
A B C D            A|               A B C D
↓ ↓ ↓ ↓            ─┼→ → → →        ↓ ↓ ↓ ↓
A B C D          E|E E E E       ← ← ← ←  (取周围像素均值填充)
A B C D          F|F F F F
A B C D          G|G G G G
A B C D          H|H H H H

模式3~8: 对角线方向预测（左下、右下、左上等）

示例：一个4x4残差块经过DCT变换

空域残差:              频域DCT系数:
┌──────────────┐      ┌──────────────┐
│  2  3  1  0  │      │ 12  1  0  0  │  ← 低频（左上角）能量集中
│  1  2  1  0  │  DCT │  2  0  0  0  │
│  0  1  0  0  │ ───→ │  0  0  0  0  │  ← 高频（右下角）接近零
│  0  0  0  0  │      │  0  0  0  0  │
└──────────────┘      └──────────────┘

低频系数: 表示块的整体亮度和缓变趋势
高频系数: 表示块内的急剧变化（边缘、纹理细节）

量化过程: Q(x) = round(DCT(x) / QStep)

DCT系数:        量化步长QStep=4:     量化后:
┌────────────┐                     ┌────────────┐
│ 12  1  0  0│                     │  3  0  0  0│  ← 大部分高频系数变为0
│  2  0  0  0│  ÷4并取整  →        │  1  0  0  0│
│  0  0  0  0│                     │  0  0  0  0│
│  0  0  0  0│                     │  0  0  0  0│
└────────────┘                     └────────────┘

Zigzag扫描顺序（4x4块）:
┌─→─→──┐
│ 0  1  5  6
│ ↙ ↗ ↙ ↗
│ 2  4  7 12
│ ↗ ↙ ↗ ↙
│ 3  8 11 13
│ ↙ ↗ ↙
  9 10 14 15

这样排列使得连续的零值集中在序列尾部，便于游程编码

NAL单元结构:
┌─────────┬───────────────────────┐
│ NAL头(1B)│     RBSP数据           │
│ F|NRI|Type│                      │
└─────────┴───────────────────────┘

常见NAL Type:
  1  - 非IDR图像的Slice（P帧、B帧）
  5  - IDR图像的Slice（关键帧，清空参考帧队列）
  6  - SEI（补充增强信息）
  7  - SPS（序列参数集）
  8  - PPS（图像参数集）

Box结构:
┌──────────┬──────────┬─────────────────┐
│ Size (4B) │ Type (4B) │     Data        │
│ Box总长度  │ 如'moov' │  子Box或原始数据  │
└──────────┴──────────┴─────────────────┘

MP4文件
├── ftyp    -- 文件类型标识（如isom, mp42）
├── moov    -- 元数据容器（时间、轨道信息等）
│   ├── mvhd    -- 影片头信息（时长、时间刻度timescale）
│   ├── trak    -- 视频轨道
│   │   ├── tkhd    -- 轨道头（宽高、时长、transform矩阵）
│   │   └── mdia    -- 媒体信息
│   │       ├── mdhd    -- 媒体头（timescale、时长）
│   │       ├── hdlr    -- 处理器类型(vide/soun)
│   │       └── minf    -- 媒体具体信息
│   │           └── stbl    -- 采样表（Sample Table，最关键的部分）
│   │               ├── stsd    -- 采样描述（编码参数，如avc1/hvc1）
│   │               ├── stts    -- DTS时间到采样的映射
│   │               ├── ctts    -- CTS偏移（PTS = DTS + CTS）
│   │               ├── stss    -- 关键帧索引（哪些帧是I帧）
│   │               ├── stsc    -- 采样到chunk映射
│   │               ├── stsz    -- 每个采样的大小（字节数）
│   │               └── stco    -- chunk在文件中的偏移量
│   └── trak    -- 音频轨道
│       └── ...（结构类似视频轨道）
└── mdat    -- 实际音视频数据（编码后的裸数据）

1. stts: 目标时间 → 第N个sample
2. stss: 从第N个sample向前找到最近的关键帧K
3. stsz: 计算第K个sample的大小
4. stsc: 第K个sample属于哪个chunk
5. stco: 该chunk在文件中的字节偏移
6. 定位到mdat中的具体位置，开始解码

timescale = 90000 (视频常用)
一帧的duration = 3000
实际时长 = 3000 / 90000 = 0.0333秒 = 33.3ms ≈ 30fps

timescale = 44100 (音频，等于采样率)
1024个采样的duration = 1024
实际时长 = 1024 / 44100 = 0.0232秒 ≈ 23.2ms

普通MP4 (moov在尾部):
┌──────┬────────────────────────┬──────┐
│ ftyp │        mdat            │ moov │
└──────┴────────────────────────┴──────┘
  问题：播放器必须先下载到文件尾部获取moov才能开始播放

Fast Start MP4 (moov在头部):
┌──────┬──────┬────────────────────────┐
│ ftyp │ moov │        mdat            │
└──────┴──────┴────────────────────────┘
  优势：播放器下载少量头部数据即可开始播放

fMP4结构:
┌──────┬──────┬──────┬──────┬──────┬──────┬──────┬──────┐
│ ftyp │ moov │ moof │ mdat │ moof │ mdat │ moof │ mdat │
│      │(初始)│  #1  │  #1  │  #2  │  #2  │  #3  │  #3  │
└──────┴──────┴──────┴──────┴──────┴──────┴──────┴──────┘

class CameraCapture: NSObject {
    private let session = AVCaptureSession()
    private let videoOutput = AVCaptureVideoDataOutput()
    private let audioOutput = AVCaptureAudioDataOutput()
    private let processingQueue = DispatchQueue(label: "com.capture.processing")
    
    func setupSession() throws {
        session.beginConfiguration()
        defer { session.commitConfiguration() }
        
        session.sessionPreset = .hd1920x1080
        
        // 配置视频输入
        guard let videoDevice = AVCaptureDevice.default(
            .builtInWideAngleCamera, for: .video, position: .back
        ) else { throw CaptureError.deviceNotFound }
        
        let videoInput = try AVCaptureDeviceInput(device: videoDevice)
        guard session.canAddInput(videoInput) else { throw CaptureError.cannotAddInput }
        session.addInput(videoInput)
        
        // 配置音频输入
        guard let audioDevice = AVCaptureDevice.default(for: .audio) else {
            throw CaptureError.deviceNotFound
        }
        let audioInput = try AVCaptureDeviceInput(device: audioDevice)
        session.addInput(audioInput)
        
        // 配置视频输出
        videoOutput.videoSettings = [
            kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange
        ]
        videoOutput.setSampleBufferDelegate(self, queue: processingQueue)
        videoOutput.alwaysDiscardsLateVideoFrames = true
        session.addOutput(videoOutput)
        
        // 配置音频输出
        audioOutput.setSampleBufferDelegate(self, queue: processingQueue)
        session.addOutput(audioOutput)
    }
    
    func startCapture() {
        DispatchQueue.global(qos: .userInitiated).async {
            self.session.startRunning()
        }
    }
}

extension CameraCapture: AVCaptureVideoDataOutputSampleBufferDelegate,
                          AVCaptureAudioDataOutputSampleBufferDelegate {
    func captureOutput(_ output: AVCaptureOutput,
                       didOutput sampleBuffer: CMSampleBuffer,
                       from connection: AVCaptureConnection) {
        if output == videoOutput {
            // 处理视频帧 - sampleBuffer包含CVPixelBuffer
            guard let pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer) else { return }
            let pts = CMSampleBufferGetPresentationTimeStamp(sampleBuffer)
            processVideoFrame(pixelBuffer, timestamp: pts)
        } else if output == audioOutput {
            // 处理音频帧 - sampleBuffer包含AudioBufferList
            processAudioSample(sampleBuffer)
        }
    }
    
    func captureOutput(_ output: AVCaptureOutput,
                       didDrop sampleBuffer: CMSampleBuffer,
                       from connection: AVCaptureConnection) {
        // 帧被丢弃时的回调，通常因为处理太慢
    }
}

CMSampleBuffer
├── CMBlockBuffer / CVImageBuffer   -- 实际的媒体数据
│   ├── 视频: CVPixelBuffer (未压缩) 或 CMBlockBuffer (已压缩)
│   └── 音频: CMBlockBuffer (PCM数据)
├── CMFormatDescription              -- 格式信息
│   ├── 视频: 编码类型、分辨率、像素格式
│   └── 音频: 采样率、声道数、位深
├── CMTime (PTS)                     -- 显示时间戳
├── CMTime (DTS)                     -- 解码时间戳
└── Attachments                      -- 附加信息（是否关键帧等）

class H264Encoder {
    private var compressionSession: VTCompressionSession?
    
    func setupEncoder(width: Int32, height: Int32) {
        let status = VTCompressionSessionCreate(
            allocator: kCFAllocatorDefault,
            width: width,
            height: height,
            codecType: kCMVideoCodecType_H264,
            encoderSpecification: nil,
            imageBufferAttributes: nil,
            compressedDataAllocator: nil,
            outputHandler: { [weak self] status, flags, sampleBuffer in
                guard status == noErr, let sampleBuffer = sampleBuffer else { return }
                self?.handleEncodedData(sampleBuffer)
            },
            refcon: nil,
            compressionSessionOut: &compressionSession
        )
        guard status == noErr, let session = compressionSession else { return }
        
        // 配置编码参数
        VTSessionSetProperty(session, key: kVTCompressionPropertyKey_RealTime, value: kCFBooleanTrue)
        VTSessionSetProperty(session, key: kVTCompressionPropertyKey_ProfileLevel,
                            value: kVTProfileLevel_H264_High_AutoLevel)
        VTSessionSetProperty(session, key: kVTCompressionPropertyKey_AverageBitRate,
                            value: (width * height * 3) as CFNumber)
        VTSessionSetProperty(session, key: kVTCompressionPropertyKey_MaxKeyFrameInterval,
                            value: 60 as CFNumber)
        VTSessionSetProperty(session, key: kVTCompressionPropertyKey_AllowFrameReordering,
                            value: kCFBooleanFalse) // 禁用B帧以降低延迟
        
        VTCompressionSessionPrepareToEncodeFrames(session)
    }
    
    func encode(pixelBuffer: CVPixelBuffer, presentationTimeStamp: CMTime) {
        guard let session = compressionSession else { return }
        
        VTCompressionSessionEncodeFrame(
            session,
            imageBuffer: pixelBuffer,
            presentationTimeStamp: presentationTimeStamp,
            duration: .invalid,
            frameProperties: nil,
            sourceFrameRefcon: nil,
            infoFlagsOut: nil
        )
    }
    
    private func handleEncodedData(_ sampleBuffer: CMSampleBuffer) {
        let isKeyFrame = !(sampleBuffer.sampleAttachments.first?[.notSync] as? Bool ?? false)
        
        if isKeyFrame {
            // 从关键帧中提取SPS/PPS
            extractParameterSets(from: sampleBuffer)
        }
        
        // 获取编码后的NAL单元数据
        guard let dataBuffer = sampleBuffer.dataBuffer else { return }
        var totalLength = 0
        var dataPointer: UnsafeMutablePointer<Int8>?
        CMBlockBufferGetDataPointer(dataBuffer, atOffset: 0, lengthAtOffsetOut: nil,
                                     totalLengthOut: &totalLength, dataPointerOut: &dataPointer)
        // 将AVCC格式转换为Annex-B格式用于网络传输
        // AVCC: [4字节长度][NAL数据]
        // Annex-B: [00 00 00 01][NAL数据]
    }
    
    private func extractParameterSets(from sampleBuffer: CMSampleBuffer) {
        guard let formatDescription = sampleBuffer.formatDescription else { return }
        
        // 提取SPS
        var spsSize = 0
        var spsCount = 0
        var spsPointer: UnsafePointer<UInt8>?
        CMVideoFormatDescriptionGetH264ParameterSetAtIndex(
            formatDescription, parameterSetIndex: 0,
            parameterSetPointerOut: &spsPointer, parameterSetSizeOut: &spsSize,
            parameterSetCountOut: &spsCount, nalUnitHeaderLengthOut: nil
        )
        
        // 提取PPS
        var ppsSize = 0
        var ppsPointer: UnsafePointer<UInt8>?
        CMVideoFormatDescriptionGetH264ParameterSetAtIndex(
            formatDescription, parameterSetIndex: 1,
            parameterSetPointerOut: &ppsPointer, parameterSetSizeOut: &ppsSize,
            parameterSetCountOut: nil, nalUnitHeaderLengthOut: nil
        )
    }
    
    deinit {
        if let session = compressionSession {
            VTCompressionSessionInvalidate(session)
        }
    }
}

class H264Decoder {
    private var decompressionSession: VTDecompressionSession?
    private var formatDescription: CMVideoFormatDescription?
    
    func setupDecoder(sps: Data, pps: Data) {
        let spsPointer = sps.withUnsafeBytes { $0.baseAddress!.assumingMemoryBound(to: UInt8.self) }
        let ppsPointer = pps.withUnsafeBytes { $0.baseAddress!.assumingMemoryBound(to: UInt8.self) }
        let parameterSets: [UnsafePointer<UInt8>] = [spsPointer, ppsPointer]
        let parameterSetSizes: [Int] = [sps.count, pps.count]
        
        // 从SPS/PPS创建格式描述
        CMVideoFormatDescriptionCreateFromH264ParameterSets(
            allocator: kCFAllocatorDefault,
            parameterSetCount: 2,
            parameterSetPointers: parameterSets,
            parameterSetSizes: parameterSetSizes,
            nalUnitHeaderLength: 4,
            formatDescriptionOut: &formatDescription
        )
        
        guard let formatDescription = formatDescription else { return }
        
        let outputAttributes: [String: Any] = [
            kCVPixelBufferPixelFormatTypeKey as String: kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange,
            kCVPixelBufferMetalCompatibilityKey as String: true
        ]
        
        var callbackRecord = VTDecompressionOutputCallbackRecord(
            decompressionOutputCallback: decompressionCallback,
            decompressionOutputRefCon: Unmanaged.passUnretained(self).toOpaque()
        )
        
        VTDecompressionSessionCreate(
            allocator: kCFAllocatorDefault,
            formatDescription: formatDescription,
            decoderSpecification: nil,
            imageBufferAttributes: outputAttributes as CFDictionary,
            outputCallback: &callbackRecord,
            decompressionSessionOut: &decompressionSession
        )
    }
}

private func decompressionCallback(
    decompressionOutputRefCon: UnsafeMutableRawPointer?,
    sourceFrameRefCon: UnsafeMutableRawPointer?,
    status: OSStatus,
    infoFlags: VTDecodeInfoFlags,
    imageBuffer: CVImageBuffer?,
    presentationTimeStamp: CMTime,
    presentationDuration: CMTime
) {
    guard status == noErr, let pixelBuffer = imageBuffer else { return }
    // pixelBuffer即为解码后的YUV数据，可用于渲染显示
}

class VideoPlayerManager {
    private var player: AVPlayer?
    private var playerItem: AVPlayerItem?
    private var timeObserver: Any?
    private var observations: [NSKeyValueObservation] = []
    
    func setupPlayer(with url: URL) {
        let asset = AVURLAsset(url: url)
        playerItem = AVPlayerItem(asset: asset)
        player = AVPlayer(playerItem: playerItem)
        
        // 监听播放状态
        observations.append(
            playerItem!.observe(\.status) { [weak self] item, _ in
                switch item.status {
                case .readyToPlay:
                    self?.player?.play()
                case .failed:
                    print("播放失败: \(item.error?.localizedDescription ?? "")")
                case .unknown:
                    break
                @unknown default:
                    break
                }
            }
        )
        
        // 监听缓冲进度
        observations.append(
            playerItem!.observe(\.loadedTimeRanges) { item, _ in
                guard let timeRange = item.loadedTimeRanges.first?.timeRangeValue else { return }
                let bufferedDuration = CMTimeGetSeconds(timeRange.start) + CMTimeGetSeconds(timeRange.duration)
                // 更新缓冲进度UI
            }
        )
        
        // 监听缓冲是否足够播放
        observations.append(
            playerItem!.observe(\.isPlaybackLikelyToKeepUp) { item, _ in
                if item.isPlaybackLikelyToKeepUp {
                    // 缓冲足够，可以流畅播放
                }
            }
        )
        
        // 周期性时间观察（更新进度条）
        timeObserver = player?.addPeriodicTimeObserver(
            forInterval: CMTime(seconds: 0.5, preferredTimescale: 600),
            queue: .main
        ) { [weak self] time in
            let currentSeconds = CMTimeGetSeconds(time)
            // 更新播放进度UI
        }
        
        // 播放完成通知
        NotificationCenter.default.addObserver(
            self, selector: #selector(playerDidFinish),
            name: .AVPlayerItemDidPlayToEndTime, object: playerItem
        )
    }
    
    @objc private func playerDidFinish() {
        player?.seek(to: .zero)
    }
    
    deinit {
        if let observer = timeObserver {
            player?.removeTimeObserver(observer)
        }
    }
}

同步流程:
1. 音频按固定采样率持续播放，维护音频时钟 audio_clock
2. 取出待渲染的视频帧，读取其PTS
3. 计算差值: diff = video_pts - audio_clock
4. 根据diff决定:
   - diff > 阈值(如40ms): 视频超前，延迟渲染（等待）
   - diff < -阈值: 视频落后，丢弃当前帧（追赶）
   - |diff| <= 阈值: 在可接受范围内，正常渲染

#EXTM3U
#EXT-X-STREAM-INF:BANDWIDTH=1280000,RESOLUTION=640x360
low/playlist.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=2560000,RESOLUTION=960x540
mid/playlist.m3u8
#EXT-X-STREAM-INF:BANDWIDTH=7680000,RESOLUTION=1920x1080
high/playlist.m3u8

#EXTM3U
#EXT-X-VERSION:3
#EXT-X-TARGETDURATION:10
#EXT-X-MEDIA-SEQUENCE:0
#EXTINF:9.009,
segment0.ts
#EXTINF:9.009,
segment1.ts
#EXTINF:9.009,
segment2.ts
#EXT-X-ENDLIST

class AudioProcessor {
    private let engine = AVAudioEngine()
    private let playerNode = AVAudioPlayerNode()
    private let pitchEffect = AVAudioUnitTimePitch()
    private let reverbEffect = AVAudioUnitReverb()
    
    func setupAudioChain() {
        engine.attach(playerNode)
        engine.attach(pitchEffect)
        engine.attach(reverbEffect)
        
        // 构建音频处理链
        let format = engine.mainMixerNode.outputFormat(forBus: 0)
        engine.connect(playerNode, to: pitchEffect, format: format)
        engine.connect(pitchEffect, to: reverbEffect, format: format)
        engine.connect(reverbEffect, to: engine.mainMixerNode, format: format)
        
        // 变调（不变速）
        pitchEffect.pitch = 500 // 以音分为单位，100 = 半音
        
        // 混响效果
        reverbEffect.loadFactoryPreset(.largeHall)
        reverbEffect.wetDryMix = 30
        
        try? engine.start()
    }
    
    func installTap() {
        let inputNode = engine.inputNode
        let format = inputNode.inputFormat(forBus: 0)
        
        // 安装音频采集回调（实时获取麦克风数据）
        inputNode.installTap(onBus: 0, bufferSize: 1024, format: format) { buffer, time in
            // buffer: AVAudioPCMBuffer - 包含PCM音频数据
            // 可用于音频分析（频谱、音量）、录制或实时处理
            let channelData = buffer.floatChannelData?[0]
            let frameLength = Int(buffer.frameLength)
            
            // 计算音量（RMS）
            var rms: Float = 0
            vDSP_measqv(channelData!, 1, &rms, vDSP_Length(frameLength))
            rms = sqrtf(rms)
            let dbLevel = 20 * log10f(rms)
        }
    }
}

#include <metal_stdlib>
using namespace metal;

struct VertexOut {
    float4 position [[position]];
    float2 texCoord;
};

fragment float4 yuvToRGBFragment(
    VertexOut in [[stage_in]],
    texture2d<float> yTexture [[texture(0)]],
    texture2d<float> uvTexture [[texture(1)]]
) {
    constexpr sampler textureSampler(mag_filter::linear, min_filter::linear);
    
    float y = yTexture.sample(textureSampler, in.texCoord).r;
    float2 uv = uvTexture.sample(textureSampler, in.texCoord).rg;
    
    // BT.601 YUV to RGB
    float u = uv.x - 0.5;
    float v = uv.y - 0.5;
    
    float r = y + 1.402 * v;
    float g = y - 0.344 * u - 0.714 * v;
    float b = y + 1.772 * u;
    
    return float4(r, g, b, 1.0);
}

func composeVideos(clips: [AVAsset]) async throws -> AVMutableComposition {
    let composition = AVMutableComposition()
    
    guard let videoTrack = composition.addMutableTrack(
        withMediaType: .video, preferredTrackID: kCMPersistentTrackID_Invalid
    ) else { throw EditError.trackCreationFailed }
    
    guard let audioTrack = composition.addMutableTrack(
        withMediaType: .audio, preferredTrackID: kCMPersistentTrackID_Invalid
    ) else { throw EditError.trackCreationFailed }
    
    var currentTime = CMTime.zero
    
    for clip in clips {
        let duration = try await clip.load(.duration)
        
        if let clipVideoTrack = try await clip.loadTracks(withMediaType: .video).first {
            try videoTrack.insertTimeRange(
                CMTimeRange(start: .zero, duration: duration),
                of: clipVideoTrack,
                at: currentTime
            )
        }
        
        if let clipAudioTrack = try await clip.loadTracks(withMediaType: .audio).first {
            try audioTrack.insertTimeRange(
                CMTimeRange(start: .zero, duration: duration),
                of: clipAudioTrack,
                at: currentTime
            )
        }
        
        currentTime = CMTimeAdd(currentTime, duration)
    }
    
    return composition
}

func exportVideo(composition: AVComposition, to outputURL: URL) async throws {
    guard let exportSession = AVAssetExportSession(
        asset: composition, presetName: AVAssetExportPresetHighestQuality
    ) else { throw EditError.exportFailed }
    
    exportSession.outputURL = outputURL
    exportSession.outputFileType = .mp4
    exportSession.shouldOptimizeForNetworkUse = true // moov前置，支持Fast Start
    
    await exportSession.export()
    
    if exportSession.status == .failed {
        throw exportSession.error ?? EditError.exportFailed
    }
}