概述

GPUImage是一個著名的圖像處理開源庫，它讓你能夠在圖片、視頻、相機上使用GPU加速的濾鏡和其它特效。與CoreImage框架相比，可以根據GPUImage提供的接口，使用自定義的濾鏡。項目地址：https://github.com/BradLarson/GPUImage
這篇文章主要是閱讀GPUImage框架中的 GPUImageFramebuffer、GPUImageFramebufferCache 兩個重要類的源碼。這兩個是GPUImage中處理幀緩存相關的類，是各種濾鏡的基礎。以下是源碼內容：
GPUImageFramebuffer
GPUImageFramebufferCache

準備

• 位圖創建。通過幀緩存生成圖像的時候，GPUImage使用CGImage相關的API生成相關的位圖對象。以下是該API的相關說明：

// CGImageRef這個結構用來創建像素位圖，可以通過操作存儲的像素位來編輯圖片
typedef struct CGImage *CGImageRef;

/**
 通過CGImageCreate方法，我們可以創建出一個CGImageRef類型的對象

 @param width 圖片寬度像素
 @param height 圖片高度像素
 @param bitsPerComponent 每個顏色的比特數，例如在rgba32模式下為8
 @param bitsPerPixel 每個像素的總比特數
 @param bytesPerRow 每一行占用的字節數，注意這里的單位是字節
 @param space 顏色空間模式
 @param bitmapInfo 位圖像素布局枚舉
 @param provider 數據源提供者
 @param decode 解碼渲染數組
 @param shouldInterpolate 是否抗鋸齒
 @param intent 圖片相關參數
 @return 位圖
 */
 CGImageRef CGImageCreate(size_t width,
                          size_t height,
                          size_t bitsPerComponent, 
                          size_t bitsPerPixel, 
                          size_t bytesPerRow,
                          CGColorSpaceRef space, 
                          CGBitmapInfo bitmapInfo,
                          CGDataProviderRef provider,
                          const CGFloat *decode, 
                          bool shouldInterpolate,
                          CGColorRenderingIntent intent)

GPUImageFramebuffer

這個類不是很復雜，它主要是涉及幀緩存和幀緩存附件等相關OpenGLES的知識，參見
OpenGL ES入門12-幀緩存 。GPUImageFramebuffer 管理者幀緩存和紋理附件。其中紋理附件涉及到了相關的紋理選項。因此，它提供的屬性也是和幀緩存、紋理附件、紋理選項等相關。

• 屬性

// 幀緩存大小
@property(readonly) CGSize size;
// 紋理選項
@property(readonly) GPUTextureOptions textureOptions;
// 紋理緩存
@property(readonly) GLuint texture;
// 是否僅有紋理沒有幀緩存
@property(readonly) BOOL missingFramebuffer;

• 初始化方法

- (id)initWithSize:(CGSize)framebufferSize;
- (id)initWithSize:(CGSize)framebufferSize textureOptions:(GPUTextureOptions)fboTextureOptions onlyTexture:(BOOL)onlyGenerateTexture;
- (id)initWithSize:(CGSize)framebufferSize overriddenTexture:(GLuint)inputTexture;

- (id)initWithSize:(CGSize)framebufferSize;
{
    // 提供默認紋理選項
    GPUTextureOptions defaultTextureOptions;
    defaultTextureOptions.minFilter = GL_LINEAR;
    defaultTextureOptions.magFilter = GL_LINEAR;
    defaultTextureOptions.wrapS = GL_CLAMP_TO_EDGE;
    defaultTextureOptions.wrapT = GL_CLAMP_TO_EDGE;
    defaultTextureOptions.internalFormat = GL_RGBA;
    defaultTextureOptions.format = GL_BGRA;
    defaultTextureOptions.type = GL_UNSIGNED_BYTE;
    
    // 根據默認紋理選項以及強制生成幀緩存和紋理附件進行相關初始化
    if (!(self = [self initWithSize:framebufferSize textureOptions:defaultTextureOptions onlyTexture:NO]))
    {
        return nil;
    }

    return self;
}

