12

是否可以使用 iOS 硬件加速的 h.264 解码 API 解码本地（非流式传输）视频文件，然后在其上组合其他对象，并且是否受支持？

我想制作一个涉及在视频前面绘制图形对象的应用程序，并使用播放计时器将我在上面绘制的内容与视频上正在播放的内容同步。然后，根据用户的操作，更改我在顶部绘制的内容（但不是视频）

来自 Android 的 DirectX、OpenGL 和 OpenGL ES，我正在描绘类似将视频渲染为纹理，并使用该纹理绘制全屏四边形，然后使用其他精灵来绘制其余对象；或者可能在渲染器之前编写一个中间过滤器，这样我就可以操纵各个输出帧并绘制我的东西；或者可能在视频顶部绘制到 2D 图层。

似乎 AV Foundation 或 Core Media可以帮助我做我正在做的事情，但在我深入研究细节之前，我想知道是否有可能做我想做的事，我的主要工作是什么解决问题的途径。

请不要回答“这对你来说太高级了，先试试你好世界”的答案。在我自己研究细节之前，我知道我的东西，只是想知道我想做的事情是否可行（最重要的是，得到支持，所以应用程序最终不会被拒绝）。

编辑：

我不熟悉 iOS 开发，但专业为 Android 做 DirectX、OpenGL 和 OpenGL ES。我正在考虑制作我目前拥有的 Android 应用程序的 iOS 版本，我只想知道这是否可能。如果是这样，我有足够的时间从头开始 iOS 开发，直到做我想做的事情。如果不可能，那么我现在就不会花时间研究整个平台。

因此，这是一个技术可行性问题。我不是在请求代码。我正在寻找“是的，你可以这样做。只需使用 A 和 B，使用 C 渲染到 D 并用 E 绘制你的东西”或“不，你不能。硬件加速解码是不适用于第三方应用程序”（这是一位朋友告诉我的）。就这样，我就上路了。

我已阅读ios 技术概述第 32 页中的视频技术概述。它几乎说我可以使用 Media Player 来实现最简单的播放功能（不是我想要的），UIKit 用于嵌入视频，对嵌入有更多的控制，但不能控制实际的播放（不是我想要的）我正在寻找），AVFoundation 可以更好地控制播放（可能是我需要的，但是我在网上找到的大多数资源都在谈论如何使用相机），或者 Core Media 可以对视频进行完全的低级控制（可能是我需要，但文档记录极差，甚至比 AVFoundation 更缺乏播放资源）。

我担心我可能会在接下来的六个月里全职学习 iOS 编程，结果发现相关 API 对第三方开发人员不可用，而我想做的事情是无法接受 iTunes 商店部署。这是我的朋友告诉我的，但我似乎在应用程序开发指南中找不到任何相关内容。所以，我来这里是想问问在这方面有更多经验的人，我想做的事情是否可行。不再。

我认为这是一个有效的高级问题，可能会被误解为 I-didn't-do-my-homework-plz-give-me-teh-codez 问题。如果我在这里的判断是错误的，请随时删除或否决这个问题，让您心生鄙视。

4

1 回答 1

25

是的，您可以这样做，而且我认为您的问题足够具体，可以归入此处。你不是唯一一个想要这样做的人，而且确实需要一点点挖掘才能弄清楚你能做什么和不能做什么。

AV Foundation 允许您使用 AVAssetReader 对 H.264 视频进行硬件加速解码，此时您将收到 BGRA 格式的原始解码视频帧。这些可以使用glTexImage2D()iOS 5.0 中的任一或更高效的纹理缓存上传到纹理。从那里，您可以处理显示或从 OpenGL ES 检索帧，并使用 AVAssetWriter 对结果执行硬件加速的 H.264 编码。所有这些都使用公共 API，因此您永远不会接近会导致 App Store 拒绝的东西。

但是，您不必滚动自己的实现。我的 BSD 许可开源框架GPUImage封装了这些操作并为您处理所有这些。您为输入的 H.264 电影创建一个 GPUImageMovie 实例，在其上附加过滤器（例如叠加混合或色度键操作），然后将这些过滤器附加到 GPUImageView 进行显示和/或附加到 GPUImageMovieWriter 以重新编码 H. 264 电影来自处理过的视频。

