我的应用程序首先录制视频，然后在添加一些效果后使用 AVExportSession 导出输出。

首先，问题是视频录制期间的视频引力问题，通过将 AVCaptureVideoPreviewLayer 中的 videoGravity 属性更改为 AVLayerVideoGravityResizeAspectFill 解决了这个问题。

其次，问题在于显示录制的视频，解决方法是将 AVPlayerLayer 中的 VideoGravity 属性更改为 AVLayerVideoGravityResizeAspectFill

但是，现在的问题是，当我想在使用 AVExportSession 添加一些效果后导出视频时，又出现了一些视频引力问题。即使更改 CALayer 中的 contentsGravity 属性也不会影响输出。我应该提到这个问题在 iPad 中很明显。

这是我想在添加一些效果之前显示视频时的图像:

如您所见，我的指尖位于屏幕顶部(因为我已经解决了应用内图层的重力问题)

但在导出并保存到图库后，我看到的是这样的:

我知道问题出在重力上，但我不知道该如何解决。我不知道在录制时是否应该对视频进行任何更改或在导出时更改以下代码:

    let composition = AVMutableComposition()
    let asset = AVURLAsset(url: videoUrl, options: nil)

    let tracks =  asset.tracks(withMediaType : AVMediaTypeVideo)
    let videoTrack:AVAssetTrack = tracks[0] as AVAssetTrack
    let timerange = CMTimeRangeMake(kCMTimeZero, asset.duration)

    let viewSize = parentView.bounds.size
    let trackSize = videoTrack.naturalSize

    let compositionVideoTrack:AVMutableCompositionTrack = composition.addMutableTrack(withMediaType: AVMediaTypeVideo, preferredTrackID: CMPersistentTrackID())

    do {
        try compositionVideoTrack.insertTimeRange(timerange, of: videoTrack, at: kCMTimeZero)
    } catch {
        print(error)
    }

    let compositionAudioTrack:AVMutableCompositionTrack = composition.addMutableTrack(withMediaType: AVMediaTypeAudio, preferredTrackID: CMPersistentTrackID())

    for audioTrack in asset.tracks(withMediaType: AVMediaTypeAudio) {
        do {
            try compositionAudioTrack.insertTimeRange(audioTrack.timeRange, of: audioTrack, at: kCMTimeZero)
        } catch {
            print(error)
        }
    }

    let videolayer = CALayer()
    videolayer.frame.size = viewSize
    videolayer.contentsGravity = kCAGravityResizeAspectFill

    let parentlayer = CALayer()
    parentlayer.frame.size = viewSize
    parentlayer.contentsGravity = kCAGravityResizeAspectFill

    parentlayer.addSublayer(videolayer)

    let layercomposition = AVMutableVideoComposition()
    layercomposition.frameDuration = CMTimeMake(1, 30)
    layercomposition.renderSize = viewSize
    layercomposition.animationTool = AVVideoCompositionCoreAnimationTool(postProcessingAsVideoLayer: videolayer, in: parentlayer)

    let instruction = AVMutableVideoCompositionInstruction()

    instruction.timeRange = CMTimeRangeMake(kCMTimeZero, asset.duration)

    let videotrack = composition.tracks(withMediaType: AVMediaTypeVideo)[0] as AVAssetTrack
    let layerinstruction = AVMutableVideoCompositionLayerInstruction(assetTrack: videotrack)

    let trackTransform = videoTrack.preferredTransform
    let xScale = viewSize.height / trackSize.width
    let yScale = viewSize.width / trackSize.height

    var exportTransform : CGAffineTransform!
    if (getVideoOrientation(transform: videoTrack.preferredTransform).1 == .up) {
        exportTransform = videoTrack.preferredTransform.translatedBy(x: trackTransform.ty * -1 , y: 0).scaledBy(x: xScale , y: yScale)
    } else {
        exportTransform = CGAffineTransform.init(translationX: viewSize.width, y: 0).rotated(by: .pi/2).scaledBy(x: xScale, y: yScale)
    }

    layerinstruction.setTransform(exportTransform, at: kCMTimeZero)

    instruction.layerInstructions = [layerinstruction]
    layercomposition.instructions = [instruction]

    let filePath = FileHelper.getVideoTimeStampName()
    let exportedUrl = URL(fileURLWithPath: filePath)

    guard let assetExport = AVAssetExportSession(asset: composition, presetName:AVAssetExportPresetHighestQuality) else {delegate?.exportFinished(status: .failed, outputUrl: exportedUrl); return}

    assetExport.videoComposition = layercomposition
    assetExport.outputFileType = AVFileTypeMPEG4
    assetExport.outputURL = exportedUrl
    assetExport.exportAsynchronously(completionHandler: {
        switch assetExport.status {
        case .completed:
            print("video exported successfully")
            self.delegate?.exportFinished(status: .completed, outputUrl: exportedUrl)
            break
        case .failed:
            self.delegate?.exportFinished(status: .failed, outputUrl: exportedUrl)
            print("exporting video failed: \(String(describing: assetExport.error))")
            break
        default :
            print("the video export status is \(assetExport.status)")
            self.delegate?.exportFinished(status: assetExport.status, outputUrl: exportedUrl)
            break
        }
    })

