Max 5 API Reference

jit.gl.readback.c

/*
 * Copyright 2001-2005 - Cycling '74
 * Derek Gerstmann - derek@cycling74.com
 *
 * Struct and associated methods for an offscreen framebuffer object
 * capable of writing raster information into another buffer object,
 * either textures or renderbuffers.
 */

#include "jit.gl.readback.h"
#include "jit.gl.readback.fbo.h"
#include "jit.gl.readback.pbuffer.h"
#include "jit.gl.texture.h"
#include "jit.gl.pixelformat.h"
#include "jit.gl.fbo.h"

//******************************************************************************

void *_jit_gl_readback_class;

t_symbol *ps_jit_gl_readback_fbo;
t_symbol *ps_jit_gl_readback_rtt;
t_symbol *ps_jit_gl_readback_ctt;

//******************************************************************************

void jit_gl_readback_init()
{
    long attrflags=0;
    void *attr;
    
    jit_gl_fbo_init();          //should eventually move to kernel initialization
    
    // create class
    _jit_gl_readback_class = jit_class_new("jit_gl_readback",(method)jit_gl_readback_new,(method)jit_gl_readback_free,
        sizeof(t_jit_gl_readback), A_DEFSYM, 0L);
    
    ps_jit_gl_readback_fbo = gensym("fbo");
    ps_jit_gl_readback_rtt = gensym("rtt");
    ps_jit_gl_readback_ctt = gensym("ctt");
    
    jit_class_register(_jit_gl_readback_class);
}

t_jit_gl_readback *jit_gl_readback_new()
{
    t_jit_gl_readback *x = NULL;

    if(x=(t_jit_gl_readback *)jit_object_alloc(_jit_gl_readback_class))
    {
        x->mode = -1;
        x->fbo = NULL;
        x->matrix = NULL;
        x->pbuffer = NULL;
        x->depthbuffer = NULL;
        x->stencilbuffer = NULL;
        jit_gl_readback_reset(x);
        x->ownsfbo = 0;
        x->attachment = GL_NONE;
    }

    return x;
}

void jit_gl_readback_free(t_jit_gl_readback *x)
{
    if(x)
    {
        jit_gl_readback_destroy(x);
    }
}

//******************************************************************************

t_jit_err jit_gl_readback_create(
    t_jit_gl_readback *x, long mode, GLint width, GLint height, GLint depth, GLint stencil)
{
    t_jit_err err = JIT_ERR_NONE;

    if(!x)
        return JIT_ERR_INVALID_PTR;

    // handle vendor specific limitations
    if(mode == JIT_GL_READBACK_MODE_FBO)
    {   
        /*char *vendor  = (char *) glGetString(GL_VENDOR);
        char *version = (char *) glGetString(GL_VERSION);

        if (strstr(vendor, "ATI Technologies"))
        {
            // ATI only seems to support 16bit depth
            if(depth)
                depth = 16; 
        }

        if (strstr(vendor, "NVIDIA"))
        {
            // NVIDIA only seems to support 24bit depth
            if(depth)
                depth = 24;
        }*/
    }

    if( x->mode == mode &&
        x->width == width &&
        x->height == height &&
        x->depth == depth &&
        x->stencil == stencil )
    {
        // nothing todo!
        return JIT_ERR_NONE;
    }

    // destroy current readback
    jit_gl_readback_destroy(x);

    // use either fbo or pbuffer as destination
    switch(mode)
    {
        case(JIT_GL_READBACK_MODE_FBO):
        {
            err = jit_gl_readback_create_fbo(x, mode, width, height, depth, stencil);
            break;
        }
        case(JIT_GL_READBACK_MODE_PBUFFER_CTT):
        case(JIT_GL_READBACK_MODE_PBUFFER_RTT):
        {
            err = jit_gl_readback_create_pbuffer(x, mode, width, height, depth, stencil);
            break;
        }
        default:
        {
            jit_object_error((t_object *)x,"jit.gl.readback: unable to create readback object: mode invalid!");
            err = JIT_ERR_GENERIC;
            break;
        }
    };

    if(!err)
    {
        x->mode = mode;
        x->width = width;
        x->height = height;
        x->depth = depth;
        x->stencil = stencil;
    }

    return err;
}

t_jit_err jit_gl_readback_create_with_fbo(t_jit_gl_readback *x, long mode, GLint width, GLint height, void *fbocontext, GLenum attachment)
{
    GLenum type;
    t_jit_gl_support *support = NULL;

    //reinit readback mechanism
    jit_gl_readback_destroy(x);
    
    //verify fbocontext is valid
    if(jit_object_classname(fbocontext) != gensym("jit_gl_fbo")) {
        jit_object_error((t_object *)x,"jit.gl.readback: texture's fbocontext is invalid!");
        return JIT_ERR_INVALID_OBJECT;
    }

    //setup readback struct to sync with FBO attachment point
    x->mode = mode;
    x->width = width;
    x->height = height;
    x->fbo = (t_jit_gl_fbo *)fbocontext;
    x->ownsfbo = 0;
    x->attachment = attachment;
    
    if(attachment == GL_DEPTH_ATTACHMENT_EXT) {
        // get opengl support capabilities
        support = jit_gl_get_support();
        if(!support || !support->initialized)
        {
            jit_object_error((t_object *)x,"jit.gl.texture: unable to setup readback mechanism: opengl support uninitialized!");
            return JIT_ERR_GENERIC;
        }
        
        x->depth = support->depth_bits;
    }
    else if(attachment == GL_STENCIL_ATTACHMENT_EXT){
        jit_object_error((t_object *)x,"jit.gl.readback: stencil is invalid FBO attachment point for textures!");
        return JIT_ERR_GENERIC;
    }
    else if(attachment > GL_STENCIL_ATTACHMENT_EXT) {
        jit_object_error((t_object *)x,"jit.gl.readback: invalid FBO attachment point!");
        return JIT_ERR_GENERIC;
    }

    return JIT_ERR_NONE;
}

t_jit_err jit_gl_readback_attach_texture(
    t_jit_gl_readback *x, GLenum attachment, t_jit_gl_texture *texture, GLint miplevel, GLint zslice)
{
    t_jit_err err = JIT_ERR_NONE;
    GLuint id;

    // use either fbo or pbuffer as destination
    switch(x->mode)
    {
        case(JIT_GL_READBACK_MODE_FBO):
        {
            jit_gl_texture_destroy_data(texture);
            err = jit_gl_texture_bind(texture, 0, 0, 0);
            if(err) return err;

            err = jit_gl_texture_unbind(texture, 0, 0, 0);
            if(err) return err;

            err = jit_gl_readback_attach_texture_fbo(x, attachment, texture, miplevel, zslice);
            break;
        }
        case(JIT_GL_READBACK_MODE_PBUFFER_CTT):
        case(JIT_GL_READBACK_MODE_PBUFFER_RTT):
        {
            err = jit_gl_readback_attach_texture_pbuffer(x, attachment, texture, miplevel, zslice);
            break;
        }
    };

    return err;
}

t_jit_err jit_gl_readback_detach_texture(t_jit_gl_readback *x, GLenum attachment)
{
    t_jit_err err = JIT_ERR_NONE;

    // use either fbo or pbuffer as destination
    switch(x->mode)
    {
        case(JIT_GL_READBACK_MODE_FBO):
        {
            err = jit_gl_readback_detach_texture_fbo(x, attachment);
            break;
        }
        case(JIT_GL_READBACK_MODE_PBUFFER_CTT):
        case(JIT_GL_READBACK_MODE_PBUFFER_RTT):
        {
            err = jit_gl_readback_detach_texture_pbuffer(x, attachment);
            break;
        }
    };

    return err;
}

t_jit_err jit_gl_readback_bind(t_jit_gl_readback *x)
{
    t_jit_err err = JIT_ERR_NONE;

    // use either fbo or pbuffer as destination
    switch(x->mode)
    {
        case(JIT_GL_READBACK_MODE_FBO):
        {
            err = jit_gl_readback_bind_fbo(x);
            jit_gl_fbo_report_error(x->fbo, "jit.gl.readback: error binding framebuffer object!");
            jit_gl_report_error("jit.gl.readback: error binding framebuffer object!");
            break;
        }
        case(JIT_GL_READBACK_MODE_PBUFFER_CTT):
        case(JIT_GL_READBACK_MODE_PBUFFER_RTT):
        {
            err = jit_gl_readback_bind_pbuffer(x);
            jit_gl_report_error("jit.gl.readback: error binding pbuffer!");
            break;
        }
        default:
        {
            jit_object_error((t_object *)x,"jit.gl.readback: invalid readback mode!");
            break;
        }
    };
    return err;
}

t_jit_err jit_gl_readback_unbind(t_jit_gl_readback *x)
{
    t_jit_err err = JIT_ERR_NONE;

    // use either fbo or pbuffer as destination
    switch(x->mode)
    {
        case(JIT_GL_READBACK_MODE_FBO):
        {
            err = jit_gl_readback_unbind_fbo(x);
            break;
        }
        case(JIT_GL_READBACK_MODE_PBUFFER_CTT):
        case(JIT_GL_READBACK_MODE_PBUFFER_RTT):
        {
            err = jit_gl_readback_unbind_pbuffer(x);
            break;
        }
        default:
        {
            jit_object_error((t_object *)x,"jit.gl.readback: unable to create readback object: mode invalid!");
            err = JIT_ERR_GENERIC;
            break;
        }
    };

    return err;
}

t_jit_err jit_gl_readback_bind_attachment(t_jit_gl_readback *x, long attachment)
{
    t_jit_err err = JIT_ERR_NONE;

    // use either fbo or pbuffer as destination
    switch(x->mode)
    {
        case(JIT_GL_READBACK_MODE_FBO):
        {
            // nothing to do for FBO
            return JIT_ERR_NONE;
        }
        case(JIT_GL_READBACK_MODE_PBUFFER_CTT):
        case(JIT_GL_READBACK_MODE_PBUFFER_RTT):
        {
            return jit_gl_pbuffer_bind_texture(x->pbuffer);
        }
        default:
        {
            jit_object_error((t_object *)x,"jit.gl.readback: unable to unbind attachment: mode invalid!");
            err = JIT_ERR_GENERIC;
            break;
        }
    };

    return err;
}

t_jit_err jit_gl_readback_unbind_attachment(t_jit_gl_readback *x, long attachment)
{
    t_jit_err err = JIT_ERR_NONE;

    // use either fbo or pbuffer as destination
    switch(x->mode)
    {
        case(JIT_GL_READBACK_MODE_FBO):
        {
            // nothing to do for FBO
            return JIT_ERR_NONE;
        }
        case(JIT_GL_READBACK_MODE_PBUFFER_CTT):
        case(JIT_GL_READBACK_MODE_PBUFFER_RTT):
        {
            return jit_gl_pbuffer_unbind_texture(x->pbuffer);
        }
        default:
        {
            jit_object_error((t_object *)x,"jit.gl.readback: unable to unbind attachment: mode invalid!");
            err = JIT_ERR_GENERIC;
            break;
        }
    };

    return err;
}

t_jit_err jit_gl_readback_update(t_jit_gl_readback *x)
{
    t_jit_err err = JIT_ERR_NONE;

    // use either fbo or pbuffer as destination
    switch(x->mode)
    {
        case(JIT_GL_READBACK_MODE_FBO):
        {
            err = jit_gl_readback_update_fbo(x);
            break;
        }
        case(JIT_GL_READBACK_MODE_PBUFFER_CTT):
        case(JIT_GL_READBACK_MODE_PBUFFER_RTT):
        {
            err = jit_gl_readback_update_pbuffer(x);
            break;
        }
    };
    return err;
}

t_jit_err jit_gl_readback_destroy(t_jit_gl_readback *x)
{
    t_jit_err err = JIT_ERR_NONE;

    // use either fbo or pbuffer as destination
    switch(x->mode)
    {
        case(JIT_GL_READBACK_MODE_FBO):
        {
            if(x->ownsfbo)
                err = jit_gl_readback_destroy_fbo(x);
            break;
        }
        case(JIT_GL_READBACK_MODE_PBUFFER_CTT):
        case(JIT_GL_READBACK_MODE_PBUFFER_RTT):
        {
            err = jit_gl_readback_destroy_pbuffer(x);
            break;
        }
    };

    //delete FBO if owns it, otherwise detach from FBO context
    if(x->ownsfbo) {
        if(x->fbo)
            jit_gl_fbo_free(x->fbo);
    }
    else {
        jit_gl_fbo_detach(x->fbo, x->attachment);
    }
    x->fbo = NULL;

    if(x->pbuffer)
        jit_gl_pbuffer_free(x->pbuffer);
    x->pbuffer = NULL;

    if (x->matrix)
        jit_object_free(x->matrix);
    x->matrix = NULL;

    if(x->depthbuffer)
        jit_gl_renderbuffer_free(x->depthbuffer);
    x->depthbuffer = NULL;

    if(x->stencilbuffer)
        jit_gl_renderbuffer_free(x->stencilbuffer);
    x->stencilbuffer = NULL;

    return err;
}

t_jit_err jit_gl_readback_reset(t_jit_gl_readback *x)
{
    t_jit_err err = JIT_ERR_NONE;

    // use either fbo or pbuffer as destination
    switch(x->mode)
    {
        case(JIT_GL_READBACK_MODE_FBO):
        {
            err = jit_gl_readback_reset_fbo(x);
            break;
        }
        case(JIT_GL_READBACK_MODE_PBUFFER_CTT):
        case(JIT_GL_READBACK_MODE_PBUFFER_RTT):
        {
            err = jit_gl_readback_reset_pbuffer(x);
            break;
        }
    };

    x->mode = -1;
    x->width = 0;
    x->height = 0;
    x->depth = 0;
    x->stencil = 0;
    return err;
}

t_jit_err jit_gl_readback_readpixels(t_jit_gl_readback *x, t_symbol *matrix)
{
    char *bp;
    GLint drawbuffer;
    GLint readbuffer;
    GLboolean enabled;
    long i = 0;
    long ix = 0, iy = 0;
    long width = 0, height = 0;
    long usefloat = 0;
    
    GLenum internal, format, type;
    t_symbol *colormode;
    t_jit_object *m;
    t_jit_matrix_info info;
    t_jit_gl_context ctx = NULL;
    t_jit_err err;

    if(!x)
        return JIT_ERR_INVALID_PTR;

    ctx = jit_gl_get_context();
    if(!ctx)
        return JIT_ERR_GENERIC;

    // find the registered matrix object
    if (m = jit_object_findregistered(matrix)) 
    {
        if (!jit_object_method(m, _jit_sym_class_jit_matrix)) 
        {
            jit_object_error((t_object *)x,"jit.gl.readback:: unable to find matrix %s", matrix);
            return JIT_ERR_GENERIC;
        }
    } 
    else 
    {
        return JIT_ERR_GENERIC;
    }
    
    // get the matrix info and data pointer
    jit_object_method(m,_jit_sym_getinfo,&info);
    jit_object_method(m,_jit_sym_getdata,&bp);

    // skip invalid data
    if(!bp)
        return JIT_ERR_INVALID_PTR;
    
    // get the dimensions and datatype
    width = info.dim[0];
    height = info.dim[1];   
    usefloat = (info.type == _jit_sym_float32);
    
    // hack for 16 byte aligned data, not a valid byte alignment for gl
    if (width == info.dim[0]) 
        width = info.dimstride[1] / info.dimstride[0];
            
    // detemine colormode from planecount
    switch(info.planecount)
    {
        case 1:
            colormode = ps_jit_gl_colormode_luminance;
            break;
        case 2:
            colormode = ps_jit_gl_colormode_lumalpha;
            break;
        case 3:
            colormode = ps_jit_gl_colormode_rgb;        
            break;
        case 4:
            colormode = ps_jit_gl_colormode_argb;       
        default:
            break;          
    };
    
    // choose the internal format
    err = jit_gl_texture_choose_internal_format(colormode, info.type, gensym("static"), &internal, &format, &type, 0);  
    if(err) return err;
    
    glGetIntegerv(GL_DRAW_BUFFER, &drawbuffer);
    glGetIntegerv(GL_READ_BUFFER, &readbuffer);

    if(x->mode == JIT_GL_READBACK_MODE_FBO)
    {
        glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);
    }
    else
    {
        glReadBuffer(drawbuffer);
    }

    glPixelStorei(GL_PACK_ROW_LENGTH, (info.dimstride[1] / info.dimstride[0]));
    glPixelStorei(GL_PACK_ALIGNMENT, 8);

    // perform the readback
    glReadPixels(ix, iy, width, height, format, type, bp);

    // restore pixel store
    glPixelStorei(GL_PACK_ROW_LENGTH, 0);
    glPixelStorei(GL_PACK_ALIGNMENT, 1);
    glReadBuffer(readbuffer);

    return JIT_ERR_NONE;
}

Copyright © 2008, Cycling '74