- (id)initWithSize:(CGSize)framebufferSize textureOptions:(GPUTextureOptions)fboTextureOptions onlyTexture:(BOOL)onlyGenerateTexture;
{
    if (!(self = [super init]))
    {
        return nil;
    }
    
    // 紋理選項
    _textureOptions = fboTextureOptions;
    _size = framebufferSize;
    framebufferReferenceCount = 0;
    referenceCountingDisabled = NO;
    // 是否只生成紋理緩存
    _missingFramebuffer = onlyGenerateTexture;
    
    // 如果只生成紋理緩存，則不生成幀緩存
    if (_missingFramebuffer)
    {
        runSynchronouslyOnVideoProcessingQueue(^{
            [GPUImageContext useImageProcessingContext];
            [self generateTexture];
            framebuffer = 0;
        });
    }
    // 既生成紋理緩存又生成幀緩存
    else
    {
        [self generateFramebuffer];
    }
    return self;
}

• 方法列表。方法主要分為四大類：
  第一類：與使用當前幀緩存相關的方法，
  第二類：與 GPUImageFramebuffer 引用計數相關的方法，
  第三類：從幀緩存生成位圖相關的方法，
  第四類：獲取幀緩存原始數據相關的方法。

// Usage
- (void)activateFramebuffer;

// Reference counting
- (void)lock;
- (void)unlock;
- (void)clearAllLocks;
- (void)disableReferenceCounting;
- (void)enableReferenceCounting;

// Image capture
- (CGImageRef)newCGImageFromFramebufferContents;
- (void)restoreRenderTarget;

// Raw data bytes
- (void)lockForReading;
- (void)unlockAfterReading;
- (NSUInteger)bytesPerRow;
- (GLubyte *)byteBuffer;
- (CVPixelBufferRef)pixelBuffer;

• 激活。在使用幀緩存的時候首先要激活（即綁定為當前幀緩存），激活之后才能在當前幀緩存上進行相關操作。

- (void)activateFramebuffer;
{
    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
    // 激活的時候需要設置視口大小
    glViewport(0, 0, (int)_size.width, (int)_size.height);
}

• 引用計數。

開啟引用計數后，每次調用 lock 方法后，引用計數加一。

- (void)lock;
{
    if (referenceCountingDisabled)
    {
        return;
    }
    
    framebufferReferenceCount++;
}

開啟引用計數后，當引用計數小于1的時候，會調用 returnFramebufferToCache 函數把自己放回 GPUImageFramebufferCache 中，便于之后的使用，并不會銷毀幀緩存。銷毀幀緩存是通過 destroyFramebuffer 函數，該函數是私有函數，未在頭文件中公開，在 dealloc 中被調用。

- (void)unlock;
{
    if (referenceCountingDisabled)
    {
        return;
    }

    NSAssert(framebufferReferenceCount > 0, @"Tried to overrelease a framebuffer, did you forget to call -useNextFrameForImageCapture before using -imageFromCurrentFramebuffer?");
    framebufferReferenceCount--;
    if (framebufferReferenceCount < 1)
    {
        [[GPUImageContext sharedFramebufferCache] returnFramebufferToCache:self];
    }
}

清除所有引用計數，以及開啟關閉引用計數如下：

- (void)clearAllLocks;
{
    framebufferReferenceCount = 0;
}

- (void)disableReferenceCounting;
{
    referenceCountingDisabled = YES;
}

- (void)enableReferenceCounting;
{
    referenceCountingDisabled = NO;
}

• 從幀緩存中生成圖片。在讀取圖片數據的時候，根據設備是否支持 CoreVideo 框架，GPUImage 會選擇使用 CVPixelBufferGetBaseAddress 或者 glReadPixels 讀取幀緩存中的數據。最后通過 CGImageCreate，創建 CGImage 對象并返回該對象。