如果有人能提供帮助，我将不胜感激。

最佳答案

如果您正在使用 AVLayerVideoGravityResizeAspectFill，视频捕获屏幕将自行调整为 CALayer。所以真正发生的是相机实际上正在捕获您提供的第二张图像。您可以通过以下步骤解决此问题:

1. 获取图像作为 UIImage
2. 使用与您使用的 CALayer 相同的尺寸裁剪图像
3. 将裁剪后的图片上传到服务器，展示给用户等。

要裁剪图像，您可以使用它:

extension UIImage {
    func crop(to:CGSize) -> UIImage {
            guard let cgimage = self.cgImage else { return self }

            let contextImage: UIImage = UIImage(cgImage: cgimage)

            let contextSize: CGSize = contextImage.size

            //Set to square
            var posX: CGFloat = 0.0
            var posY: CGFloat = 0.0
            let cropAspect: CGFloat = to.width / to.height

            var cropWidth: CGFloat = to.width
            var cropHeight: CGFloat = to.height

            if to.width > to.height { //Landscape
                cropWidth = contextSize.width
                cropHeight = contextSize.width / cropAspect
                posY = (contextSize.height - cropHeight) / 2
            } else if to.width < to.height { //Portrait
                cropHeight = contextSize.height
                cropWidth = contextSize.height * cropAspect
                posX = (contextSize.width - cropWidth) / 2
            } else { //Square
                if contextSize.width >= contextSize.height { //Square on landscape (or square)
                    cropHeight = contextSize.height
                    cropWidth = contextSize.height * cropAspect
                    posX = (contextSize.width - cropWidth) / 2
                }else{ //Square on portrait
                    cropWidth = contextSize.width
                    cropHeight = contextSize.width / cropAspect
                    posY = (contextSize.height - cropHeight) / 2
                }
            }

            let rect: CGRect = CGRect(x: posX, y: posY, width: cropWidth, height: cropHeight)
            // Create bitmap image from context using the rect
            let imageRef: CGImage = contextImage.cgImage!.cropping(to: rect)!

            // Create a new image based on the imageRef and rotate back to the original orientation
            let cropped: UIImage = UIImage(cgImage: imageRef, scale: self.scale, orientation: self.imageOrientation)

            UIGraphicsBeginImageContextWithOptions(to, true, self.scale)
            cropped.draw(in: CGRect(x: 0, y: 0, width: to.width, height: to.height))
            let resized = UIGraphicsGetImageFromCurrentImageContext()
            UIGraphicsEndImageContext()

            return resized!
        }
}

关于ios - AVExportSession 中 CALayer 中的视频重力，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/44471040/