Comment faire pour afficher un raw YUV dans un cadre de Cacao programme OpenGL

J'ai été assigné à l'esprit la tâche d'écrire un programme qui prend un échantillon brut YUV fichier et l'afficher dans un Cacao programme OpenGL.

Je suis un stagiaire dans mon travail et j'ai peu ou aucune idée de comment commencer. J'ai été la lecture de wikipédia & des articles sur YUV, mais je ne pouvais pas trouver une bonne source code sur comment ouvrir un raw YUV fichier, extraire les données et de les convertir en RVB et l'afficher dans la fenêtre d'affichage.

Essentiellement, j'ai besoin d'aide avec les aspects suivants de la tâche
-comment extraire le YUV données à partir de l'exemple de fichier YUV
-comment faire pour convertir le YUV données dans l'espace de couleurs RVB
-comment faire pour afficher l'espace de couleurs RVB en OpenGL. (Celui-ci je pense que je peux comprendre avec le temps, mais j'ai vraiment besoin d'aide avec les deux premiers points)

veuillez me dire les classes à utiliser, ou de m'indiquer les endroits où je peux apprendre sur YUV graphique/affichage vidéo

InformationsquelleAutor ReachConnection | 2009-07-03

1

Cette réponse n'est pas correcte, voir les autres réponses et commentaires. Réponse originale à cette question à gauche en dessous pour la postérité.

~~Vous ne pouvez pas l'afficher directement.~~ Vous aurez besoin de les convertir en RVB texture. Comme vous l'avez compris de Wikipédia, il y a un tas de variations sur l'espace de couleurs YUV. Assurez-vous que vous utilisez la bonne.

Pour chaque pixel, la conversion YUV vers RGB est une simple transformation linéaire. Vous venez de faire la même chose à chaque pixel de façon indépendante.

Une fois que vous avez converti l'image en RVB, vous pouvez l'afficher par la création d'une texture. Vous devez appeler glGenTextures() d'allouer une texture poignée, glBindTexture() pour lier la texture à la rendre contexte, et glTexImage2D() pour télécharger les données de la texture pour le GPU. Le rendre, vous à nouveau appel glBindTexture(), suivi par le rendu d'un quad, avec des coordonnées de texture correctement configuré.
```
//parameters: image:  pointer to raw YUV input data
//            width:  image width (must be a power of 2)
//            height: image height (must be a power of 2)
//returns: a handle to the resulting RGB texture
GLuint makeTextureFromYUV(const float *image, int width, int height)
{
float *rgbImage = (float *)malloc(width * height * 3 * sizeof(float));  //check for NULL
float *rgbImagePtr = rgbImage;
//convert from YUV to RGB (floats used here for simplicity; it's a little
//trickier with 8-bit ints)
int y, x;
for(y = 0; y < height; y++)
{
for(x = 0; x < width; x++)
{
float Y = *image++;
float U = *image++;
float V = *image++;
*rgbImagePtr++ = Y                + 1.13983f * V;  //R
*rgbImagePtr++ = Y - 0.39465f * U - 0.58060f * V;  //G
*rgbImagePtr++ = Y + 2.03211f * U;                 //B
}
}
//create texture
GLuint texture;
glGenTextures(1, &texture);
//bind texture to render context
glBindTexture(GL_TEXTURE_2D, texture);
//upload texture data
glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0, GL_RGB, GL_FLOAT, rgbImage);
//don't use mipmapping (since we're not creating any mipmaps); the default
//minification filter uses mipmapping.  Use linear filtering for minification
//and magnification.
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//free data (it's now been copied onto the GPU) and return texture handle
free(rgbImage);
return texture;
}
```
À rendre:
```
glBindTexture(GL_TEXTURE_2D, texture);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f); glVertex3f( 0.0f,  0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f); glVertex3f(64.0f,  0.0f, 0.0f);
glTexCoord2f(1.0f, 1.0f); glVertex3f(64.0f, 64.0f, 0.0f);
glTexCoord2f(0.0f, 1.0f); glVertex3f( 0.0f, 64.0f, 0.0f);
glEnd();
```
Et n'oubliez pas d'appeler glEnable(GL_TEXTURE_2D) à un certain moment au cours de l'initialisation, et de l'appeler glDeleteTextures(1, &texture) lors de l'arrêt.
- Merci beaucoup pour l'information Adam je l'apprécie vraiment. Maintenant, pouvez-vous me dire comment extraire les données brutes du fichier à partir du disque dur? Je suis familier avec NSOpenPanel, je peux l'utiliser pour extraire les données du fichier chemin d'accès, cependant, comment puis-je utiliser un chemin d'accès au fichier et charger le YUV fichier dans l'application?
- En supposant que le fichier ne contient rien que de pixels, vous pouvez simplement utiliser NSData ou NSFileHandle et tout lire. Si le fichier contient des métadonnées telles que la taille de l'information, vous allez avoir à l'interpréter à l'aide de la norme C pointeur et/ou de la structure des opérateurs.
- Cette réponse est incorrecte. Départ avec MacOS 10.2 et plus tard, tous les système Apple prend en charge OpenGL extensions, qui peut directement charger et afficher YUV données. Recherche pour "GL_YCBCR_422_APPLE" pour plus de détails. Si les données sont converties quelque part (par le pilote dans le logiciel, sur le GPU dans le matériel, etc.) est aucun de votre entreprise lors de l'utilisation de cette extension (et lorsque le GPU est la conversion, faites-moi confiance, il peut battre l'exemple de code ci-dessus par au moins 1000%)
InformationsquelleAutor Adam Rosenfield