- (CGImageRef)newCGImageFromFramebufferContents;
{
    // a CGImage can only be created from a 'normal' color texture
    NSAssert(self.textureOptions.internalFormat == GL_RGBA, @"For conversion to a CGImage the output texture format for this filter must be GL_RGBA.");
    NSAssert(self.textureOptions.type == GL_UNSIGNED_BYTE, @"For conversion to a CGImage the type of the output texture of this filter must be GL_UNSIGNED_BYTE.");
    
    __block CGImageRef cgImageFromBytes;
    
    // 在VideoProcessingQueue中進行同步處理
    runSynchronouslyOnVideoProcessingQueue(^{
        // 設置OpenGLES上下文
        [GPUImageContext useImageProcessingContext];
        
        // 圖片的總大小 = 幀緩存大小 * 每個像素點字節數
        NSUInteger totalBytesForImage = (int)_size.width * (int)_size.height * 4;
        // It appears that the width of a texture must be padded out to be a multiple of 8 (32 bytes) if reading from it using a texture cache
        
        GLubyte *rawImagePixels;
        
        CGDataProviderRef dataProvider = NULL;
        
        // 判斷是否支持CoreVideo的快速紋理上傳
        if ([GPUImageContext supportsFastTextureUpload])
        {
#if TARGET_IPHONE_SIMULATOR || TARGET_OS_IPHONE
            // 圖像寬度 = 每行圖像數據大小 / 每個像素點字節數
            NSUInteger paddedWidthOfImage = CVPixelBufferGetBytesPerRow(renderTarget) / 4.0;
            
            // 圖像大小 = 圖像寬度 * 高度 * 每個像素點字節數
            NSUInteger paddedBytesForImage = paddedWidthOfImage * (int)_size.height * 4;
            // 等待OpenGL指令執行完成，與glFlush有區別
            glFinish();
            CFRetain(renderTarget); // I need to retain the pixel buffer here and release in the data source callback to prevent its bytes from being prematurely deallocated during a photo write operation
            [self lockForReading];
            rawImagePixels = (GLubyte *)CVPixelBufferGetBaseAddress(renderTarget);
            
            // 創建CGDataProviderRef對象
            dataProvider = CGDataProviderCreateWithData((__bridge_retained void*)self, rawImagePixels, paddedBytesForImage, dataProviderUnlockCallback);
            [[GPUImageContext sharedFramebufferCache] addFramebufferToActiveImageCaptureList:self]; // In case the framebuffer is swapped out on the filter, need to have a strong reference to it somewhere for it to hang on while the image is in existence
#else
#endif
        }
        else
        {
            // 激活幀緩存
            [self activateFramebuffer];
            rawImagePixels = (GLubyte *)malloc(totalBytesForImage);
            
            // 從當前的幀緩存讀取圖片數據
            glReadPixels(0, 0, (int)_size.width, (int)_size.height, GL_RGBA, GL_UNSIGNED_BYTE, rawImagePixels);
            
            // 創建 CGDataProvider
            dataProvider = CGDataProviderCreateWithData(NULL, rawImagePixels, totalBytesForImage, dataProviderReleaseCallback);
            
            // 讀取到數據之后不需要再持有幀緩存
            [self unlock]; // Don't need to keep this around anymore
        }
        
        CGColorSpaceRef defaultRGBColorSpace = CGColorSpaceCreateDeviceRGB();
        
        if ([GPUImageContext supportsFastTextureUpload])
        {
#if TARGET_IPHONE_SIMULATOR || TARGET_OS_IPHONE
            // 創建CGImage對象
            cgImageFromBytes = CGImageCreate((int)_size.width, (int)_size.height, 8, 32, CVPixelBufferGetBytesPerRow(renderTarget), defaultRGBColorSpace, kCGBitmapByteOrder32Little | kCGImageAlphaPremultipliedFirst, dataProvider, NULL, NO, kCGRenderingIntentDefault);
#else
#endif
        }
        else
        {
            // 創建CGImage對象
            cgImageFromBytes = CGImageCreate((int)_size.width, (int)_size.height, 8, 32, 4 * (int)_size.width, defaultRGBColorSpace, kCGBitmapByteOrderDefault | kCGImageAlphaLast, dataProvider, NULL, NO, kCGRenderingIntentDefault);
        }
        
        // Capture image with current device orientation
        // 釋放數據
        CGDataProviderRelease(dataProvider);
        CGColorSpaceRelease(defaultRGBColorSpace);
        
    });
    
    return cgImageFromBytes;
}

• 獲取幀緩存原始數據相關的方法。如果設備支持 CoreVideo框架，獲取紋理數據的相關操作會調用下面的這些方法。詳細見 newCGImageFromFramebufferContents 方法。

