Attachment 139204 Details for Bug 106302 – Isolated test case

Isolated test case

multiple-contexts.cpp (text/x-c++src), 5.89 KB, created by seb on 2018-04-28 20:06:49 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: seb

Created: 2018-04-28 20:06:49 UTC

Size: 5.89 KB

patch

obsolete

>/*
> * Asynchronous texture upload test.
> *
> * Compile and execute on radeonsi:
> *   g++ multiple-contexts.cpp -lEGL -lGL -lpthread && ./a.out
> *
> * Compare with llvmpipe:
> *   LIBGL_ALWAYS_SOFTWARE=1 ./a.out
> *
> * Expected result: "passed" printed on stdout
> */
>
>#include <EGL/egl.h>
>#include <GLES3/gl3.h>
>#include <array>
>#include <cassert>
>#include <cstdio>
>#include <thread>
>
>
>EGLDisplay g_eglDisplay;
>
>
>void       initEGL();
>EGLContext initContext( EGLContext shareContext = EGL_NO_CONTEXT );
>void       createTexture( EGLContext shareContext, GLuint & texture );
>GLuint     createShader( GLenum type, const char * src );
>void       drawTexQuad( GLuint );
>
>
>int
>main()
>{
>   initEGL();
>   EGLContext context = initContext();
>
>   // 1. use primary context
>   glClearColor( 1.0f, 0.0f, 0.0f, 1.0f );
>   glClear( GL_COLOR_BUFFER_BIT );
>
>   // 2. upload texture on secondary context
>   GLuint texture;
>   std::thread texUploadThread( createTexture, std::ref( context ), std::ref( texture ) );
>   texUploadThread.join();
>
>   // 3. draw texture on primary context
>   drawTexQuad( texture );
>
>   // 4. assert the expectations
>   std::array< unsigned char, 8*8*4 > pixels;
>   glReadPixels( 0, 0, 8, 8, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data() );
>
>   bool success = true;
>   for ( size_t i = 0; i < pixels.size(); ++i )
>   {
>      if ( pixels[ i ] != i )
>      {
>         printf( "fb[ %lu, %lu, %lu ] expected %lu, actual %u\n", i/4/8, i/4%8, i%4, i, pixels[ i ] );
>         success = false;
>      }
>   }
>
>   assert( glGetError() == GL_NO_ERROR );
>
>   if ( success )  printf( "passed\n" );
>}
>
>
>/*
> * Initializes EGL and default display.
> */
>void
>initEGL()
>{
>   g_eglDisplay = eglGetDisplay( EGL_DEFAULT_DISPLAY );
>
>   EGLint major, minor;
>   bool eglInitialized = eglInitialize( g_eglDisplay, &major, &minor );
>   assert( eglInitialized );
>
>   printf( "EGL_CLIENT_APIS: %s\nEGL_VENDOR: %s\nEGL_VERSION: %s\n",
>           eglQueryString( g_eglDisplay, EGL_CLIENT_APIS ),
>           eglQueryString( g_eglDisplay, EGL_VENDOR ),
>           eglQueryString( g_eglDisplay, EGL_VERSION ) );
>}
>
>
>/*
> * Initializes OpenGL ES context with an optional shared context.
> */
>EGLContext
>initContext( EGLContext shareContext )
>{
>   EGLConfig eglConfig;
>   EGLint    numConfigs;
>   EGLint    configAttribs[] = { EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_ALPHA_SIZE, 8,
>                                 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
>                                 EGL_NONE };
>   eglChooseConfig( g_eglDisplay, configAttribs, &eglConfig, 1, &numConfigs );
>   assert( numConfigs == 1 );
>
>   EGLint contextAttribs[] =
>   {
>      EGL_CONTEXT_MAJOR_VERSION, 3,
>      EGL_CONTEXT_MINOR_VERSION, 0,
>      EGL_NONE
>   };
>
>   EGLContext eglContext = eglCreateContext( g_eglDisplay, eglConfig, shareContext, contextAttribs );
>   assert( eglContext != EGL_NO_CONTEXT );
>
>   EGLint const surfaceAttribs[] = { EGL_WIDTH, 8, EGL_HEIGHT, 8, EGL_NONE };
>   EGLSurface eglSurface = eglCreatePbufferSurface( g_eglDisplay, eglConfig, surfaceAttribs );
>   assert( eglSurface != EGL_NO_SURFACE );
>
>   eglMakeCurrent( g_eglDisplay, eglSurface, eglSurface, eglContext );
>
>   return eglContext;
>}
>
>
>/*
> * Generates a texture name and calls TexImage with 8x8 RGBA texels = { 0, 1, ..., 255 }.
> * Creates its own EGL context.
> */
>void
>createTexture( EGLContext shareContext, GLuint & texture )
>{
>   initContext( shareContext );
>
>   glGenTextures( 1, &texture );
>   glBindTexture( GL_TEXTURE_2D, texture );
>
>   std::array< unsigned char, 8*8*4 > texels;
>   for ( size_t i = 0; i < texels.size(); ++i )  texels[i] = i;
>
>   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
>   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
>   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
>   glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
>   glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, texels.data() );
>   assert( glGetError() == GL_NO_ERROR );
>
>   glBindTexture( GL_TEXTURE_2D, 0 );
>}
>
>
>/*
> * Helper to create a shader.
> */
>GLuint
>createShader( GLenum type, const char * src )
>{
>   GLuint shader = glCreateShader( type );
>
>   glShaderSource( shader, 1, &src, nullptr );
>   glCompileShader( shader );
>
>   GLint success;
>   glGetShaderiv( shader, GL_COMPILE_STATUS, &success );
>
>   if ( !success )
>   {
>      char log[ 2048 ];
>      GLsizei length;
>      glGetShaderInfoLog( shader, sizeof( log ), &length, log );
>      printf( "Shader didn't compile:\n%s\n", log );
>   }
>
>   assert( success );
>
>   return shader;
>}
>
>
>/*
> * Draws a textured fullscreen quad.
> */
>void
>drawTexQuad( GLuint texture )
>{
>   // 1. create shader program
>   GLuint vertexShader = createShader( GL_VERTEX_SHADER,
>   R"(
>      #version 300 es
>      in   vec4 pos;
>      out  vec2 texc;
>      void main()
>      {
>         gl_Position = vec4( pos.xy, 0.0, 1.0 );
>         texc = pos.zw;
>      }
>   )" );
>   GLuint fragmentShader = createShader( GL_FRAGMENT_SHADER,
>   R"(
>      #version 300 es
>      precision highp float;
>      uniform sampler2D tex;
>      in   vec2 texc;
>      out  vec4 color;
>      void main()
>      {
>         color = texture( tex, texc );
>      }
>   )" );
>
>   GLuint program = glCreateProgram();
>   glAttachShader( program, vertexShader );
>   glAttachShader( program, fragmentShader );
>   glLinkProgram( program );
>
>   GLint success;
>   glGetProgramiv( program, GL_LINK_STATUS, &success );
>   assert( success );
>
>   glUseProgram( program );
>
>   // 2. draw quad
>   glBindTexture( GL_TEXTURE_2D, texture );
>
>   float quad[] = { -1.0f, -1.0f,  0.0f, 0.0f,
>                     1.0f, -1.0f,  1.0f, 0.0f,
>                    -1.0f,  1.0f,  0.0f, 1.0f,
>                     1.0f,  1.0f,  1.0f, 1.0f };
>   glEnableVertexAttribArray( 0 );
>   glVertexAttribPointer( 0, 4, GL_FLOAT, GL_FALSE, 16, quad );
>
>   glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
>   assert( glGetError() == GL_NO_ERROR );
>
>   glBindTexture( GL_TEXTURE_2D, 0 );
>}

Actions: View

Attachments on bug 106302: 139204

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.