Exibir YUV em OpenGL

Question

Estou tendo problemas para exibir um arquivo YUV cru que é em formato NV12.

Eu posso exibir um quadro selecionado, no entanto, ainda é principalmente em preto e branco com certos tons de rosa e verde.

Aqui está como a minha saída parece

De qualquer forma, aqui está como o meu programa funciona. (Isto é feito no cacau / Objective-C, mas eu preciso do seu conselho perito em algoritmo do programa, e não na sintaxe.)

Antes da execução do programa, o arquivo YUV é armazenado em um arquivo binário chamado "test.yuv". O arquivo está no formato NV12, ou seja, o plano Y é armazenado em primeiro lugar, em seguida, o plano de UV é entrelaçado. Meu extração do arquivo não tem nenhum problema, porque eu fiz um monte testes nele.

Durante a iniciação, eu criar uma tabela de pesquisa que vai converter binário / 8 bites / um byte / caracteres em respeitada Y, U, V valores flutuador

Para o plano Y este é meu código

-(void)createLookupTableY //creates a lookup table for converting a single byte into a float between 0 and 1
{
    NSLog(@"YUVFrame: createLookupTableY");
    lookupTableY = new float [256];

    for (int i = 0; i < 256; i++)
    {
        lookupTableY[i] = (float) i /255;
        //NSLog(@"lookupTableY[%d]: %f",i,lookupTableY[i]);//prints out the value of each float
    }
}

O U Plane consulta à tabela

-(void)createLookupTableU //creates a lookup table for converting a single byte into a float between 0 and 1
{
    NSLog(@"YUVFrame: createLookupTableU");
    lookupTableU = new float [256];

    for (int i = 0; i < 256; i++)
    {
        lookupTableU[i] =  -0.436 + (float) i / 255* (0.436*2);
        NSLog(@"lookupTableU[%d]: %f",i,lookupTableU[i]);//prints out the value of each float
    }
}

E o V tabela look-up

-(void)createLookupTableV //creates a lookup table for converting a single byte into a float between 0 and 1
{
    NSLog(@"YUVFrame: createLookupTableV");
    lookupTableV = new float [256];

    for (int i = 0; i < 256; i++)
    {
        lookupTableV[i] =  -0.615 + (float) i /255 * (0.615*2);
        NSLog(@"lookupTableV[%d]: %f",i,lookupTableV[i]);//prints out the value of each float
    }
}

após este ponto, eu extrair o plano de Y & UV e armazená-los em dois buffers, yBuffer & uvBuffer

Neste ponto, I tentar converter os dados YUV e armazenados-lo em uma matriz de buffer RGB chamado "frameImage"

-(void)sortAndConvert//sort the extracted frame data into an array of float
{
    NSLog(@"YUVFrame: sortAndConvert");
    int frameImageCounter = 0;
    int pixelCounter = 0;
    for (int y = 0; y < YUV_HEIGHT; y++)//traverse through the frame's height
    {
        for ( int x = 0; x < YUV_WIDTH; x++)//traverse through the frame's width
        {

            float Y = lookupTableY [yBuffer [y*YUV_WIDTH + x] ];
            float U = lookupTableU [uvBuffer [ ((y / 2) * (YUV_WIDTH / 2) + (x/2)) * 2  ] ]; 
            float V = lookupTableV [uvBuffer [  ((y / 2) * (YUV_WIDTH / 2) + (x/2)) * 2 + 1] ];

            float RFormula = Y + 1.13983f * V;
            float GFormula = Y - 0.39465f * U - 0.58060f * V;
            float BFormula = Y + 2.03211f * U;

             frameImage [frameImageCounter++] = [self clampValue:RFormula];
             frameImage [frameImageCounter++] = [self clampValue:GFormula];
             frameImage [frameImageCounter++] = [self clampValue:BFormula];

        }
    }

}

então eu tentei desenhar a imagem em OpenGL