- (void)lockForReading
{
#if TARGET_IPHONE_SIMULATOR || TARGET_OS_IPHONE
    if ([GPUImageContext supportsFastTextureUpload])
    {
        if (readLockCount == 0)
        {
            // 在訪問CPU的像素數據之前，必須調用CVPixelBufferLockBaseAddress
            CVPixelBufferLockBaseAddress(renderTarget, 0);
        }
        readLockCount++;
    }
#endif
}

- (void)unlockAfterReading
{
#if TARGET_IPHONE_SIMULATOR || TARGET_OS_IPHONE
    if ([GPUImageContext supportsFastTextureUpload])
    {
        NSAssert(readLockCount > 0, @"Unbalanced call to -[GPUImageFramebuffer unlockAfterReading]");
        readLockCount--;
        if (readLockCount == 0)
        {
            // 訪問結束后，必須調用CVPixelBufferUnlockBaseAddress
            CVPixelBufferUnlockBaseAddress(renderTarget, 0);
        }
    }
#endif
}

- (NSUInteger)bytesPerRow;
{
    if ([GPUImageContext supportsFastTextureUpload])
    {
#if TARGET_IPHONE_SIMULATOR || TARGET_OS_IPHONE
        // 獲取每行數據大小
        return CVPixelBufferGetBytesPerRow(renderTarget);
#else
        return _size.width * 4; // TODO: do more with this on the non-texture-cache side
#endif
    }
    else
    {
        return _size.width * 4;
    }
}

GPUImageFramebufferCache

GPUImageFramebufferCache類核心的職責是管理GPUImageFramebuffer對象。

• 屬性

@interface GPUImageFramebufferCache()
{
//    NSCache *framebufferCache;
    //  緩存字典
    NSMutableDictionary *framebufferCache;
    // 緩存數量字典
    NSMutableDictionary *framebufferTypeCounts;
    // 當前正在使用的GPUImageFramebuffer數組
    NSMutableArray *activeImageCaptureList; // Where framebuffers that may be lost by a filter, but which are still needed for a UIImage, etc., are stored
    id memoryWarningObserver;
    
    // 緩存隊列
    dispatch_queue_t framebufferCacheQueue;
}

• 構造方法。構造方法中主要是初始化各個緩存池，以及創建緩存隊列，以及對系統內存警告進行監聽。

- (id)init;
{
    if (!(self = [super init]))
    {
        return nil;
    }
    
#if TARGET_IPHONE_SIMULATOR || TARGET_OS_IPHONE
    __unsafe_unretained __typeof__ (self) weakSelf = self;
    // 監聽系統內存警告，收到通知，便清理緩存數組。
    memoryWarningObserver = [[NSNotificationCenter defaultCenter] addObserverForName:UIApplicationDidReceiveMemoryWarningNotification object:nil queue:nil usingBlock:^(NSNotification *note) {
        __typeof__ (self) strongSelf = weakSelf;
        if (strongSelf) {
            [strongSelf purgeAllUnassignedFramebuffers];
        }
    }];
#else
#endif

// 初始化緩存池
//    framebufferCache = [[NSCache alloc] init];
    framebufferCache = [[NSMutableDictionary alloc] init];
    framebufferTypeCounts = [[NSMutableDictionary alloc] init];
    activeImageCaptureList = [[NSMutableArray alloc] init];
    framebufferCacheQueue = dispatch_queue_create("com.sunsetlakesoftware.GPUImage.framebufferCacheQueue", GPUImageDefaultQueueAttribute());
    
    return self;
}

• 方法列表。主要涉及到在緩存中查找 GPUImageFramebuffer，將 GPUImageFramebuffer 加入緩存，清空緩存等相關方法。

- (GPUImageFramebuffer *)fetchFramebufferForSize:(CGSize)framebufferSize textureOptions:(GPUTextureOptions)textureOptions onlyTexture:(BOOL)onlyTexture;
- (GPUImageFramebuffer *)fetchFramebufferForSize:(CGSize)framebufferSize onlyTexture:(BOOL)onlyTexture;
- (void)returnFramebufferToCache:(GPUImageFramebuffer *)framebuffer;
- (void)purgeAllUnassignedFramebuffers;
- (void)addFramebufferToActiveImageCaptureList:(GPUImageFramebuffer *)framebuffer;
- (void)removeFramebufferFromActiveImageCaptureList:(GPUImageFramebuffer *)framebuffer;

