Dov'è la documentazione ufficiale per i tipi di metodo di CVOpenGLESTexture?

Question

Ho provato google e stackoverflow ma non riesco a trovare la documentazione ufficiale per le funzioni che iniziano con CVOpenGLESTexture. Vedo che provengono da Core Video e so che sono stati aggiunti su iOS 5 ma la ricerca nella documentazione non mi dà nulla.

Sto cercando informazioni sui parametri, su cosa fanno, su come utilizzarli ecc. Come negli altri framework Apple.

Finora tutto ciò che posso fare è fare clic su di esso per vedere le informazioni ma questo sembra super strano. O c'è un modo per aggiungere questo in modo che possa essere visualizzato sulla guida rapida a destra su xcode?

Grazie e scusa se è una domanda stupida.

PD: La guida di riferimento video principale non sembra spiegare questi neanche.

Answer 1

Sfortunatamente, non c'è davvero alcuna documentazione su queste nuove funzioni. Il meglio che si sta andando a trovare in questo momento si trova nel file di intestazione CVOpenGLESTextureCache.h, dove vedrete una descrizione di base dei parametri della funzione:

/*! 
    @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); 

Gli elementi più difficili sono i dizionari di attributi, che purtroppo è necessario per trovare esempi di al fine di utilizzare correttamente queste funzioni. Apple ha gli esempi GLCameraRipple e RosyWriter che mostrano come utilizzare il percorso di caricamento veloce delle texture con i formati di colore di input BGRA e YUV. Apple ha anche fornito l'esempio ChromaKey su WWDC (che potrebbe essere ancora accessibile insieme ai video) che ha dimostrato come utilizzare queste cache di texture per estrarre informazioni da una trama OpenGL ES.

Ho appena ottenuto il caricamento veloce della texture nel mio framework GPUImage (il codice sorgente per il quale è disponibile a quel collegamento), quindi illustrerò cosa è stato in grado di analizzare da questo. In primo luogo, creo una cache consistenza utilizzando il seguente codice:

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

dove il contesto di cui è un EAGLContext configurato per OpenGL ES 2.0.

Io lo uso per tenere fotogrammi video dalla fotocamera del dispositivo iOS nella memoria video, e io uso il seguente codice per fare questo:

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; 

Questo crea un nuovo CVOpenGLESTextureRef, che rappresenta una texture OpenGL ES, da la cache delle texture. Questa texture è basata sul CVImageBufferRef trasmesso dalla fotocamera. Quella trama viene quindi recuperata dal CVOpenGLESTextureRef e i parametri appropriati impostati per esso (che sembrava essere necessario nel mio processo). Infine, faccio il mio lavoro sulla texture e pulisco quando ho finito.

Questo processo di caricamento rapido fa davvero la differenza sui dispositivi iOS. È stato necessario caricare ed elaborare un singolo frame di video 640x480 su un iPhone 4S da 9,0 ms a 1,8 ms.

Ho heard that this works in reverse, che potrebbe consentire la sostituzione di glReadPixels() in determinate situazioni, ma devo ancora provarlo.

Answer 2

Apple ha finalmente pubblicato il documentation, poco più di una settimana fa.