我目前遇到的一个问题是我不遵守视频中的时间戳进行播放，因此帧的处理速度与从电影中解码的速度一样快。对于视频的过滤和重新编码，这不是问题，因为时间戳会传递到记录器，但对于直接显示到屏幕，这意味着视频可以加速多达 2-4 倍. 我欢迎任何可以让您将播放速率与实际视频时间戳同步的贡献。

我目前可以在 iPhone 4 上以超过 30 FPS 的速度播放、过滤和重新编码 640x480 视频，在 ~20-25 FPS 上播放 720p 视频，而 iPhone 4S 能够以远高于 30 FPS 的速度进行 1080p 过滤和编码. 一些更昂贵的过滤器会对 GPU 造成负担并稍微减慢速度，但大多数过滤器都在这些帧率范围内运行。

如果你愿意，你可以检查 GPUImageMovie 类，看看它是如何上传到 OpenGL ES 的，但相关代码如下：

- (void)startProcessing;
{
    NSDictionary *inputOptions = [NSDictionary dictionaryWithObject:[NSNumber numberWithBool:YES] forKey:AVURLAssetPreferPreciseDurationAndTimingKey];
    AVURLAsset *inputAsset = [[AVURLAsset alloc] initWithURL:self.url options:inputOptions];

    [inputAsset loadValuesAsynchronouslyForKeys:[NSArray arrayWithObject:@"tracks"] completionHandler: ^{
        NSError *error = nil;
        AVKeyValueStatus tracksStatus = [inputAsset statusOfValueForKey:@"tracks" error:&error];
        if (!tracksStatus == AVKeyValueStatusLoaded) 
        {
            return;
        }
        reader = [AVAssetReader assetReaderWithAsset:inputAsset error:&error];

        NSMutableDictionary *outputSettings = [NSMutableDictionary dictionary];
        [outputSettings setObject: [NSNumber numberWithInt:kCVPixelFormatType_32BGRA]  forKey: (NSString*)kCVPixelBufferPixelFormatTypeKey];
        // Maybe set alwaysCopiesSampleData to NO on iOS 5.0 for faster video decoding
        AVAssetReaderTrackOutput *readerVideoTrackOutput = [AVAssetReaderTrackOutput assetReaderTrackOutputWithTrack:[[inputAsset tracksWithMediaType:AVMediaTypeVideo] objectAtIndex:0] outputSettings:outputSettings];
        [reader addOutput:readerVideoTrackOutput];

        NSArray *audioTracks = [inputAsset tracksWithMediaType:AVMediaTypeAudio];
        BOOL shouldRecordAudioTrack = (([audioTracks count] > 0) && (self.audioEncodingTarget != nil) );
        AVAssetReaderTrackOutput *readerAudioTrackOutput = nil;

        if (shouldRecordAudioTrack)
        {            
            audioEncodingIsFinished = NO;

            // This might need to be extended to handle movies with more than one audio track
            AVAssetTrack* audioTrack = [audioTracks objectAtIndex:0];
            readerAudioTrackOutput = [AVAssetReaderTrackOutput assetReaderTrackOutputWithTrack:audioTrack outputSettings:nil];
            [reader addOutput:readerAudioTrackOutput];
        }

        if ([reader startReading] == NO) 
        {
            NSLog(@"Error reading from file at URL: %@", self.url);
            return;
        }

        if (synchronizedMovieWriter != nil)
        {
            __unsafe_unretained GPUImageMovie *weakSelf = self;

            [synchronizedMovieWriter setVideoInputReadyCallback:^{
                [weakSelf readNextVideoFrameFromOutput:readerVideoTrackOutput];
            }];

            [synchronizedMovieWriter setAudioInputReadyCallback:^{
                [weakSelf readNextAudioSampleFromOutput:readerAudioTrackOutput];
            }];

            [synchronizedMovieWriter enableSynchronizationCallbacks];
        }
        else
        {
            while (reader.status == AVAssetReaderStatusReading) 
            {
                [self readNextVideoFrameFromOutput:readerVideoTrackOutput];

                if ( (shouldRecordAudioTrack) && (!audioEncodingIsFinished) )
                {
                    [self readNextAudioSampleFromOutput:readerAudioTrackOutput];
                }

            }            

            if (reader.status == AVAssetWriterStatusCompleted) {
                [self endProcessing];
            }
        }
    }];
}