-(void)drawFrame:(int )x
{

    GLuint texture;

    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, YUV_WIDTH, YUV_HEIGHT, 0, GL_RGB, GL_FLOAT, frameImage);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    glEnable(GL_TEXTURE_2D);
    glBindTexture(GL_TEXTURE_2D, texture);
    glRotatef( 180.0f, 1.0f, 0.0f, 0.0f );

    glBegin( GL_QUADS );
    glTexCoord2d(0.0,0.0); glVertex2d(-1.0,-1.0);
    glTexCoord2d(1.0,0.0); glVertex2d(+1.0,-1.0);
    glTexCoord2d(1.0,1.0); glVertex2d(+1.0,+1.0);
    glTexCoord2d(0.0,1.0); glVertex2d(-1.0,+1.0);
    glEnd();

    glFlush();
}

Então, basicamente este meu programa em uma casca de noz. essencialmente i ler os arquivos YUV binários, armazena todos os dados em um buffer matriz de char. Eu, então, traduzir esses valores em seus valores float YUV respeitados.

Este é onde Penso que o erro pode ser: na tabela de pesquisa Y I padronizar o plano Y para [0,1], no plano U I padronizado entre os valores de [-0.435,0.436], e no V plano I padronizado que bewteen [-0.615,0.615]. Eu fiz isso porque esses são os intervalos de valores YUV acordo com a Wikipedia.

E o YUV a fórmula RGB é a mesma fórmula da Wikipedia. Eu também tentei várias outras fórmulas, e esta é a única fórmula que dá a perspectiva aproximada do quadro. Qualquer um pode se aventurar a adivinhar a razão pela qual meu programa não está exibindo corretamente os dados do quadro YUV. Eu acho que é algo a ver com a minha técnica de padronização, mas parece certo para mim.

Eu fiz um monte de testes, e estou 100% certo de que o erro é causado por por olhar para cima da tabela. Eu não acho que minhas fórmulas de configuração estão corretos.

Uma nota para todos que estão lendo isto. Durante muito tempo, o meu quadro não foi exibido corretamente porque eu não foi capaz de extrair os dados do quadro corretamente.

Quando eu comecei a programar, eu estava a impressão de que em um clipe de 30 quadros dizer, todos os 30 Y Dados planares são escritos em primeiro lugar no arquivo de dados, seguido depois por Dados planas UV.

O que eu descobri através de tentativa e erro foi que para um arquivo de dados YUV, especificamente NV12, o arquivo de dados é armazenados na seguinte forma

Y (1) UV (1) Y (2), uv (2) ... ...

@nschmidt

Eu mudei meu código para o que você sugeriu

float U = lookupTableU [uvBuffer [ (y * (YUV_WIDTH / 4) + (x/4)) * 2 ] ]
float V = lookupTableU [uvBuffer [ (y * (YUV_WIDTH / 4) + (x/4)) * 2 + 1] ]

e este é o resultado que eu recebo

aqui é a linha a partir do console de impressão. eu sou imprimir os valores para Y, U, V e valor RGB que estão sendo traduzido e armazenados no na matriz frameImage

YUV: [0.658824, -0,022227, -,045824] RGBFinal: [0.606593,0.694201,0.613655]

YUV: [0.643137, -0,022227, -,045824] RGBFinal: [0.590906,0.678514,0.597969]

YUV: [0.607843, -0,022227, -,045824] RGBFinal: [0.555612,0.643220,0.562675]

YUV: [0.592157, -0,022227, -,045824] RGBFinal: [0.539926,0.627534,0.546988]

YUV: [0.643137,0.025647,0.151941] RGBFinal: [0.816324,0.544799,0.695255]

YUV: [0.662745,0.025647,0.151941] RGBFinal: [0.835932,0.564406,0.714863]

YUV: [0.690196,0.025647,0.151941] RGBFinal: [0.863383,0.591857,0.742314]

Atualização de 13 de julho de 2009

O problema foi finalmente resolvido, graças a recomendação da nschmidt . Acontece que meu arquivo YUV estava realmente em YUV 4: 1: 1 formato. I foi originalmente disse que era em formato YUV NV12. De qualquer forma, eu gostaria de compartilhar meus resultados com você.

Aqui está de saída