• 根據framebufferSize、textureOptions和onlyTexture查找GPUImageFramebuffer。如果找不到framebufferCache，會創建新的緩存。這里說的相同類型的 GPUImageFramebuffer 指的是根據 - (NSString *)hashForSize:(CGSize)size textureOptions:(GPUTextureOptions)textureOptions onlyTexture:(BOOL)onlyTexture 得出來的lookupHash相同。

- (GPUImageFramebuffer *)fetchFramebufferForSize:(CGSize)framebufferSize textureOptions:(GPUTextureOptions)textureOptions onlyTexture:(BOOL)onlyTexture;
{
    __block GPUImageFramebuffer *framebufferFromCache = nil;
//    dispatch_sync(framebufferCacheQueue, ^{
    runSynchronouslyOnVideoProcessingQueue(^{
        // 創建查找字符串
        NSString *lookupHash = [self hashForSize:framebufferSize textureOptions:textureOptions onlyTexture:onlyTexture];
        // 獲取GPUImageFramebuffer在緩存中的數量
        NSNumber *numberOfMatchingTexturesInCache = [framebufferTypeCounts objectForKey:lookupHash];
        NSInteger numberOfMatchingTextures = [numberOfMatchingTexturesInCache integerValue];
        
        // 緩存中如果沒有，則創建
        if ([numberOfMatchingTexturesInCache integerValue] < 1)
        {
            // Nothing in the cache, create a new framebuffer to use
            framebufferFromCache = [[GPUImageFramebuffer alloc] initWithSize:framebufferSize textureOptions:textureOptions onlyTexture:onlyTexture];
        }
        else
        {
            // Something found, pull the old framebuffer and decrement the count
            // 緩存中如果有，則取出最后一個，如果取出framebufferFromCache為空，則取倒數第二個，依次類推。
            NSInteger currentTextureID = (numberOfMatchingTextures - 1);
            while ((framebufferFromCache == nil) && (currentTextureID >= 0))
            {
                // 根據數量構建帶數量的textureHash字符串
                NSString *textureHash = [NSString stringWithFormat:@"%@-%ld", lookupHash, (long)currentTextureID];
                
                // 查找以textureHash為key的GPUImageFramebuffer是否存在
                framebufferFromCache = [framebufferCache objectForKey:textureHash];
                // Test the values in the cache first, to see if they got invalidated behind our back
                if (framebufferFromCache != nil)
                {
                    // 存在，則從緩存中刪除
                    // Withdraw this from the cache while it's in use
                    [framebufferCache removeObjectForKey:textureHash];
                }
                currentTextureID--;
            }
            
            currentTextureID++;
            
            // 更新framebufferTypeCounts中相同類型GPUImageFramebuffer的數量
            [framebufferTypeCounts setObject:[NSNumber numberWithInteger:currentTextureID] forKey:lookupHash];
            
            // 還是沒有則創建
            if (framebufferFromCache == nil)
            {
                framebufferFromCache = [[GPUImageFramebuffer alloc] initWithSize:framebufferSize textureOptions:textureOptions onlyTexture:onlyTexture];
            }
        }
    });
    
    // 引用計數加1，返回
    [framebufferFromCache lock];
    return framebufferFromCache;
}

• 根據framebufferSize和onlyTexture以及默認的GPUTextureOptions查找GPUImageFramebuffer。如果找不到，會創建新的緩存。

- (GPUImageFramebuffer *)fetchFramebufferForSize:(CGSize)framebufferSize onlyTexture:(BOOL)onlyTexture;
{
    GPUTextureOptions defaultTextureOptions;
    defaultTextureOptions.minFilter = GL_LINEAR;
    defaultTextureOptions.magFilter = GL_LINEAR;
    defaultTextureOptions.wrapS = GL_CLAMP_TO_EDGE;
    defaultTextureOptions.wrapT = GL_CLAMP_TO_EDGE;
    defaultTextureOptions.internalFormat = GL_RGBA;
    defaultTextureOptions.format = GL_BGRA;
    defaultTextureOptions.type = GL_UNSIGNED_BYTE;
    
    return [self fetchFramebufferForSize:framebufferSize textureOptions:defaultTextureOptions onlyTexture:onlyTexture];
}

• 回收緩存。根據size、textureOptions和onlyTexture，創建緩存的key值，ramebufferTypeCounts中的key由lookupHash構成沒有加數量。在framebufferCache中，key值由lookupHash加上數量避免覆蓋相同的GPUImageFramebuffer。

- (void)returnFramebufferToCache:(GPUImageFramebuffer *)framebuffer;
{
    // 清除引用計數
    [framebuffer clearAllLocks];
    
//    dispatch_async(framebufferCacheQueue, ^{
    runAsynchronouslyOnVideoProcessingQueue(^{
        CGSize framebufferSize = framebuffer.size;
        GPUTextureOptions framebufferTextureOptions = framebuffer.textureOptions;
        // 常見查找hash字符串
        NSString *lookupHash = [self hashForSize:framebufferSize textureOptions:framebufferTextureOptions onlyTexture:framebuffer.missingFramebuffer];
        // 獲取當前同類型緩存的數量
        NSNumber *numberOfMatchingTexturesInCache = [framebufferTypeCounts objectForKey:lookupHash];
        NSInteger numberOfMatchingTextures = [numberOfMatchingTexturesInCache integerValue];
        
        // 對相同類型的GPUImageFramebuffer,存放在framebufferCache中時，key值由lookupHash加上數量避免覆蓋相同的GPUImageFramebuffer。
        NSString *textureHash = [NSString stringWithFormat:@"%@-%ld", lookupHash, (long)numberOfMatchingTextures];
        
//        [framebufferCache setObject:framebuffer forKey:textureHash cost:round(framebufferSize.width * framebufferSize.height * 4.0)];
        [framebufferCache setObject:framebuffer forKey:textureHash];
        
        // framebufferTypeCounts中的key沒有加數量
        [framebufferTypeCounts setObject:[NSNumber numberWithInteger:(numberOfMatchingTextures + 1)] forKey:lookupHash];
    });
}

• 內存警告的時候，清空緩存。

- (void)purgeAllUnassignedFramebuffers;
{
    runAsynchronouslyOnVideoProcessingQueue(^{
//    dispatch_async(framebufferCacheQueue, ^{
        [framebufferCache removeAllObjects];
        [framebufferTypeCounts removeAllObjects];
#if TARGET_IPHONE_SIMULATOR || TARGET_OS_IPHONE
        CVOpenGLESTextureCacheFlush([[GPUImageContext sharedImageProcessingContext] coreVideoTextureCache], 0);
#else
#endif
    });
}

• 幀緩存持有與釋放。在讀取幀緩存圖像數據時，需要保持對 GPUImageFramebuffer 的引用。并且讀取完數據后，需要對其進行釋放。詳細見 GPUImageFramebuffer 的 newCGImageFromFramebufferContents 方法。

- (void)addFramebufferToActiveImageCaptureList:(GPUImageFramebuffer *)framebuffer;
{
    runAsynchronouslyOnVideoProcessingQueue(^{
//    dispatch_async(framebufferCacheQueue, ^{
        [activeImageCaptureList addObject:framebuffer];
    });
}

- (void)removeFramebufferFromActiveImageCaptureList:(GPUImageFramebuffer *)framebuffer;
{
    runAsynchronouslyOnVideoProcessingQueue(^{
//  dispatch_async(framebufferCacheQueue, ^{
        [activeImageCaptureList removeObject:framebuffer];
    });
}

總結

GPUImageFramebuffer 封裝了OpenGLES中幀緩存，紋理附件等相關技術。
GPUImageFramebufferCache 管理著GPUImageFramebuffer，方便GPUImageFramebuffer的重復利用。

源碼地址：GPUImage源碼閱讀系列 https://github.com/QinminiOS/GPUImage
系列文章地址：GPUImage源碼閱讀 http://www.lxweimin.com/nb/11749791