Je l'ai fait avec YUV images capturées par une caméra CCD. Malheureusement, il y a un certain nombre de différents formats YUV. Je crois que celui que Apple utilise pour la GL_YCBCR_422_APPLE format de texture est techniquement 2VUY422. Pour convertir une image à partir d'un YUV422 image générée par un IIDC caméra Firewire à 2VUY422, j'ai utilisé le suivant:

void yuv422_2vuy422(const unsigned char *theYUVFrame, unsigned char *the422Frame, const unsigned int width, const unsigned int height) 
{
int i =0, j=0;
unsigned int numPixels = width * height;
unsigned int totalNumberOfPasses = numPixels * 2;
register unsigned int y0, y1, y2, y3, u0, u2, v0, v2;
while (i < (totalNumberOfPasses) )
{
u0 = theYUVFrame[i++]-128;
y0 = theYUVFrame[i++];
v0 = theYUVFrame[i++]-128;
y1 = theYUVFrame[i++];
u2 = theYUVFrame[i++]-128;
y2 = theYUVFrame[i++];
v2 = theYUVFrame[i++]-128;
y3 = theYUVFrame[i++];
//U0 Y0 V0 Y1 U2 Y2 V2 Y3
//Remap the values to 2VUY (YUYS?) (Y422) colorspace for OpenGL
//Y0 U Y1 V Y2 U Y3 V
//IIDC cameras are full-range y=[0..255], u,v=[-127..+127], where display is "video range" (y=[16..240], u,v=[16..236])
the422Frame[j++] = ((y0 * 240) / 255 + 16);
the422Frame[j++] = ((u0 * 236) / 255 + 128);
the422Frame[j++] = ((y1 * 240) / 255 + 16);
the422Frame[j++] = ((v0 * 236) / 255 + 128);
the422Frame[j++] = ((y2 * 240) / 255 + 16);
the422Frame[j++] = ((u2 * 236) / 255 + 128);
the422Frame[j++] = ((y3 * 240) / 255 + 16);
the422Frame[j++] = ((v2 * 236) / 255 + 128);
}
}

Efficace de l'affichage d'une vidéo YUV source, vous pouvez utiliser Apple client extension de stockage, que vous pouvez configurer à l'aide de quelque chose comme ce qui suit:

glEnable(GL_TEXTURE_RECTANGLE_EXT);
glBindTexture(GL_TEXTURE_RECTANGLE_EXT, 1);
glTextureRangeAPPLE(GL_TEXTURE_RECTANGLE_EXT, videoImageWidth * videoImageHeight * 2, videoTexture);
glTexParameteri(GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_STORAGE_HINT_APPLE , GL_STORAGE_SHARED_APPLE);
glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
glTexParameteri(GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_RECTANGLE_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glTexImage2D(GL_TEXTURE_RECTANGLE_EXT, 0, GL_RGBA, videoImageWidth, videoImageHeight, 0, GL_YCBCR_422_APPLE, GL_UNSIGNED_SHORT_8_8_REV_APPLE, videoTexture);

Cela vous permet de modifier rapidement les données stockées au sein de votre côté client texture vidéo avant chaque image à afficher sur l'écran.

Pour dessiner, vous pouvez utiliser le code suivant:

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);         
glEnable(GL_TEXTURE_2D);
glViewport(0, 0, [self frame].size.width, [self frame].size.height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
NSRect bounds = NSRectFromCGRect([self bounds]);
glOrtho( (GLfloat)NSMinX(bounds), (GLfloat)NSMaxX(bounds), (GLfloat)NSMinY(bounds), (GLfloat)NSMaxY(bounds), -1.0, 1.0);
glBindTexture(GL_TEXTURE_RECTANGLE_EXT, 1);
glTexSubImage2D (GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, videoImageWidth, videoImageHeight, GL_YCBCR_422_APPLE, GL_UNSIGNED_SHORT_8_8_REV_APPLE, videoTexture);
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f);
glVertex2f(0.0f, videoImageHeight);
glTexCoord2f(0.0f, videoImageHeight);
glVertex2f(0.0f, 0.0f);
glTexCoord2f(videoImageWidth, videoImageHeight);
glVertex2f(videoImageWidth, 0.0f);
glTexCoord2f(videoImageWidth, 0.0f);
glVertex2f(videoImageWidth, videoImageHeight);      
glEnd();

merci beaucoup brad

InformationsquelleAutor Brad Larson

6

Adam Rosenfield du commentaire est incorrect. Sur Mac, vous pouvez afficher YCbCr (l'équivalent numérique YUV) des textures à l'aide de la GL_YCBCR_422_APPLE format de texture, comme spécifié dans le APPLE_ycbcr_422 extension.

InformationsquelleAutor Jens Ayton

Vous devez vous connecter pour publier un commentaire.