Question

我创建了一个流程，用于在我正在构建的应用程序中从照片和图像集合中生成视频“幻灯片”。该过程运行正常，但是如果视频中包含的任何照片重复100到150帧不变，则会产生不必要的大文件。我已经包含了我在AVFoundation中可以找到的任何压缩，它主要应用帧内技术并试图在AVFoundation中找到有关帧间压缩的更多信息。不幸的是，我只能找到一些我能找到的参考资料，而且没有任何东西让我能够使用它。

我希望有人能引导我朝着正确的方向前进。视频生成器的代码包含在下面。我没有包含用于获取和准备单个帧的代码（以下称为self.getFrame（）），因为它似乎工作正常并且变得非常复杂，因为它处理照片，视频，添加标题帧和执行淡入淡出过渡。对于重复的帧，它返回一个带有帧图像的结构和一个包含输出帧数的计数器。

        // Create a new AVAssetWriter Instance that will build the video

        assetWriter = createAssetWriter(path: filePathNew, size: videoSize!)
        guard assetWriter != nil else
        {
            print("Error converting images to video: AVAssetWriter not created.")
            inProcess = false
            return
        }

        let writerInput = assetWriter!.inputs.filter{ $0.mediaType == AVMediaTypeVideo }.first!

        let sourceBufferAttributes : [String : AnyObject] = [
            kCVPixelBufferPixelFormatTypeKey as String : Int(kCVPixelFormatType_32ARGB) as AnyObject,
            kCVPixelBufferWidthKey as String : videoSize!.width as AnyObject,
            kCVPixelBufferHeightKey as String : videoSize!.height as AnyObject,
            AVVideoMaxKeyFrameIntervalKey as String : 50 as AnyObject,
            AVVideoCompressionPropertiesKey as String : [
                AVVideoAverageBitRateKey: 725000,
                AVVideoProfileLevelKey: AVVideoProfileLevelH264Baseline30,
                ] as AnyObject
        ]

        let pixelBufferAdaptor = AVAssetWriterInputPixelBufferAdaptor(assetWriterInput: writerInput, sourcePixelBufferAttributes: sourceBufferAttributes)

        // Start the writing session

        assetWriter!.startWriting()

        assetWriter!.startSession(atSourceTime: kCMTimeZero)

        if (pixelBufferAdaptor.pixelBufferPool == nil) {
            print("Error converting images to video: pixelBufferPool nil after starting session")
            inProcess = false
            return
        }

        // -- Create queue for <requestMediaDataWhenReadyOnQueue>

        let mediaQueue = DispatchQueue(label: "mediaInputQueue")

        // Initialize run time values

        var presentationTime = kCMTimeZero
        var done = false
        var nextFrame: FramePack?                // The FramePack struct has the frame to output, noDisplays - the number of times that it will be output
                                                 // and an isLast flag that is true when it's the final frame

        writerInput.requestMediaDataWhenReady(on: mediaQueue, using: { () -> Void in    // Keeps invoking the block to get input until call markAsFinished

            nextFrame = self.getFrame()          // Get the next frame to be added to the output with its associated values
            let imageCGOut = nextFrame!.frame    // The frame to output
            if nextFrame!.isLast { done = true } // Identifies the last frame so can drop through to markAsFinished() below

            var frames = 0                       // Counts how often we've output this frame
            var waitCount = 0                    // Used to avoid an infinite loop if there's trouble with writer.Input

            while (frames < nextFrame!.noDisplays) && (waitCount < 1000000)  // Need to wait for writerInput to be ready - count deals with potential hung writer
            {
                waitCount += 1
                if waitCount == 1000000     // Have seen it go into 100s of thousands and succeed
                {
                    print("Exceeded waitCount limit while attempting to output slideshow frame.")
                    self.inProcess = false
                    return
                }

                if (writerInput.isReadyForMoreMediaData)
                {
                    waitCount = 0
                    frames += 1

                    autoreleasepool
                        {
                            if  let pixelBufferPool = pixelBufferAdaptor.pixelBufferPool
                            {
                                let pixelBufferPointer = UnsafeMutablePointer<CVPixelBuffer?>.allocate(capacity: 1)
                                let status: CVReturn = CVPixelBufferPoolCreatePixelBuffer(
                                    kCFAllocatorDefault,
                                    pixelBufferPool,
                                    pixelBufferPointer
                                )

                                if let pixelBuffer = pixelBufferPointer.pointee, status == 0
                                {
                                    CVPixelBufferLockBaseAddress(pixelBuffer, CVPixelBufferLockFlags(rawValue: CVOptionFlags(0)))
                                    let pixelData = CVPixelBufferGetBaseAddress(pixelBuffer)
                                    let rgbColorSpace = CGColorSpaceCreateDeviceRGB()

                                    // Set up a context for rendering using the PixelBuffer allocated above as the target

                                    let context = CGContext(
                                        data: pixelData,
                                        width: Int(self.videoWidth),
                                        height: Int(self.videoHeight),
                                        bitsPerComponent: 8,
                                        bytesPerRow: CVPixelBufferGetBytesPerRow(pixelBuffer),
                                        space: rgbColorSpace,
                                        bitmapInfo: CGImageAlphaInfo.premultipliedFirst.rawValue
                                    )

                                    // Draw the image into the PixelBuffer used for the context

                                    context?.draw(imageCGOut, in: CGRect(x: 0.0,y: 0.0,width: 1280, height: 720))

                                    // Append the image (frame) from the context pixelBuffer onto the video file

                                    _ = pixelBufferAdaptor.append(pixelBuffer, withPresentationTime: presentationTime)
                                    presentationTime = presentationTime + CMTimeMake(1, videoFPS)

                                    // We're done with the PixelBuffer, so unlock it

                                    CVPixelBufferUnlockBaseAddress(pixelBuffer, CVPixelBufferLockFlags(rawValue: CVOptionFlags(0)))
                                }

                                pixelBufferPointer.deinitialize()
                                pixelBufferPointer.deallocate(capacity: 1)

                            } else {
                                NSLog("Error: Failed to allocate pixel buffer from pool")
                            }
                    }
                }
            }

提前感谢任何建议。

Answer 1

看起来像你

为您的视频添加一堆冗余帧
在误解的情况下劳作：视频文件必须具有高的恒定帧率，例如： 30fps的。

例如，如果您在15秒的时间内显示3张图片的幻灯片，则只需输出3张图片，展示时间戳为0秒，5秒，10秒和assetWriter.endSession(atSourceTime:）15s，而不是15s * 30 FPS = 450帧。

换句话说，您的帧速率太高了 - 为了获得最佳的帧间压缩效果，可以将帧速率降低到所需的最小帧数，并且一切都很好< SUP> *

^{* _{我看到一些视频服务/玩家因异常低的帧率而窒息
所以你可能需要一个最小帧速率和一些冗余帧，例如1帧/ 5秒，ymmv}}

在AVFoundation中进行帧间视频压缩的方法

1 个答案: