Attachment 49039 Details for Bug 39193 – Test program demonstrating the crash

Test program demonstrating the crash

framebuffertexturetest.c (text/x-csrc), 13.21 KB, created by Simon Farnsworth on 2011-07-13 07:41:28 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Simon Farnsworth

Created: 2011-07-13 07:41:28 UTC

Size: 13.21 KB

patch

obsolete

>#include <X11/Xlib.h>
>#include <GL/glew.h>
>#include <GL/glxew.h>
>
>#include <sys/time.h>
>
>#include <stdlib.h>
>#include <stdio.h>
>#include <assert.h>
>
>/* Shared state variables */
>static Display *display;
>static int screen;
>static Screen *screen_ptr;
>static int glx_event_base;
>static Window render_window;
>static GLXWindow glx_render_window;
>
>/* Functions */
>
>static void dump_gl_errors( unsigned int line )
>{
>    GLenum error;
>    error = glGetError();
>    if( error == 0 )
>    {
>        return;
>    }
>    else
>    {
>        while( error != 0 )
>        {
>            fprintf( stderr, "GL Error 0x%x at line %d\n", error, line );
>            error = glGetError();
>        }
>        exit( EXIT_FAILURE );
>    }
>}
>#define check_gl_errors() dump_gl_errors( __LINE__ )
>
>static void draw( double red, double green, double blue )
>{
>    check_gl_errors();
>    glClear( GL_COLOR_BUFFER_BIT );
>    check_gl_errors();
>    glColor4d( red, green, blue, 1.0 );
>    check_gl_errors();
>
>    glBegin( GL_QUADS );
>    glTexCoord2d( 0.0, 0.0 );
>    glVertex2d( 0.1, 0.1 );
>    glTexCoord2d( 1.0, 0.0 );
>    glVertex2d( 0.9, 0.1 );
>    glTexCoord2d( 1.0, 1.0 );
>    glVertex2d( 0.9, 0.9 );
>    glTexCoord2d( 0.0, 1.0 );
>    glVertex2d( 0.1, 0.9 );
>    glEnd();
>
>    check_gl_errors();
>    glFinish();
>    check_gl_errors();
>}
>
>static void render_to_texture( GLuint target_texture )
>{
>    GLuint framebuffer;
>    GLuint bound_texture;
>    size_t i;
>    Pixmap pixmap;
>    GLXPixmap glx_pixmap;
>    GC gc;
>    XWindowAttributes attrib;
>    VisualID visualid;
>    GLXFBConfig *fbconfigs;
>    int nfbconfigs;
>    int value;
>    XVisualInfo *visinfo;
>    int pixmapAttribs[] = { GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
>                            GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGBA_EXT,
>                            None };
>
>    check_gl_errors();
>
>    /* In the "real" use, this pixmap would come from XCompositeNameWindowPixmap */
>    pixmap = XCreatePixmap( display, render_window, 64, 64, 24 );
>    gc = XCreateGC( display, pixmap, 0, NULL );
>    XSetForeground( display, gc, WhitePixel( display, screen ) );
>    XDrawLine( display, pixmap, gc, 0, 0, 64, 64 );
>    XFreeGC( display, gc );
>    XFlush( display );
>
>    glXWaitX();
>
>    /* Copied from http://www.opengl.org/registry/specs/EXT/texture_from_pixmap.txt */
>    XGetWindowAttributes (display, render_window, &attrib);
>
>    visualid = XVisualIDFromVisual (attrib.visual);
>
>    fbconfigs = glXGetFBConfigs (display, screen, &nfbconfigs);
>    for (i = 0; i < nfbconfigs; i++)
>    {
>        visinfo = glXGetVisualFromFBConfig (display, fbconfigs[i]);
>        if (!visinfo || visinfo->visualid != visualid)
>            continue;
>
>        glXGetFBConfigAttrib (display, fbconfigs[i], GLX_DRAWABLE_TYPE, &value);
>        if (!(value & GLX_PIXMAP_BIT))
>            continue;
>
>        glXGetFBConfigAttrib (display, fbconfigs[i],
>                              GLX_BIND_TO_TEXTURE_TARGETS_EXT,
>                              &value);
>        if (!(value & GLX_TEXTURE_2D_BIT_EXT))
>            continue;
>
>        glXGetFBConfigAttrib (display, fbconfigs[i],
>                              GLX_BIND_TO_TEXTURE_RGBA_EXT,
>                              &value);
>        if (value == GL_FALSE)
>        {
>            glXGetFBConfigAttrib (display, fbconfigs[i],
>                                  GLX_BIND_TO_TEXTURE_RGB_EXT,
>                                  &value);
>            if (value == GL_FALSE)
>                continue;
>        }
>        break;
>    }
>
>    if (i == nfbconfigs)
>        exit( EXIT_FAILURE );
>
>    glx_pixmap = glXCreatePixmap (display, fbconfigs[i], pixmap, pixmapAttribs);
>
>    glBindTexture( GL_TEXTURE_2D, bound_texture );
>    check_gl_errors();
>
>    glXBindTexImageEXT (display, glx_pixmap, GLX_FRONT_LEFT_EXT, NULL);
>    check_gl_errors();
>
>    glGenFramebuffersEXT( 1, &framebuffer );
>    check_gl_errors();
>
>    glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, framebuffer );
>    check_gl_errors();
>
>    glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, bound_texture, 0 );
>    check_gl_errors();
>
>    GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
>    if(status != GL_FRAMEBUFFER_COMPLETE_EXT)
>    {
>        glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
>        fprintf(stderr, "Framebuffer incomplete error!\n");
>        exit( EXIT_FAILURE );
>    }
>
>    glBindTexture( GL_TEXTURE_2D, target_texture );
>    check_gl_errors();
>
>    glCopyTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 64, 64, 0 );
>    check_gl_errors();
>
>    glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );
>    check_gl_errors();
>    glBindTexture( GL_TEXTURE_2D, bound_texture );
>    glXReleaseTexImageEXT( display, glx_pixmap, GLX_FRONT_LEFT_EXT );
>    glXDestroyGLXPixmap( display, glx_pixmap );
>    XFreePixmap( display, pixmap );
>    glDeleteTextures( 1, &bound_texture );
>    glDeleteFramebuffersEXT( 1, &framebuffer );
>    check_gl_errors();
>}
>
>typedef Bool ( * PFNGLXGETSYNCVALUESOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t *ust, int64_t *msc, int64_t *sbc);
>PFNGLXGETSYNCVALUESOMLPROC glXGetSyncValuesOML;
>typedef Bool ( * PFNGLXWAITFORSBCOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t target_sbc, int64_t *ust, int64_t *msc, int64_t *sbc);
>PFNGLXWAITFORSBCOMLPROC glXWaitForSbcOML;
>typedef int64_t ( * PFNGLXSWAPBUFFERSMSCOMLPROC) (Display *dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder);
>PFNGLXSWAPBUFFERSMSCOMLPROC glXSwapBuffersMscOML;
>
>static void init_gl( void )
>{
>    int glx_error_base;
>    int major;
>    int minor;
>    GLenum err;
>    const int attrib_list[] = { GLX_DOUBLEBUFFER, True,
>                                GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
>                                GLX_RED_SIZE, 8,
>                                GLX_GREEN_SIZE, 8,
>                                GLX_BLUE_SIZE, 8,
>                                GLX_ALPHA_SIZE, 0,
>                                GLX_DEPTH_SIZE, 0,
>                                GLX_STENCIL_SIZE, 0,
>                                GLX_RENDER_TYPE, GLX_RGBA_BIT,
>                                GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
>                                GLX_X_RENDERABLE, True,
>                                None };
>    int num_glx_fb_configs;
>    GLXFBConfig *all_glx_fb_configs;
>    GLXFBConfig glx_fb_config;
>    XVisualInfo *visual_info;
>    Colormap colormap;
>    XSetWindowAttributes attrs;
>    GLXContext gl_context;
>
>    glXQueryExtension( display, &glx_error_base, &glx_event_base );
>
>    if( !glXQueryVersion( display, &major, &minor ) )
>    {
>        fprintf( stderr, "No GLX?!?\n" );
>    }
>    if( major != 1 || minor < 3 )
>    {
>        fprintf( stderr, "Bad GLX version %d.%d!\n", major, minor );
>        exit( EXIT_FAILURE );
>    }
>
>    glXChooseFBConfig = (GLXFBConfig*(*)(Display *, int, const int *, int *))glXGetProcAddressARB((GLubyte*)"glXChooseFBConfig");
>    glXGetVisualFromFBConfig = (XVisualInfo*(*)(Display *, GLXFBConfig ))glXGetProcAddressARB((GLubyte*)"glXGetVisualFromFBConfig");
>    glXCreateNewContext = (GLXContext(*)(Display *, GLXFBConfig, int, GLXContext, Bool))glXGetProcAddressARB((GLubyte*)"glXCreateNewContext");
>    glXMakeContextCurrent = (Bool(*)(Display *, GLXDrawable, GLXDrawable, GLXContext))glXGetProcAddressARB((GLubyte*)"glXMakeContextCurrent");
>    glXCreateWindow = (GLXWindow(*)(Display *, GLXFBConfig, Window, const int *))glXGetProcAddressARB((GLubyte*)"glXCreateWindow");
>
>    all_glx_fb_configs = glXChooseFBConfig( display, screen, attrib_list, &num_glx_fb_configs );
>
>    if( !all_glx_fb_configs )
>    {
>        fprintf( stderr, "No GLX FB config!\n" );
>        exit( EXIT_FAILURE );
>    }
>
>    glx_fb_config = all_glx_fb_configs[0];
>    XFree( all_glx_fb_configs );
>
>    visual_info = glXGetVisualFromFBConfig( display, glx_fb_config );
>    colormap = XCreateColormap( display, RootWindow( display, screen ), visual_info->visual, AllocNone );
>
>    attrs.colormap = colormap;
>    attrs.border_pixel = 0;
>
>    printf( "Screen is %dx%d\n", WidthOfScreen( screen_ptr ), HeightOfScreen( screen_ptr ) );
>    render_window = XCreateWindow( display, RootWindow( display, screen ),
>                                          0, 0,
>                                          WidthOfScreen( screen_ptr ), HeightOfScreen( screen_ptr ),
>                                          0, visual_info->depth, InputOutput, visual_info->visual,
>                                          CWColormap, &attrs );
>    glx_render_window = glXCreateWindow( display, glx_fb_config, render_window, NULL );
>
>    XMapWindow( display, render_window );
>
>    gl_context = glXCreateNewContext( display, glx_fb_config, GLX_RGBA_TYPE, NULL, GL_TRUE );
>
>    glXMakeContextCurrent( display, glx_render_window, glx_render_window, gl_context );
>
>    err = glewInit();
>    if( err != GLEW_OK )
>    {
>        fprintf( stderr, "GLEW init: %s\n", glewGetErrorString( err ) );
>        exit( EXIT_FAILURE );
>    }
>
>    if( !GLXEW_VERSION_1_3 )
>    {
>        fprintf( stderr, "GLXEW failure\n" );
>        exit( EXIT_FAILURE );
>    }
>
>    if( !GLEW_VERSION_2_0 )
>    {
>        fprintf( stderr, "OpenGL version too old - need 2.0.\n" );
>        exit( EXIT_FAILURE );
>    }
>
>    /* OML_sync_control */
>    glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC)glXGetProcAddress( (const GLubyte *)"glXGetSyncValuesOML" );
>    glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC)glXGetProcAddress( (const GLubyte *)"glXWaitForSbcOML" );
>    glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC)glXGetProcAddress( (const GLubyte *)"glXSwapBuffersMscOML" );
>    if( glXGetSyncValuesOML == NULL ||
>        glXWaitForSbcOML == NULL ||
>        glXSwapBuffersMscOML == NULL )
>    {
>        fprintf( stderr, "GLX_OML_sync_control is required.\n" );
>        exit(1);
>    }
>
>    if( !GLXEW_INTEL_swap_event )
>    {
>        fprintf( stderr, "GLX_INTEL_swap_event is required.\n" );
>        exit( EXIT_FAILURE );
>    }
>
>    if( !GLEW_EXT_framebuffer_object )
>    {
>        fprintf( stderr, "GL_EXT_framebuffer_object is required.\n" );
>        exit( EXIT_FAILURE );
>    }
>
>    glXSelectEvent( display, glx_render_window, GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK );
>    glClearColor( 0.0, 0.0, 0.0, 0.0 );
>    glShadeModel( GL_FLAT );
>
>    glMatrixMode( GL_PROJECTION );
>    glLoadIdentity();
>    /* left, right, bottom, top - gets 0,0 at top, left */
>    gluOrtho2D( 0, 1, 1, 0 );
>
>    glMatrixMode( GL_MODELVIEW );
>    glLoadIdentity();
>
>    check_gl_errors();
>}
>
>static double timeOfDay( void )
>{
>    struct timeval tod;
>    gettimeofday( &tod, NULL );
>    return tod.tv_sec + tod.tv_usec / 1000000.0;
>}
>
>int main( int argc, char *argv[] )
>{
>    double last_frame_time;
>    double start_time;
>    int64_t ust;
>    int64_t msc;
>    int64_t sbc;
>    int64_t initial_msc;
>    int64_t initial_sbc;
>    GLuint draw_texture;
>
>    display = XOpenDisplay( NULL );
>    screen = DefaultScreen( display );
>    screen_ptr = DefaultScreenOfDisplay( display );
>
>    init_gl();
>    check_gl_errors();
>
>    glGenTextures( 1, &draw_texture );
>    check_gl_errors();
>
>    render_to_texture( draw_texture );
>    check_gl_errors();
>
>    glEnable( GL_TEXTURE_2D );
>    glBindTexture( GL_TEXTURE_2D, draw_texture );
>    glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
>    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
>    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
>    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
>    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
>    check_gl_errors();
>
>    glViewport( 0, 0, WidthOfScreen( screen_ptr ), HeightOfScreen( screen_ptr ) );
>
>    glXGetSyncValuesOML( display,
>                         glx_render_window,
>                         &ust,
>                         &msc,
>                         &sbc );
>    initial_msc = msc;
>    initial_sbc = sbc;
>
>    draw( 1.0, 1.0, 1.0 );
>    check_gl_errors();
>    glXSwapBuffersMscOML( display,
>                          glx_render_window,
>                          msc + 1,
>                          0,
>                          0 );
>    check_gl_errors();
>
>    start_time = last_frame_time = timeOfDay();
>    while( 1 )
>    {
>        double now;
>
>        ++msc;
>        if( (msc % 2) == 0 )
>        {
>            draw( 0.0, 1.0, 1.0 );
>        }
>        else
>        {
>            draw( 1.0, 1.0, 0.0 );
>        }
>        check_gl_errors();
>
>        glXSwapBuffersMscOML( display,
>                              glx_render_window,
>                              msc + 1,
>                              0,
>                              0 );
>        check_gl_errors();
>
>        now = timeOfDay();
>        if( (now - start_time) > 10 )
>        {
>            double average_swap_interval;
>            double frames_per_swap;
>            long frames;
>            long swaps;
>
>            glXGetSyncValuesOML( display,
>                                 glx_render_window,
>                                 &ust,
>                                 &msc,
>                                 &sbc );
>            frames = msc - initial_msc;
>            swaps = sbc - initial_sbc;
>            average_swap_interval = (now - start_time) / (double)swaps;
>            frames_per_swap = (double)frames / (double)swaps;
>
>            printf( "Averaging %lf frames per swap\n", frames_per_swap );
>            printf( "Average swap interval %lf ms\n", average_swap_interval * 1000 );
>            printf( "%ld frames, %ld swaps\n", frames, swaps );
>            exit( EXIT_SUCCESS );
>        }
>    }
>}

Actions: View

Attachments on bug 39193: 49039 | 51195 | 51200

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.