#import "GPUImageContext.h"#import <OpenGLES/EAGLDrawable.h>#import <AVFoundation/AVFoundation.h>#define MAXSHADERPROGRAMSALLOWEDINCACHE 40@interface GPUImageContext(){    NSMutableDictionary *shaderProgramCache;    NSMutableArray *shaderProgramUsageHistory;    EAGLSharegroup *_sharegroup;}@end@implementation GPUImageContext@synthesize context = _context;@synthesize currentShaderProgram = _currentShaderProgram;@synthesize contextQueue = _contextQueue;@synthesize coreVideoTextureCache = _coreVideoTextureCache;@synthesize framebufferCache = _framebufferCache;static void *openGLESContextQueueKey;- (id)init;{    if (!(self = [super init]))    {        return nil;    }    openGLESContextQueueKey = &openGLESContextQueueKey;    _contextQueue = dispatch_queue_create("com.sunsetlakesoftware.GPUImage.openGLESContextQueue", NULL);    #if OS_OBJECT_USE_OBJC    dispatch_queue_set_specific(_contextQueue, openGLESContextQueueKey, (__bridge void *)self, NULL);#endif    shaderProgramCache = [[NSMutableDictionary alloc] init];    shaderProgramUsageHistory = [[NSMutableArray alloc] init];        return self;}+ (void *)contextKey {    return openGLESContextQueueKey;}// Based on Colin Wheeler's example here: http://cocoasamurai.blogspot.com/2011/04/singletons-your-doing-them-wrong.html+ (GPUImageContext *)sharedImageProcessingContext;{    static dispatch_once_t pred;    static GPUImageContext *sharedImageProcessingContext = nil;        dispatch_once(&pred, ^{        sharedImageProcessingContext = [[[self class] alloc] init];    });    return sharedImageProcessingContext;}+ (dispatch_queue_t)sharedContextQueue;{    return [[self sharedImageProcessingContext] contextQueue];}+ (GPUImageFramebufferCache *)sharedFramebufferCache;{    return [[self sharedImageProcessingContext] framebufferCache];}+ (void)useImageProcessingContext;{    [[GPUImageContext sharedImageProcessingContext] useAsCurrentContext];}- (void)useAsCurrentContext;{    EAGLContext *imageProcessingContext = [self context];    if ([EAGLContext currentContext] != imageProcessingContext)    {        [EAGLContext setCurrentContext:imageProcessingContext];    }}+ (void)setActiveShaderProgram:(GLProgram *)shaderProgram;{    GPUImageContext *sharedContext = [GPUImageContext sharedImageProcessingContext];    [sharedContext setContextShaderProgram:shaderProgram];}- (void)setContextShaderProgram:(GLProgram *)shaderProgram;{    EAGLContext *imageProcessingContext = [self context];    if ([EAGLContext currentContext] != imageProcessingContext)    {        [EAGLContext setCurrentContext:imageProcessingContext];    }        if (self.currentShaderProgram != shaderProgram)    {        self.currentShaderProgram = shaderProgram;        [shaderProgram use];    }}+ (GLint)maximumTextureSizeForThisDevice;{    static dispatch_once_t pred;    static GLint maxTextureSize = 0;        dispatch_once(&pred, ^{        [self useImageProcessingContext];        glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);    });    return maxTextureSize;}+ (GLint)maximumTextureUnitsForThisDevice;{    static dispatch_once_t pred;    static GLint maxTextureUnits = 0;    dispatch_once(&pred, ^{        [self useImageProcessingContext];        glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureUnits);    });        return maxTextureUnits;}+ (GLint)maximumVaryingVectorsForThisDevice;{    static dispatch_once_t pred;    static GLint maxVaryingVectors = 0;    dispatch_once(&pred, ^{        [self useImageProcessingContext];        glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryingVectors);    });    return maxVaryingVectors;}+ (BOOL)deviceSupportsOpenGLESExtension:(NSString *)extension;{    static dispatch_once_t pred;    static NSArray *extensionNames = nil;    // Cache extensions for later quick reference, since this won't change for a given device    dispatch_once(&pred, ^{        [GPUImageContext useImageProcessingContext];        NSString *extensionsString = [NSString stringWithCString:(const char *)glGetString(GL_EXTENSIONS) encoding:NSASCIIStringEncoding];        extensionNames = [extensionsString componentsSeparatedByString:@" "];    });    return [extensionNames containsObject:extension];}// http://www.khronos.org/registry/gles/extensions/EXT/EXT_texture_rg.txt+ (BOOL)deviceSupportsRedTextures;{    static dispatch_once_t pred;    static BOOL supportsRedTextures = NO;        dispatch_once(&pred, ^{        supportsRedTextures = [GPUImageContext deviceSupportsOpenGLESExtension:@"GL_EXT_texture_rg"];    });        return supportsRedTextures;}+ (BOOL)deviceSupportsFramebufferReads;{    static dispatch_once_t pred;    static BOOL supportsFramebufferReads = NO;        dispatch_once(&pred, ^{        supportsFramebufferReads = [GPUImageContext deviceSupportsOpenGLESExtension:@"GL_EXT_shader_framebuffer_fetch"];    });        return supportsFramebufferReads;}+ (CGSize)sizeThatFitsWithinATextureForSize:(CGSize)inputSize;{    GLint maxTextureSize = [self maximumTextureSizeForThisDevice];     if ( (inputSize.width < maxTextureSize) && (inputSize.height < maxTextureSize) )    {        return inputSize;    }        CGSize adjustedSize;    if (inputSize.width > inputSize.height)    {        adjustedSize.width = (CGFloat)maxTextureSize;        adjustedSize.height = ((CGFloat)maxTextureSize / inputSize.width) * inputSize.height;    }    else    {        adjustedSize.height = (CGFloat)maxTextureSize;        adjustedSize.width = ((CGFloat)maxTextureSize / inputSize.height) * inputSize.width;    }    return adjustedSize;}- (void)presentBufferForDisplay;{    [self.context presentRenderbuffer:GL_RENDERBUFFER];}- (GLProgram *)programForVertexShaderString:(NSString *)vertexShaderString fragmentShaderString:(NSString *)fragmentShaderString;{    NSString *lookupKeyForShaderProgram = [NSString stringWithFormat:@"V: %@ - F: %@", vertexShaderString, fragmentShaderString];    GLProgram *programFromCache = [shaderProgramCache objectForKey:lookupKeyForShaderProgram];    if (programFromCache == nil)    {        programFromCache = [[GLProgram alloc] initWithVertexShaderString:vertexShaderString fragmentShaderString:fragmentShaderString];        [shaderProgramCache setObject:programFromCache forKey:lookupKeyForShaderProgram];//        [shaderProgramUsageHistory addObject:lookupKeyForShaderProgram];//        if ([shaderProgramUsageHistory count] >= MAXSHADERPROGRAMSALLOWEDINCACHE)//        {//            for (NSUInteger currentShaderProgramRemovedFromCache = 0; currentShaderProgramRemovedFromCache < 10; currentShaderProgramRemovedFromCache++)//            {//                NSString *shaderProgramToRemoveFromCache = [shaderProgramUsageHistory objectAtIndex:0];//                [shaderProgramUsageHistory removeObjectAtIndex:0];//                [shaderProgramCache removeObjectForKey:shaderProgramToRemoveFromCache];//            }//        }    }        return programFromCache;}- (void)useSharegroup:(EAGLSharegroup *)sharegroup;{    NSAssert(_context == nil, @"Unable to use a share group when the context has already been created. Call this method before you use the context for the first time.");        _sharegroup = sharegroup;}- (EAGLContext *)createContext;{    EAGLContext *context = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2 sharegroup:_sharegroup];    NSAssert(context != nil, @"Unable to create an OpenGL ES 2.0 context. The GPUImage framework requires OpenGL ES 2.0 support to work.");    return context;}#pragma mark -#pragma mark Manage fast texture upload+ (BOOL)supportsFastTextureUpload;{#if TARGET_IPHONE_SIMULATOR    return NO;#else    #pragma clang diagnostic push#pragma clang diagnostic ignored "-Wtautological-pointer-compare"    return (CVOpenGLESTextureCacheCreate != NULL);#pragma clang diagnostic pop#endif}#pragma mark -#pragma mark accessors- (EAGLContext *)context;{    if (_context == nil)    {        _context = [self createContext];        [EAGLContext setCurrentContext:_context];                // Set up a few global settings for the image processing pipeline        glDisable(GL_DEPTH_TEST);    }        return _context;}- (CVOpenGLESTextureCacheRef)coreVideoTextureCache;{    if (_coreVideoTextureCache == NULL)    {#if defined(__IPHONE_6_0)        CVReturn err = CVOpenGLESTextureCacheCreate(kCFAllocatorDefault, NULL, [self context], NULL, &_coreVideoTextureCache);#else        CVReturn err = CVOpenGLESTextureCacheCreate(kCFAllocatorDefault, NULL, (__bridge void *)[self context], NULL, &_coreVideoTextureCache);#endif                if (err)        {            NSAssert(NO, @"Error at CVOpenGLESTextureCacheCreate %d", err);        }    }        return _coreVideoTextureCache;}- (GPUImageFramebufferCache *)framebufferCache;{    if (_framebufferCache == nil)    {        _framebufferCache = [[GPUImageFramebufferCache alloc] init];    }        return _framebufferCache;}@end