CVOpenGLESTextureCacheCreateTextureFromImage для kCVPixelFormatType_OneComponent8

Question

Я пытаюсь использовать CVOpenGLESTextureCacheCreateTextureFromImage, чтобы использовать ссылку в OpenGL, но мне не повезло:

У меня есть CVPixelBufferRef pixel_bufferAlpha который обновляется с использованием CVPixelBufferCreateWithBytes, с успехом: CVReturn успешно.

Затем я пытаюсь использовать CVOpenGLESTextureCacheCreateTextureFromImage на канале 1 текстура ( alphaMatte ) для создания CVOpenGLESTextureRef, которую я могу использовать в OpenGL.

Я инициализировал мой CVOpenGLESTextureCacheRef _videoTextureAlphaCache:

err = CVOpenGLESTextureCacheCreate(
                                        kCFAllocatorDefault,
                                        nil,
                                        eaglContext,
                                        nil,
                                        &_videoTextureAlphaCache);

И моя CVPixelBufferRef pixel_bufferAlpha инициализируется с помощью:

 cvret = CVPixelBufferCreate(kCFAllocatorDefault,
                                             width,height,
                                             kCVPixelFormatType_OneComponent8,
                                             (__bridge CFDictionaryRef)cvBufferProperties,
                                             &pixel_bufferAlpha);

        if(cvret != kCVReturnSuccess)
        {
            assert(!"Failed to create shared opengl pixel_bufferAlpha");
        }

Я использую kCVPixelFormatType_OneComponent8, поскольку мои MTLTexture, переданные в CVPixelBufferCreateWithBytes, имеют a MTLPixelFormat 10 -> MTLPixelFormatR8Unorm.

При попытке использовать CVOpenGLESTextureCacheCreateTextureFromImage появляется сообщение об ошибке "несовместимо с opengl":

CVPixelBufferLockBaseAddress(pixel_bufferAlpha, 0);

        err = noErr;
        err = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault,
                                                           _videoTextureAlphaCache,
                                                           pixel_bufferAlpha,
                                                           NULL,
                                                           GL_TEXTURE_2D,
                                                           // internal
                                                           // GL_RGBA,
                                                           GL_ALPHA,
                                                           width,
                                                           height,
                                                           // gl format
                                                           // GL_BGRA_EXT,
                                                           // GL_R8_EXT,
                                                           GL_ALPHA8_EXT,
                                                           // gl type
                                                           // GL_UNSIGNED_INT_8_8_8_8_REV,
                                                           GL_UNSIGNED_BYTE,
                                                           NULL,
                                                           &alphaTextureGLES);


        if (err != kCVReturnSuccess) {
            CVBufferRelease(pixel_bufferAlpha);

            if(err == kCVReturnInvalidPixelFormat){
                NSLog(@"Invalid pixel format");
            }

            if(err == kCVReturnInvalidPixelBufferAttributes){
                NSLog(@"Invalid pixel buffer attributes");
            }

            if(err == kCVReturnInvalidSize){
                NSLog(@"invalid size");
            }

            if(err == kCVReturnPixelBufferNotOpenGLCompatible){
                NSLog(@"CVOpenGLESTextureCacheCreateTextureFromImage::not opengl compatible");
            }

        }else{
            NSLog(@"ok CVOpenGLESTextureCacheCreateTextureFromImage SUCCESS");
        }

        // ================================================================================ //

        // clear texture cache
        CVOpenGLESTextureCacheFlush(_videoTextureAlphaCache, 0);
        CVPixelBufferUnlockBaseAddress(pixel_bufferAlpha, 0);

Я не уверен, что я ' здесь неправильно.

Также Буду признателен за любые указатели, так как я не очень разбираюсь в iOS и преобразованиях / форматах текстур ...

Best,

P

Полный релевантный часть кода:

alphaTexture = [matteDepthTexture  generateMatteFromFrame:_session.currentFrame commandBuffer:commandBuffer];

        // ===============================================================



        NSUInteger texBytesPerRow = alphaTexture.bufferBytesPerRow;
        NSUInteger texArrayLength = alphaTexture.arrayLength;




        int width = (int) alphaTexture.width;
        int height = (int) alphaTexture.height;
        MTLPixelFormat texPixelFormat = alphaTexture.pixelFormat;
        MTLTextureType texType = alphaTexture.textureType;
        int bytesPerPixel = 8;

        // MTLPixelFormatR8Unorm Ordinary format with one 8-bit normalized unsigned integer component.
        NSLog(@" texPixelFormat of the texture is : %d", texPixelFormat);
        NSLog(@" texType of the texture is : %d", texType);

        CVReturn err = noErr;
        err = CVPixelBufferCreateWithBytes(kCFAllocatorDefault,
                                     width,
                                     height,
                                     kCVPixelFormatType_OneComponent8,
                                     alphaTexture,
                                     bytesPerPixel * width,
                                     stillImageDataReleaseCallback,
                                     alphaTexture,
                                     NULL,
                                     &pixel_bufferAlpha);

        if (err != kCVReturnSuccess) {

               if(err == kCVReturnInvalidPixelFormat){
                   NSLog(@"Invalid pixel format");
               }

               if(err == kCVReturnInvalidPixelBufferAttributes){
                   NSLog(@"Invalid pixel buffer attributes");
               }

               if(err == kCVReturnInvalidSize){
                   NSLog(@"invalid size");
               }

               if(err == kCVReturnPixelBufferNotOpenGLCompatible){
                   NSLog(@"CVPixelBufferCreateWithBytes::not opengl compatible");
               }

        }else{
            NSLog(@"ok CVPixelBufferCreateWithBytes SUCCESS");
        }

        OSType sourcePixelFormat = CVPixelBufferGetPixelFormatType(pixel_bufferAlpha);
        if (kCVPixelFormatType_OneComponent8 == sourcePixelFormat) {
           NSLog(@" got format kCVPixelFormatType_OneComponent8");
        } else{
           NSLog(@" Unknown CoreVideo pixel format : %a", sourcePixelFormat);
        }




        // ================================================================================ //
        CVPixelBufferLockBaseAddress(pixel_bufferAlpha, 0);

        err = noErr;
        err = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault,
                                                           _videoTextureAlphaCache,
                                                           pixel_bufferAlpha,
                                                           NULL,
                                                           GL_TEXTURE_2D,
                                                           // internal
                                                           // GL_RGBA,
                                                           GL_RED_EXT,
                                                           width,
                                                           height,
                                                           // gl format
                                                           // GL_BGRA_EXT,
                                                           // GL_R8_EXT,
                                                           GL_R8_EXT,
                                                           // gl type
                                                           // GL_UNSIGNED_INT_8_8_8_8_REV,
                                                           GL_UNSIGNED_BYTE,
                                                           NULL,
                                                           &alphaTextureGLES);


        if (err != kCVReturnSuccess) {
            CVBufferRelease(pixel_bufferAlpha);

            if(err == kCVReturnInvalidPixelFormat){
                NSLog(@"Invalid pixel format");
            }

            if(err == kCVReturnInvalidPixelBufferAttributes){
                NSLog(@"Invalid pixel buffer attributes");
            }

            if(err == kCVReturnInvalidSize){
                NSLog(@"invalid size");
            }

            if(err == kCVReturnPixelBufferNotOpenGLCompatible){
                NSLog(@"CVOpenGLESTextureCacheCreateTextureFromImage::not opengl compatible");
            }

        }else{
            NSLog(@"ok CVOpenGLESTextureCacheCreateTextureFromImage SUCCESS");
        }

        // ================================================================================ //

        // clear texture cache
        CVOpenGLESTextureCacheFlush(_videoTextureAlphaCache, 0);
        CVPixelBufferUnlockBaseAddress(pixel_bufferAlpha, 0);

Answer 1

Немного покопавшись, я нашел расширение для MTLtexture из Alloy - отличная работа там -:

здесь

• getBytes, чтобы поместить текстуру в CVPixelBufferRef, затем
• CVOpenGLESTextureCacheCreateTextureFromImage, чтобы сохранить ее в CVOpenGLESTextureRef.

Так что в Objective - C это выглядит так это - с той же инициализацией для pixel_bufferAlpha и _videoTextureAlphaCache -:

        alphaTexture = [matteDepthTexture  generateMatteFromFrame:_session.currentFrame commandBuffer:commandBuffer];

        int width = (int) alphaTexture.width;
        int height = (int) alphaTexture.height;
        MTLPixelFormat texPixelFormat = alphaTexture.pixelFormat;


        CVPixelBufferLockBaseAddress(pixel_bufferAlpha, 0);
        void * CV_NULLABLE pixelBufferBaseAdress = CVPixelBufferGetBaseAddress(pixel_bufferAlpha);
        size_t bytesPerRow = CVPixelBufferGetBytesPerRow(pixel_bufferAlpha);

         [alphaTexture getBytes:pixelBufferBaseAdress
                            bytesPerRow:bytesPerRow
                            fromRegion:MTLRegionMake2D(0, 0, width, height)
                            mipmapLevel:0];


        size_t w = CVPixelBufferGetWidth(pixel_bufferAlpha);
        size_t h = CVPixelBufferGetHeight(pixel_bufferAlpha);

        CVReturn err = noErr;
        err = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault,
                                                        _videoTextureAlphaCache,
                                                        pixel_bufferAlpha,
                                                        nil,
                                                        GLenum(GL_TEXTURE_2D),
                                                        GLint(GL_LUMINANCE),
                                                        w,
                                                        h,
                                                        GLenum(GL_LUMINANCE),
                                                        GLenum(GL_UNSIGNED_BYTE),
                                                        0,
                                                        &alphaTextureGLES);


        if (err != kCVReturnSuccess) {
            CVBufferRelease(pixel_bufferAlpha);
            NSLog(@"error on CVOpenGLESTextureCacheCreateTextureFromImage");
        }

        CVPixelBufferUnlockBaseAddress(pixel_bufferAlpha, 0);

Надеюсь, это поможет кому-то на этом пути.