¿Dónde está la documentación oficial para los tipos de método CVOpenGLESTexture?

Question

Intenté google y stackoverflow pero no puedo encontrar la documentación oficial para las funciones que comienzan con CVOpenGLESTexture. Puedo ver que son de Core video, y sé que se agregaron en iOS 5, pero al buscar en la documentación no me da nada.

Estoy buscando la información sobre los parámetros, qué hacen, cómo usarlos, etc., como en los otros frameworks de Apple.

Hasta ahora todo lo que puedo hacer es presionar clic en él para ver la información, pero esto se siente súper raro. ¿O hay alguna manera de agregar esto para que se pueda mostrar en la ayuda rápida a la derecha en xcode?

Gracias y lo siento si es una pregunta estúpida.

PD: La guía de referencia de Video central tampoco parece explicar esto.

Answer 1

Lamentablemente, realmente no hay ninguna documentación sobre estas nuevas funciones. Lo mejor que vas a encontrar en este momento se encuentra en el archivo de cabecera CVOpenGLESTextureCache.h, donde puedes encontrar una descripción básica de los parámetros de la función:

/*! 
    @function CVOpenGLESTextureCacheCreate 
    @abstract Creates a new Texture Cache. 
    @param  allocator The CFAllocatorRef to use for allocating the cache. May be NULL. 
    @param  cacheAttributes A CFDictionaryRef containing the attributes of the cache itself. May be NULL. 
    @param  eaglContext The OpenGLES 2.0 context into which the texture objects will be created. OpenGLES 1.x contexts are not supported. 
    @param  textureAttributes A CFDictionaryRef containing the attributes to be used for creating the CVOpenGLESTexture objects. May be NULL. 
    @param  cacheOut The newly created texture cache will be placed here 
    @result  Returns kCVReturnSuccess on success 
*/ 
CV_EXPORT CVReturn CVOpenGLESTextureCacheCreate(
        CFAllocatorRef allocator, 
        CFDictionaryRef cacheAttributes, 
        void *eaglContext, 
        CFDictionaryRef textureAttributes, 
        CVOpenGLESTextureCacheRef *cacheOut) __OSX_AVAILABLE_STARTING(__MAC_NA,__IPHONE_5_0); 

Los elementos más difíciles son los diccionarios de atributos, que por desgracia lo que necesita para encontrar ejemplos de para usar estas funciones correctamente. Apple tiene los ejemplos GLCameraRipple y RosyWriter que muestran cómo usar la ruta rápida de carga de texturas con los formatos de color de entrada BGRA y YUV. Apple también proporcionó el ejemplo de ChromaKey en WWDC (que aún puede ser accesible junto con los videos) que demostró cómo usar estos cachés de texturas para extraer información de una textura OpenGL ES.

Acabo de cargar rápidamente esta textura trabajando en mi framework GPUImage (cuyo código fuente está disponible en ese enlace), así que expondré lo que pude analizar. En primer lugar, se crea una memoria caché de textura usando el siguiente código:

CVReturn err = CVOpenGLESTextureCacheCreate(kCFAllocatorDefault, NULL, (__bridge void *)[[GPUImageOpenGLESContext sharedImageProcessingOpenGLESContext] context], NULL, &coreVideoTextureCache); 
if (err) 
{ 
    NSAssert(NO, @"Error at CVOpenGLESTextureCacheCreate %d"); 
} 

donde el contexto mencionó es un EAGLContext configurado para OpenGL ES 2.0.

Lo utilizo para mantener los fotogramas de vídeo de la cámara del dispositivo IOS en la memoria de vídeo, y utilizo el siguiente código para hacer esto:

CVPixelBufferLockBaseAddress(cameraFrame, 0); 

CVOpenGLESTextureRef texture = NULL; 
CVReturn err = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault, coreVideoTextureCache, cameraFrame, NULL, GL_TEXTURE_2D, GL_RGBA, bufferWidth, bufferHeight, GL_BGRA, GL_UNSIGNED_BYTE, 0, &texture); 

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

outputTexture = CVOpenGLESTextureGetName(texture); 
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); 

// Do processing work on the texture data here 

CVPixelBufferUnlockBaseAddress(cameraFrame, 0); 

CVOpenGLESTextureCacheFlush(coreVideoTextureCache, 0); 
CFRelease(texture); 
outputTexture = 0; 

Esto crea una nueva CVOpenGLESTextureRef, lo que representa una textura de OpenGL ES, desde la memoria caché Esta textura se basa en el CVImageBufferRef pasado por la cámara. Esa textura luego se recupera de CVOpenGLESTextureRef y los parámetros apropiados se establecieron para ella (lo que parecía ser necesario en mi procesamiento). Finalmente, hago mi trabajo sobre la textura y limpio cuando termino.

Este proceso de carga rápida hace una diferencia real en los dispositivos iOS. Tomó la carga y el procesamiento de un solo cuadro de video de 640x480 en un iPhone 4S de 9,0 ms a 1,8 ms.

También tengo heard that this works in reverse, lo que podría permitir el reemplazo de glReadPixels() en ciertas situaciones, pero aún no lo he intentado.

Answer 2

Apple finalmente ha publicado el documentation, hace poco más de una semana.