Incorrect lors de l'utilisation d'openGL pour afficher les données BRGA de GPUImageOutput, 1920 * 1080

Question

Pour le nouveau venu chez OpengGL, cet accident a toujours quelque chose de mal avec imageWidth. La taille des données de GPUImageOutput n'est pas égale à image.width * image.height * bitsPerPixel. Dans un code, vous pouvez voir ces codes, mais c'est faux ... C'est une fosse.

Utilisez glPixelStorei (GL_UNPACK_ROW_LENGTH) pour définir la longueur de la ligne, pas bytesPerRow.

Astuce: comment déboguer:

#define ASSERT(xx) NSAssert1(xx, @"code:0x%x", glGetError()); 
ASSERT(glGetError() == GL_NO_ERROR); 

l'histoire de la question:
hier soir:
je l'ai trouvé. Lorsque la taille de l'image est 1920 * 1080, RawDataOutput.bytesPerRow est 4352, pas 4320 (1080 * 4). donc l'image est incorrecte ..
La prochaine question est de savoir comment utiliser glTexImage2d pour définir le bytesPerRow? J'utilise les données de GPUImageRawDataOutput pour créer une image.
Lorsque la dimension de l'appareil photo est 1280 * 720 ou 640 * 480, c'est OK; mais avec 1920 * 1080, il y a quelque chose qui ne va pas.
J'ai modifié KxMovieView pour afficher les données par vue OpenGL, il a le même tort. Ensuite, je modifiais kxMovieView pour montrer une image que j'ai reçue d'internet, ça va.
Je suis perplexe! Je suppose que cela peut avoir un problème avec image.linesize, mais pas d'aide.

Le format d'image de GPUImageRawDataOutput est BGRA. kxMovieView supporte par défaut RGB, je le change uniquement en RGBA, et dans shader, j'y ajoute .bgra.

//shader: 
NSString *const zvertexShaderString = SHADER_STRING 
( 
attribute vec4 position; 
attribute vec2 texcoord; 
uniform mat4 modelViewProjectionMatrix; 
varying vec2 v_texcoord; 

void main() 
{ 
    gl_Position = modelViewProjectionMatrix * position; 
    v_texcoord = texcoord.xy; 
} 
); 

NSString *const zrgbFragmentShaderString = SHADER_STRING 
(
varying highp vec2 v_texcoord; 
uniform sampler2D s_texture; 

void main() 
{ 
    gl_FragColor = texture2D(s_texture, v_texcoord).bgra; 
} 
); 

// KxGLRenderer_RGB - (NSString *) fragmentShader { retour zrgbFragmentShaderString; }

- (void) resolveUniforms: (GLuint) program 
{ 
    _uniformSampler = glGetUniformLocation(program, "s_texture"); 
} 

- (void) setFrame: (KxVideoFrame *) frame 
{ 
    KxVideoFrameRGB *rgbFrame = (KxVideoFrameRGB *)frame; 

    assert(rgbFrame.rgb.length == rgbFrame.width * rgbFrame.height * 4); 

    glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 

    if (0 == _texture) 
     glGenTextures(1, &_texture); 

    glBindTexture(GL_TEXTURE_2D, _texture); 

    glTexImage2D(GL_TEXTURE_2D, 
       0, 
       GL_RGBA, 
       (GLsizei)frame.width, 
       (GLsizei)frame.height, 
       0, 
       GL_RGBA, 
       GL_UNSIGNED_BYTE, 
       rgbFrame.rgb.bytes); 

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); 
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 
} 

- (BOOL) prepareRender 
{ 
    if (_texture == 0) 
     return NO; 

    glActiveTexture(GL_TEXTURE0); 
    glBindTexture(GL_TEXTURE_2D, _texture); 
    glUniform1i(_uniformSampler, 0); 

    return YES; 
} 

Answer 1

matériel GPU peut nécessiter enjambée qui ne correspond pas exactement à la largeur de l'image. GPUImageRawDataOutput gère correctement cette propriété lorsque la largeur de rapport ne correspond pas à la largeur de l'image.

Vous pouvez dire GL que vos données d'image a foulée différente de la largeur avec glPixelStorei (GL_UNPACK_ROW_LENGTH)