视频压缩工具类
import UIKit
import AVFoundation
public class VideoCompressHelper {
private let expectedWidth: CGFloat = 960
private let expectedHeight: CGFloat = 540
private let expectedBitRate: Int = 1500 * 1024
private let expectedFrameRate: Int = 30
private var asset: AVAsset!
private var degrees: Int = 0
private var outputURL: URL!
private var reader: AVAssetReader?
private var writer: AVAssetWriter?
private var videoOutput: AVAssetReaderVideoCompositionOutput!
private var audioOutput: AVAssetReaderAudioMixOutput!
private var videoInput: AVAssetWriterInput!
private var audioInput: AVAssetWriterInput!
private var completionHandler: ((_ isSuccess: Bool) -> Void)?
private lazy var videoCompressProperties: [String: Any] = [
AVVideoAverageBitRateKey: expectedBitRate,
AVVideoExpectedSourceFrameRateKey: expectedFrameRate,
AVVideoProfileLevelKey: AVVideoProfileLevelH264HighAutoLevel,
]
private lazy var videoCompressSettings: [String: Any] = [
AVVideoCodecKey: AVVideoCodecType.h264,
AVVideoWidthKey: (degrees == 0 || degrees == 180) ? expectedWidth : expectedHeight,
AVVideoHeightKey: (degrees == 0 || degrees == 180) ? expectedHeight : expectedWidth,
AVVideoCompressionPropertiesKey: videoCompressProperties,
AVVideoScalingModeKey: AVVideoScalingModeResizeAspectFill,
]
private lazy var audioCompressSettings: [String: Any] = [
AVFormatIDKey: kAudioFormatMPEG4AAC,
AVNumberOfChannelsKey: 2,
AVSampleRateKey: 44100,
AVEncoderBitRateKey: 128000
]
public func compressVideo(sourceURL: URL, outputURL: URL, completionHandler: @escaping (_ isSuccess: Bool) -> Void) {
self.asset = AVAsset(url: sourceURL)
self.outputURL = outputURL
self.completionHandler = completionHandler
self.degrees = degressFromVideoFile(with: asset)
MLog("video degrees : \(degrees)")
do {
self.reader = try AVAssetReader(asset: self.asset)
} catch {
completionHandler(false)
return
}
do {
self.writer = try AVAssetWriter(outputURL: outputURL, fileType: .mp4)
} catch {
completionHandler(false)
return
}
let videoTracks = asset.tracks(withMediaType: .video)
if !videoTracks.isEmpty {
let videoOutputSettings: [String: Any] = [
kCVPixelBufferPixelFormatTypeKey as String: NSNumber(value: kCVPixelFormatType_422YpCbCr8),
kCVPixelBufferIOSurfacePropertiesKey as String: NSDictionary()
]
videoOutput = AVAssetReaderVideoCompositionOutput(videoTracks: videoTracks, videoSettings: videoOutputSettings)
videoOutput.alwaysCopiesSampleData = false
videoOutput.videoComposition = getVideoComposition(videoAsset: asset)
if let reader = self.reader, reader.canAdd(self.videoOutput) {
reader.add(self.videoOutput)
}
self.videoInput = AVAssetWriterInput(mediaType: .video, outputSettings: videoCompressSettings)
if let videoInput = self.videoInput, self.writer?.canAdd(videoInput) ?? false {
self.writer?.add(videoInput)
}
}
let audioTracks = asset.tracks(withMediaType: .audio)
if !audioTracks.isEmpty {
self.audioOutput = AVAssetReaderAudioMixOutput(audioTracks: audioTracks, audioSettings: nil)
self.audioOutput.alwaysCopiesSampleData = false
if let reader = self.reader, reader.canAdd(self.audioOutput) {
reader.add(self.audioOutput)
}
self.audioInput = AVAssetWriterInput(mediaType: .audio, outputSettings: audioCompressSettings)
if let audioInput = self.audioInput, self.writer?.canAdd(audioInput) ?? false {
self.writer?.add(audioInput)
}
}
writer?.startWriting()
reader?.startReading()
writer?.startSession(atSourceTime: CMTime.zero)
let group = DispatchGroup()
let videoQueue = DispatchQueue(label: "videoQueue")
let audioQueue = DispatchQueue(label: "audioQueue")
group.enter()
videoInput.requestMediaDataWhenReady(on: videoQueue) {
var isCompleted = false
while self.videoInput.isReadyForMoreMediaData && !isCompleted {
if let sampleBuffer = self.videoOutput.copyNextSampleBuffer() {
self.videoInput.append(sampleBuffer)
} else {
isCompleted = true
self.videoInput.markAsFinished()
group.leave()
}
}
}
group.enter()
audioInput.requestMediaDataWhenReady(on: audioQueue) {
var isCompleted = false
while (self.audioInput.isReadyForMoreMediaData && !isCompleted) {
if let sampleBuffer = self.audioOutput.copyNextSampleBuffer() {
let success = self.audioInput.append(sampleBuffer)
isCompleted = !success
} else {
isCompleted = true
}
}
if isCompleted {
self.audioInput.markAsFinished()
group.leave()
}
}
group.notify(queue: DispatchQueue.main) {
if self.reader?.status == .reading {
self.reader?.cancelReading()
}
switch self.writer?.status {
case .writing, .completed:
self.writer?.finishWriting(completionHandler: {
MLog("Compression success")
completionHandler(true)
})
default:
MLog("Compression failure")
completionHandler(false)
}
}
}
private func getVideoComposition(videoAsset: AVAsset) -> AVMutableVideoComposition {
let videoComposition = AVMutableVideoComposition()
var translateToCenter = CGAffineTransform()
var mixedTransform = CGAffineTransform()
videoComposition.frameDuration = CMTimeMake(value: 1, timescale: videoAsset.duration.timescale)
let videoTrack = videoAsset.tracks(withMediaType: .video).first!
let roateInstruction = AVMutableVideoCompositionInstruction()
roateInstruction.timeRange = CMTimeRangeMake(start: .zero, duration: videoAsset.duration)
let roateLayerInstruction = AVMutableVideoCompositionLayerInstruction(assetTrack: videoTrack)
if degrees == 90 {
// 顺时针旋转90°
translateToCenter = CGAffineTransform(translationX: videoTrack.naturalSize.height, y: 0.0)
mixedTransform = translateToCenter.rotated(by: .pi / 2)
videoComposition.renderSize = CGSize(width: videoTrack.naturalSize.height, height: videoTrack.naturalSize.width)
roateLayerInstruction.setTransform(mixedTransform, at: .zero)
} else if degrees == 180 {
// 顺时针旋转180°
translateToCenter = CGAffineTransform(translationX: videoTrack.naturalSize.width, y: videoTrack.naturalSize.height)
mixedTransform = translateToCenter.rotated(by: .pi)
videoComposition.renderSize = CGSize(width: videoTrack.naturalSize.width, height: videoTrack.naturalSize.height)
roateLayerInstruction.setTransform(mixedTransform, at: .zero)
} else if degrees == 270 {
// 顺时针旋转270°
translateToCenter = CGAffineTransform(translationX: 0.0, y: videoTrack.naturalSize.width)
mixedTransform = translateToCenter.rotated(by: .pi / 2 * 3.0)
videoComposition.renderSize = CGSize(width: videoTrack.naturalSize.height, height: videoTrack.naturalSize.width)
roateLayerInstruction.setTransform(mixedTransform, at: .zero)
} else {
videoComposition.renderSize = CGSize(width: videoTrack.naturalSize.width, height: videoTrack.naturalSize.height)
}
roateInstruction.layerInstructions = [roateLayerInstruction]
videoComposition.instructions = [roateInstruction]
return videoComposition
}
private func degressFromVideoFile(with asset: AVAsset) -> Int {
var degrees = 0
let tracks = asset.tracks(withMediaType: .video)
if let videoTrack = tracks.first {
let t = videoTrack.preferredTransform
if t.a == 0 && t.b == 1.0 && t.c == -1.0 && t.d == 0 {
// Portrait
degrees = 90
} else if t.a == 0 && t.b == -1.0 && t.c == 1.0 && t.d == 0 {
// PortraitUpsideDown
degrees = 270
} else if t.a == 1.0 && t.b == 0 && t.c == 0 && t.d == 1.0 {
// LandscapeRight
degrees = 0
} else if t.a == -1.0 && t.b == 0 && t.c == 0 && t.d == -1.0 {
// LandscapeLeft
degrees = 180
}
}
return degrees
}
deinit {
MLog("VideoCompressHelper deinit")
}
}
使用
let options = PHVideoRequestOptions()
options.version = .current
PHImageManager.default().requestAVAsset(forVideo: selectedAssets.first!, options: options) { asset, audioMin, info in
if let urlAsset = asset as? AVURLAsset {
let naturalSize = urlAsset.tracks(withMediaType: .video)[0].naturalSize
MLog("original (Width, Height) = \(naturalSize)")
let size = try? urlAsset.url.resourceValues(forKeys: [.fileSizeKey])
let originalFileSize = Double(size?.fileSize ?? 0) / 1024 / 1024
MLog("originalFileSize : \(originalFileSize) MB")
let sourceURL = urlAsset.url
let fileName = "\(Int(Date().timeIntervalSince1970)).mp4"
let outputURL = URL(fileURLWithPath: NSTemporaryDirectory() + "\(fileName)")
MLog("sourceURL : \(sourceURL.absoluteString)")
MLog("outputURL : \(outputURL.absoluteString)")
HUDTool.show()
VideoCompressHelper().compressVideo(sourceURL: sourceURL, outputURL: outputURL) { isSuccess in
HUDTool.dismiss()
if isSuccess {
HUDTool.showMessage("Video compression complete")
} else {
HUDTool.showMessage("Video compression failure")
}
}
}
}
网友评论