- (void)readNextVideoFrameFromOutput:(AVAssetReaderTrackOutput *)readerVideoTrackOutput;
{
    if (reader.status == AVAssetReaderStatusReading)
    {
        CMSampleBufferRef sampleBufferRef = [readerVideoTrackOutput copyNextSampleBuffer];
        if (sampleBufferRef) 
        {
            runOnMainQueueWithoutDeadlocking(^{
                [self processMovieFrame:sampleBufferRef]; 
            });

            CMSampleBufferInvalidate(sampleBufferRef);
            CFRelease(sampleBufferRef);
        }
        else
        {
            videoEncodingIsFinished = YES;
            [self endProcessing];
        }
    }
    else if (synchronizedMovieWriter != nil)
    {
        if (reader.status == AVAssetWriterStatusCompleted) 
        {
            [self endProcessing];
        }
    }
}

- (void)processMovieFrame:(CMSampleBufferRef)movieSampleBuffer; 
{
    CMTime currentSampleTime = CMSampleBufferGetOutputPresentationTimeStamp(movieSampleBuffer);
    CVImageBufferRef movieFrame = CMSampleBufferGetImageBuffer(movieSampleBuffer);

    int bufferHeight = CVPixelBufferGetHeight(movieFrame);
    int bufferWidth = CVPixelBufferGetWidth(movieFrame);

    CFAbsoluteTime startTime = CFAbsoluteTimeGetCurrent();

    if ([GPUImageOpenGLESContext supportsFastTextureUpload])
    {
        CVPixelBufferLockBaseAddress(movieFrame, 0);

        [GPUImageOpenGLESContext useImageProcessingContext];
        CVOpenGLESTextureRef texture = NULL;
        CVReturn err = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault, coreVideoTextureCache, movieFrame, NULL, GL_TEXTURE_2D, GL_RGBA, bufferWidth, bufferHeight, GL_BGRA, GL_UNSIGNED_BYTE, 0, &texture);

        if (!texture || err) {
            NSLog(@"Movie CVOpenGLESTextureCacheCreateTextureFromImage failed (error: %d)", err);  
            return;
        }

        outputTexture = CVOpenGLESTextureGetName(texture);
        //        glBindTexture(CVOpenGLESTextureGetTarget(texture), outputTexture);
        glBindTexture(GL_TEXTURE_2D, outputTexture);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

        for (id<GPUImageInput> currentTarget in targets)
        {            
            NSInteger indexOfObject = [targets indexOfObject:currentTarget];
            NSInteger targetTextureIndex = [[targetTextureIndices objectAtIndex:indexOfObject] integerValue];

            [currentTarget setInputSize:CGSizeMake(bufferWidth, bufferHeight) atIndex:targetTextureIndex];
            [currentTarget setInputTexture:outputTexture atIndex:targetTextureIndex];

            [currentTarget newFrameReadyAtTime:currentSampleTime];
        }

        CVPixelBufferUnlockBaseAddress(movieFrame, 0);

        // Flush the CVOpenGLESTexture cache and release the texture
        CVOpenGLESTextureCacheFlush(coreVideoTextureCache, 0);
        CFRelease(texture);
        outputTexture = 0;        
    }
    else
    {
        // Upload to texture
        CVPixelBufferLockBaseAddress(movieFrame, 0);

        glBindTexture(GL_TEXTURE_2D, outputTexture);
        // Using BGRA extension to pull in video frame data directly
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bufferWidth, bufferHeight, 0, GL_BGRA, GL_UNSIGNED_BYTE, CVPixelBufferGetBaseAddress(movieFrame));

        CGSize currentSize = CGSizeMake(bufferWidth, bufferHeight);
        for (id<GPUImageInput> currentTarget in targets)
        {
            NSInteger indexOfObject = [targets indexOfObject:currentTarget];
            NSInteger targetTextureIndex = [[targetTextureIndices objectAtIndex:indexOfObject] integerValue];

            [currentTarget setInputSize:currentSize atIndex:targetTextureIndex];
            [currentTarget newFrameReadyAtTime:currentSampleTime];
        }
        CVPixelBufferUnlockBaseAddress(movieFrame, 0);
    }

    if (_runBenchmark)
    {
        CFAbsoluteTime currentFrameTime = (CFAbsoluteTimeGetCurrent() - startTime);
        NSLog(@"Current frame time : %f ms", 1000.0 * currentFrameTime);
    }
}
于 2012-05-18T16:30:48.877 回答