`CVOpenGLESTextureCache` Am I using it wrong ？

Question

refer to GPUImage , i use frameBufferCache to reuse framebuffer.

use CVOpenGLESTextureCacheCreateTextureFromImage() to create new framebuffer

CVOpenGLESTextureCacheRef coreVideoTextureCache = [WDContext shareImageContext].glTextureCache;
            

            CFDictionaryRef empty; // empty value for attr value.
            CFMutableDictionaryRef attrs;
            empty = CFDictionaryCreate(kCFAllocatorDefault,
                                       NULL,
                                       NULL,
                                       0,
                                       &kCFTypeDictionaryKeyCallBacks,
                                       &kCFTypeDictionaryValueCallBacks); // our empty IOSurface properties dictionary
            attrs = CFDictionaryCreateMutable(kCFAllocatorDefault,
                                              1,
                                              &kCFTypeDictionaryKeyCallBacks,
                                              &kCFTypeDictionaryValueCallBacks);
            CFDictionarySetValue(attrs, kCVPixelBufferIOSurfacePropertiesKey, empty);

            CVReturn err = CVPixelBufferCreate(kCFAllocatorDefault,
                                               (int) self->_size.width,
                                               (int) self->_size.height,
                                               kCVPixelFormatType_32BGRA,
                                               attrs,
                                               &self->renderTarget);
            if (err) {
                NSLog(@"FBO size: %f, %f", self->_size.width, self->_size.height);
                NSAssert(NO, @"Error at CVPixelBufferCreate %d", err);
            }

            err = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault,
                                                               coreVideoTextureCache,
                                                               self->renderTarget,
                                                               NULL, // texture attributes
                                                               GL_TEXTURE_2D,
                                                               self->_textureOptions.internalFormat, // opengl format
                                                               (int) self->_size.width,
                                                               (int) self->_size.height,
                                                               self->_textureOptions.format, // native iOS format
                                                               self->_textureOptions.type,
                                                               0,
                                                               &self->renderTexture);
            if (err) {
                NSAssert(NO, @"Error at CVOpenGLESTextureCacheCreateTextureFromImage %d", err);
            }

            CFRelease(attrs);
            CFRelease(empty);

            glBindTexture(CVOpenGLESTextureGetTarget(self->renderTexture), CVOpenGLESTextureGetName(self->renderTexture));
            self->_texture = CVOpenGLESTextureGetName(self->renderTexture);
            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, self->_textureOptions.wrapS);
            glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, self->_textureOptions.wrapT);

            glFramebufferTexture2D(GL_FRAMEBUFFER,
                                   GL_COLOR_ATTACHMENT0,
                                   GL_TEXTURE_2D,
                                   CVOpenGLESTextureGetName(self->renderTexture),
                                   0);

when framebuffer is no use,then return to cache for reuse later.

and in my program，i also need to decode the video, and convert YUV format pixelBuffer to RGB texture

CVOpenGLESTextureRef luminanceTextureRef = NULL;
                    CVOpenGLESTextureRef chrominanceTextureRef = NULL;
                    
                    glActiveTexture(GL_TEXTURE4);
                    err = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault,
                                                                       [WDGLContext shareImageContext].glTextureCache,
                                                                       pixelBuffer,
                                                                       NULL,
                                                                       GL_TEXTURE_2D,
                                                                       GL_LUMINANCE,
                                                                       w,
                                                                       h,
                                                                       GL_LUMINANCE,
                                                                       GL_UNSIGNED_BYTE,
                                                                       0,
                                                                       &luminanceTextureRef);
                    
                    glBindTexture(GL_TEXTURE_2D, CVOpenGLESTextureGetName(luminanceTextureRef));
                    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
                    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
                    
                    if (err) {
                        WDMKLog(@"YUV Make Texture Error at CVOpenGLESTextureCacheCreateTextureFromImage %d", err);
                    }
                    
                    glActiveTexture(GL_TEXTURE5);
                    err = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault,
                                                                       [WDGLContext shareImageContext].glTextureCache,
                                                                       pixelBuffer,
                                                                       NULL,
                                                                       GL_TEXTURE_2D,
                                                                       GL_LUMINANCE_ALPHA,
                                                                       w / 2,
                                                                       h / 2,
                                                                       GL_LUMINANCE_ALPHA,
                                                                       GL_UNSIGNED_BYTE,
                                                                       1,
                                                                       &chrominanceTextureRef);
                    if (err) {
                        WDMKLog(@"YUV Make Texture Error at CVOpenGLESTextureCacheCreateTextureFromImage %d", err);
                    }
                    
                    glBindTexture(GL_TEXTURE_2D, CVOpenGLESTextureGetName(chrominanceTextureRef));
                    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
                    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

the problem is when i have framebuffer reused from cache in other process, then the luminance or chrominance texture created by CVOpenGLESTextureCacheCreateTextureFromImage is not correct

if all framebuffer are new, not from cache,then there is no problem.

i have no idea What does it matter about framebuffer cache， The only common point is that both use CVOpenGLESTextureCache .

so, am I using it wrong ？

i am puzzled by this question for a long time, anyone can help? thank you

Answer 1

Sorry，opengl operation was right，there were problems elsewhere.