e meu código para decodificar é a seguinte

        float Y = (float) yBuffer [y*YUV_WIDTH + x] ;
        float U = (float) uvBuffer [ ((y / 2) * (YUV_WIDTH  / 2) + (x/2))   ] ; 
        float V = (float) uvBuffer [  ((y / 2) * (YUV_WIDTH  / 2) + (x/2))  + UOffset] ;

        float RFormula = (1.164*(Y-16) + (1.596* (V - 128) ));
        float GFormula = ((1.164 * (Y - 16)) - (0.813 * ((V) - 128)) - (0.391 * ((U) - 128)));
        float BFormula = ((1.164 * (Y - 16)) + (2.018 * ((U) - 128)));


        frameImage [frameImageCounter] = (unsigned char)( (int)[self clampValue:RFormula]);
        frameImageCounter ++;
        frameImage [frameImageCounter] =  (unsigned char)((int)[self clampValue:GFormula]);
        frameImageCounter++;
        frameImage [frameImageCounter] = (unsigned char)((int) [self clampValue:BFormula]);
        frameImageCounter++;



GLuint texture;

glGenTextures(1, &texture);
glEnable(GL_TEXTURE_2D);

glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);

glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, YUV_WIDTH, YUV_HEIGHT, 0, GL_RGB, GL_UNSIGNED_BYTE, frameImage);

//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE_SGIS);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE_SGIS);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);

glRotatef( 180.0f, 1.0f, 0.0f, 0.0f );

glBegin( GL_QUADS );
glTexCoord2d(0.0,0.0); glVertex2d(-1.0,-1.0);
glTexCoord2d(1.0,0.0); glVertex2d(+1.0,-1.0);
glTexCoord2d(1.0,1.0); glVertex2d(+1.0,+1.0);
glTexCoord2d(0.0,1.0); glVertex2d(-1.0,+1.0);
glEnd();

NSLog(@"YUVFrameView: drawRect complete");
glFlush();

essencialmente, eu usei NSData para a extração do arquivo raw. armazenado num tampão matriz de char. Para YUV para RGB conversão, I usado a fórmula acima, depois, I fixada os valores para [0: 255]. então eu usei um 2DTexture em OpenGL para exibição.

Então, se você está convertendo YUV para RGB no futuro, usar a fórmula de cima. Se estiver usando o YUV a fórmula de conversão RGB do post anterior, então você precisa para exibir a textura em GL_Float a partir dos valores de RGB são fixadas entre [0: 1]

Answer 1

Em seguida tente :) Acho que você está tampão uv não é intercalado. Parece que os valores U vir em primeiro lugar e, em seguida, a matriz de valores V. Alterar as linhas para

unsigned int voffset = YUV_HEIGHT * YUV_WIDTH / 2;
float U = lookupTableU [uvBuffer [ y * (YUV_WIDTH / 2) + x/2] ]; 
float V = lookupTableV [uvBuffer [ voffset + y * (YUV_WIDTH / 2) + x/2] ];

pode indicar se este é realmente o caso.

Answer 2

Eu acho que você está dirigindo U e V valores incorretamente. Em vez de:

float U = lookupTableU [uvBuffer [ ((y / 2) * (x / 2) + (x/2)) * 2  ] ]; 
float V = lookupTableV [uvBuffer [  ((y / 2) * (x / 2) + (x/2)) * 2 + 1] ];

Deve ser algo ao longo das linhas

float U = lookupTableU [uvBuffer [ ((y / 2) * (YUV_WIDTH / 2) + (x/2)) * 2  ] ]; 
float V = lookupTableV [uvBuffer [  ((y / 2) * (YUV_WIDTH / 2) + (x/2)) * 2 + 1] ];

Answer 3

Os olhares de imagem como você tem formato 4: 1: 1. Você deve mudar suas linhas para

float U = lookupTableU [uvBuffer [ (y * (YUV_WIDTH / 4) + (x/4)) * 2 ] ]
float V = lookupTableU [uvBuffer [ (y * (YUV_WIDTH / 4) + (x/4)) * 2 + 1] ]

Talvez você pode enviar o resultado para ver, o que mais está errado. Acho que é sempre difícil pensar sobre isso. É muito mais fácil de abordar isso de forma iterativa.