Max 5 API Reference

jit.gl.pbo.c

/*
 * Copyright 2001-2005 - Cycling '74
 * Derek Gerstmann - derek@cycling74.com
 *
 * Struct and associated methods for maintaining an OpenGL 
 * pixel buffer object (PBO).
 *
 */

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

#include "jit.gl.pbo.h"
#include "jit.gl.support.h"

void *_jit_gl_pbo_class;

//targets
static t_symbol *ps_jit_gl_pbo_pixel_pack_buffer;
static t_symbol *ps_jit_gl_pbo_pixel_unpack_buffer;

//usages
static t_symbol *ps_jit_gl_pbo_stream_draw;
static t_symbol *ps_jit_gl_pbo_stream_read;
static t_symbol *ps_jit_gl_pbo_stream_copy;
static t_symbol *ps_jit_gl_pbo_static_draw;
static t_symbol *ps_jit_gl_pbo_static_read;
static t_symbol *ps_jit_gl_pbo_static_copy;
static t_symbol *ps_jit_gl_pbo_dynamic_draw;
static t_symbol *ps_jit_gl_pbo_dynamic_read;
static t_symbol *ps_jit_gl_pbo_dynamic_copy;

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

t_jit_err jit_gl_pbo_init(void) 
{
    long attrflags=0;
    long ob3d_flags=0;
    t_jit_object *attr;
    void * ob3d;
    
    _jit_gl_pbo_class = jit_class_new("jit_gl_pbo", (method)jit_gl_pbo_new, (method)jit_gl_pbo_free,
                sizeof(t_jit_gl_pbo),A_DEFSYM,0L);
    
    // set up object extension for 3d object, customized with flags
    ob3d_flags |= JIT_OB3D_NO_ROTATION_SCALE;
    ob3d_flags |= JIT_OB3D_NO_POLY_VARS;
    ob3d_flags |= JIT_OB3D_NO_BLEND;
    ob3d_flags |= JIT_OB3D_NO_TEXTURE;
    ob3d_flags |= JIT_OB3D_NO_DEPTH;
    ob3d_flags |= JIT_OB3D_NO_ANTIALIAS;
    ob3d_flags |= JIT_OB3D_NO_FOG;
    ob3d_flags |= JIT_OB3D_NO_LIGHTING_MATERIAL;
    ob3d_flags |= JIT_OB3D_NO_COLOR;
    ob3d = jit_ob3d_setup(_jit_gl_pbo_class, calcoffset(t_jit_gl_pbo, ob3d), ob3d_flags);
    
    // add attributes
    attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
    attr = jit_object_new(_jit_sym_jit_attr_offset,"planecount",_jit_sym_long,attrflags,
        (method)0L,(method)jit_gl_pbo_setattr_planecount,calcoffset(t_jit_gl_pbo,planecount));
    jit_class_addattr(_jit_gl_pbo_class,attr);
    
    attr = jit_object_new(_jit_sym_jit_attr_offset,"type",_jit_sym_symbol,attrflags,
        (method)0L,(method)jit_gl_pbo_setattr_type,calcoffset(t_jit_gl_pbo,type));
    jit_class_addattr(_jit_gl_pbo_class,attr);
    
    attr = jit_object_new(_jit_sym_jit_attr_offset_array,"offset",_jit_sym_long,2,attrflags,
        (method)0L,(method)jit_gl_pbo_setattr_offset,NULL,calcoffset(t_jit_gl_pbo,offset));
    jit_class_addattr(_jit_gl_pbo_class,attr);
    
    attr = jit_object_new(_jit_sym_jit_attr_offset_array,"dim",_jit_sym_long,2,attrflags,
        (method)0L,(method)jit_gl_pbo_setattr_dim,NULL,calcoffset(t_jit_gl_pbo,dim));
    jit_class_addattr(_jit_gl_pbo_class,attr);
    
    attr = jit_object_new(_jit_sym_jit_attr_offset,"target",_jit_sym_symbol,attrflags,
        (method)0L,(method)jit_gl_pbo_setattr_target,calcoffset(t_jit_gl_pbo,target));
    jit_class_addattr(_jit_gl_pbo_class,attr);
    
    attr = jit_object_new(_jit_sym_jit_attr_offset,"usage",_jit_sym_symbol,attrflags,
        (method)0L,(method)jit_gl_pbo_setattr_usage,calcoffset(t_jit_gl_pbo,usage));
    jit_class_addattr(_jit_gl_pbo_class,attr);
    
    jit_class_addmethod(_jit_gl_pbo_class, (method)jit_gl_pbo_draw, "ob3d_draw", A_CANT, 0L);
    jit_class_addmethod(_jit_gl_pbo_class, (method)jit_gl_pbo_dest_changed, "dest_changed", A_CANT, 0L);
    
    // must register for ob3d
    jit_class_addmethod(_jit_gl_pbo_class, (method)jit_object_register, "register", A_CANT, 0L);
    jit_class_addmethod(_jit_gl_pbo_class, (method)jit_gl_pbo_dest_closing, "dest_closing", A_CANT, 0L);
    
    jit_class_addmethod(_jit_gl_pbo_class, (method)jit_gl_pbo_destroy, "destroy", A_CANT, 0L);
    
    //bind/unbind
    jit_class_addmethod(_jit_gl_pbo_class, (method)jit_gl_pbo_bind, "bind", A_DEFER_LOW, 0L);
    jit_class_addmethod(_jit_gl_pbo_class, (method)jit_gl_pbo_unbind, "unbind", A_DEFER_LOW, 0L);
    
    //to/from matrix
    jit_class_addmethod(_jit_gl_pbo_class, (method)jit_gl_pbo_from_matrix, "from_matrix", A_CANT, 0L);
    jit_class_addmethod(_jit_gl_pbo_class, (method)jit_gl_pbo_to_matrix, "to_matrix", A_CANT, 0L);

    jit_class_addmethod(_jit_gl_pbo_class, (method)jit_gl_pbo_readpixels, "readpixels", A_CANT, 0L);
    jit_class_addmethod(_jit_gl_pbo_class, (method)jit_gl_pbo_getteximage, "getteximage", A_CANT, 0L);


    jit_class_register(_jit_gl_pbo_class);
    
    ps_jit_gl_pbo_pixel_pack_buffer = gensym("pixel_pack_buffer");
    ps_jit_gl_pbo_pixel_unpack_buffer = gensym("pixel_unpack_buffer");
    ps_jit_gl_pbo_stream_draw = gensym("stream_draw");
    ps_jit_gl_pbo_stream_read = gensym("stream_read");
    ps_jit_gl_pbo_stream_copy = gensym("stream_copy");
    ps_jit_gl_pbo_static_draw = gensym("static_draw");
    ps_jit_gl_pbo_static_read = gensym("static_read");
    ps_jit_gl_pbo_static_copy = gensym("static_copy");
    ps_jit_gl_pbo_dynamic_draw = gensym("dynamic_draw");
    ps_jit_gl_pbo_dynamic_read = gensym("dynamic_read");
    ps_jit_gl_pbo_dynamic_copy = gensym("dynamic_copy");
    
    return JIT_ERR_NONE;
}


t_jit_gl_pbo *jit_gl_pbo_new()
{
    t_jit_gl_pbo *x = NULL;

    if(x = (t_jit_gl_pbo *)jit_object_alloc(_jit_gl_pbo_class))
    {
        jit_gl_pbo_reset(x);
    }

    return x;
}

void jit_gl_pbo_free(t_jit_gl_pbo *x)
{
    if(x)
    {
        jit_gl_pbo_destroy(x);
    }
}

#ifdef __glext_h
    #error "__glext_h"
#endif

GLenum jit_gl_pbo_gltarget_from_target(t_symbol *target)
{
    if(target == ps_jit_gl_pbo_pixel_pack_buffer) {
        return GL_PIXEL_PACK_BUFFER_EXT;
    }
    else {
        return GL_PIXEL_UNPACK_BUFFER_EXT;
    }
}

GLenum jit_gl_pbo_glusage_from_usage(t_symbol *usage)
{
    if(usage == ps_jit_gl_pbo_stream_draw) {
        return GL_STREAM_DRAW_ARB;
    }
    else if(usage == ps_jit_gl_pbo_stream_read) {
        return GL_STREAM_READ_ARB;
    }
    else if(usage == ps_jit_gl_pbo_stream_copy) {
        return GL_STREAM_COPY_ARB;
    }
    else if(usage == ps_jit_gl_pbo_static_draw) {
        return GL_STATIC_DRAW_ARB;
    }
    else if(usage == ps_jit_gl_pbo_static_read) {
        return GL_STATIC_READ_ARB;
    }
    else if(usage == ps_jit_gl_pbo_static_copy) {
        return GL_STATIC_COPY_ARB;
    }
    else if(usage == ps_jit_gl_pbo_dynamic_draw) {
        return GL_DYNAMIC_DRAW_ARB;
    }
    else if(usage == ps_jit_gl_pbo_dynamic_read) {
        return GL_DYNAMIC_READ_ARB;
    }
    else if(usage == ps_jit_gl_pbo_dynamic_copy) {
        return GL_DYNAMIC_COPY_ARB;
    }
    
    //default
    return GL_STREAM_DRAW_ARB;
}

GLenum jit_gl_pbo_gltype_from_type(t_symbol *type)
{
    if(type == _jit_sym_float32) {
        return GL_FLOAT;
    }
    else if(type == _jit_sym_long) {
        return GL_UNSIGNED_INT;
    }
    else {
        return GL_UNSIGNED_BYTE;
    }
}

long jit_gl_pbo_datasize_from_gltype(GLenum gltype)
{
    switch(gltype) {
    case GL_FLOAT:          return sizeof(GLfloat); break;
    case GL_UNSIGNED_INT:   return sizeof(GLuint); break;

    case GL_UNSIGNED_BYTE:
    default:                return sizeof(GLubyte); break;
    }
}

t_jit_err jit_gl_pbo_create(t_jit_gl_pbo *x)
{
    GLuint id;
    t_jit_err err;
    long bpp, size;

    //calculate size info to verify if we need to destroy
    x->gltype = jit_gl_pbo_gltype_from_type(x->type);
    bpp = jit_gl_pbo_datasize_from_gltype(x->gltype);
    
    size = x->dim[0]*x->dim[1]*x->planecount*bpp;

    // delete existing cache if buffer size is different
    if(x->size != size)
    {
        err = jit_gl_pbo_destroy(x);    
        if(err) return err;
    }
    x->size = size;

    // create the buffer object
    if(x->id < 0)
    {
        glGenBuffersARB(1, &id);
        x->id = id;
    }
    
    if(x->id < 0)
    {
        jit_object_error((t_object *)x,"jit.gl.texture: unable to create pixel buffer object.");            
        return JIT_ERR_GENERIC;
    }

    x->recreate = FALSE;    //must come before bind to avoid infinite recursion

    // bind the buffer
    err = jit_gl_pbo_bind(x);
    if(err) return err;

    // allocate buffer
    glBufferDataARB(x->gltarget, x->size, NULL, x->glusage);
    jit_gl_report_error("jit.gl: error allocating pixel buffer object!");

    // unbind buffer
    err = jit_gl_pbo_unbind(x);
    if(err) return err;

    return JIT_ERR_NONE;
}

t_jit_err jit_gl_pbo_setattr_dim(t_jit_gl_pbo *x, void *attr, long argc, t_atom *argv)
{
    long v;
    long i, c, p;
    long changed = FALSE;

    if (x)
    {
        for(i = 0; i < MIN(argc, 2); i++)
        {
            v = jit_atom_getlong(argv+i);
            if(x->dim[i] != v)
            {
                x->dim[i] = v;
                changed = TRUE;
            }
        }
        
        if(changed)
        {
            x->destroy = TRUE;
            x->recreate = TRUE;
        }
        
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_gl_pbo_setattr_offset(t_jit_gl_pbo *x, void *attr, long argc, t_atom *argv)
{
    long v;
    long i, c, p;
    long changed = FALSE;

    if (x)
    {
        for(i = 0; i < MIN(argc, 2); i++)
        {
            v = jit_atom_getlong(argv+i);
            if(x->offset[i] != v)
            {
                x->offset[i] = v;
                changed = TRUE;
            }
        }
        
        if(changed)
        {
            x->destroy = TRUE;
            x->recreate = TRUE;
        }
        
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_gl_pbo_setattr_target(t_jit_gl_pbo *x, void *attr, long argc, t_atom *argv)
{
    if(x)
    {
        if(argc)
        {
            t_symbol *target = jit_atom_getsym(argv);
            if(target != x->target)
            {
                x->target = target;
                x->gltarget = jit_gl_pbo_gltarget_from_target(x->target);
                x->destroy = TRUE;
                x->recreate = TRUE;
            }
        }
        
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_gl_pbo_setattr_usage(t_jit_gl_pbo *x, void *attr, long argc, t_atom *argv)
{
    if(x)
    {
        if(argc)
        {
            t_symbol *usage = jit_atom_getsym(argv);
            if(usage != x->usage)
            {
                x->usage = usage;
                x->glusage = jit_gl_pbo_glusage_from_usage(x->usage);
                x->destroy = TRUE;
                x->recreate = TRUE;
            }
        }
        
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_gl_pbo_setattr_planecount(t_jit_gl_pbo *x, void *attr, long argc, t_atom *argv)
{
    if(x)
    {
        if(argc)
        {
            long planecount = jit_atom_getlong(argv);
            if(planecount != x->planecount)
            {
                x->planecount = planecount;
                x->destroy = TRUE;
                x->recreate = TRUE;
            }
        }
        
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_gl_pbo_setattr_type(t_jit_gl_pbo *x, void *attr, long argc, t_atom *argv)
{
    if(x) {
        if(argc) {
            t_symbol *type = jit_atom_getsym(argv);
            if(type != x->type) {
                x->type = type;
                x->destroy = TRUE;
                x->recreate = TRUE;
            }
        }
        
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}


//could also support mcinfo here in the future
t_jit_err jit_gl_pbo_from_matrix(t_jit_gl_pbo *x, t_jit_matrix_info *minfo, char *bp)
{
    GLuint id;
    t_jit_err err;

    if(!x || !minfo || !bp)
        return JIT_ERR_GENERIC;

    // delete existing cache if pbo size has changed
    if(x->size != minfo->size)
    {
    
        //make pbo equivalent to matrix
        x->planecount = minfo->planecount;
        x->type = minfo->type;
        x->offset[0] = 0;
        x->offset[1] = 0;
        x->dim[0] = minfo->dim[0];
        x->dim[1] = minfo->dim[1];
        
        err = jit_gl_pbo_create(x); 
        if(err) return err;
    }

    // bind the buffer
    err = jit_gl_pbo_bind(x);
    if(err) return err;

    // request buffer handle
    x->handle = (char*)glMapBufferARB(x->gltarget, GL_WRITE_ONLY);
    if(!x->handle)
    {
        jit_gl_report_error("jit.gl: error mapping pixel buffer object!");
        jit_object_error((t_object *)x,"jit.gl.pbo: unable to allocate pixel buffer: out of memory!");
        return JIT_ERR_GENERIC;
    }
        
    // modify buffer data
    jit_copy_bytes(x->handle, bp, x->size);

    // release buffer handle
    if (!glUnmapBufferARB(x->gltarget)) 
    {
        // handle error
        jit_gl_report_error("jit.gl: error unmapping pixel buffer object!");
        jit_object_error((t_object *)x,"jit.gl.pbo: unable to update pixel buffer object");
        return JIT_ERR_GENERIC;
    }

    // reset current buffer state
    err = jit_gl_pbo_unbind(x);
    if(err) return err;

    return JIT_ERR_NONE;
}

// x->offset and x->dim are taken from an origin at the top left 
// of the image, however in OpenGL glReadPixels operations, 
// the buffer's origin is bottom left so we have to flip the
// buffer copy about the horizontal (in the Y dimension)
t_jit_err jit_gl_pbo_to_matrix(t_jit_gl_pbo *x, t_jit_matrix_info *minfo, char *bp)
{
    t_jit_err err = JIT_ERR_NONE;
    char *data, *gl_bp, *mat_bp;
    long i, j, k;
    long planecount, lo_x, lo_y, hi_x, hi_y;

    err = jit_gl_pbo_bind(x);
    if(err) return err;
    
    if(x->type != minfo->type) {
        jit_object_error((t_object *)x,"jit.gl.pbo: matrix and pbo have different types");
        return JIT_ERR_GENERIC;
    }
    if(x->planecount != minfo->planecount) {
        jit_object_error((t_object *)x,"jit.gl.pbo: matrix and pbo have different planecounts");
        return JIT_ERR_GENERIC;
    }
    else {
        planecount = x->planecount;
    }
    //check matrix bounds
    lo_x = CLAMP(x->offset[0], 0, minfo->dim[0]);
    lo_y = CLAMP(x->offset[1], 0, minfo->dim[1]);
    
    hi_x = CLAMP(x->offset[0]+x->dim[0], lo_x, minfo->dim[0]);
    hi_y = CLAMP(x->offset[1]+x->dim[1], lo_y, minfo->dim[1]);
    
    jit_gl_report_error("jit.gl.pbo: error before mapping data");
    data = (char *)glMapBuffer(x->gltarget, GL_READ_ONLY);
    if(data)
    {
        for(j = lo_y; j < hi_y; j++)
        {
            long glidx = j - lo_y;
            long matidx = minfo->dim[1] - j-1;  //+ (minfo->dim[1] - hi_y - lo_y);
            mat_bp = (char *)(bp + matidx*minfo->dimstride[1]);
            gl_bp = (char *)(data + glidx*x->dim[0]*x->planecount);
            
            for(i = lo_x; i < hi_x; i++)
            {
                mat_bp[0] = gl_bp[3];
                mat_bp[1] = gl_bp[2];
                mat_bp[2] = gl_bp[1];
                mat_bp[3] = gl_bp[0];
                
                mat_bp += 4;
                gl_bp += 4;
            }
        }
    }
    else {
        jit_object_error((t_object *)x,"jit.gl.pbo: data not mapped in copy to matrix");
    }
    jit_gl_report_error("jit.gl.pbo: error mapping data");
    
    if(!glUnmapBuffer(x->gltarget)) {
        jit_object_error((t_object *)x,"jit.gl.pbo: error unmapping buffer");
    }
    
    err = jit_gl_pbo_unbind(x);
    return err;
}

t_jit_err jit_gl_pbo_dest_changed(t_jit_gl_pbo *x)
{
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_pbo_dest_closing(t_jit_gl_pbo *x)
{
    jit_gl_pbo_destroy(x);
    return JIT_ERR_NONE;
}

//asynchronous read to pbo
t_jit_err jit_gl_pbo_readpixels(t_jit_gl_pbo *x)
{
    t_jit_err err = JIT_ERR_NONE;
    
    err = jit_gl_pbo_bind(x);
    if(err) return err;
    
    if(x->id > 0) {
        //may have to use a different pixel format etc. on windows??
        switch(x->planecount) {
        case 4: glReadPixels(x->offset[0], x->offset[1], x->dim[0], x->dim[1], GL_BGRA, x->gltype, 0); break;
        case 3: glReadPixels(x->offset[0], x->offset[1], x->dim[0], x->dim[1], GL_BGR, x->gltype, 0); break;
        case 2: glReadPixels(x->offset[0], x->offset[1], x->dim[0], x->dim[1], GL_LUMINANCE_ALPHA, x->gltype, 0); break;
        case 1: glReadPixels(x->offset[0], x->offset[1], x->dim[0], x->dim[1], GL_LUMINANCE, x->gltype, 0); break;
        }
    }
    
    err = jit_gl_pbo_unbind(x);
    return err;
}

//asynchronous texture read to pbo
t_jit_err jit_gl_pbo_getteximage(t_jit_gl_pbo *x, GLenum tex_target)
{
    t_jit_err err = JIT_ERR_NONE;
    
    err = jit_gl_pbo_bind(x);
    if(err) return err;
    
    if(x->id > 0) {
        //may have to use a different pixel format etc. on windows??
        switch(x->planecount) {
        case 4: glGetTexImage(tex_target, 0, GL_RGBA, x->gltype, 0); break;
        case 3: glGetTexImage(tex_target, 0, GL_BGR, x->gltype, 0); break;
        case 2: glGetTexImage(tex_target, 0, GL_LUMINANCE_ALPHA, x->gltype, 0); break;
        case 1: glGetTexImage(tex_target, 0, GL_LUMINANCE, x->gltype, 0); break;
        }
    }
    
    err = jit_gl_pbo_unbind(x);
    return err;
}

t_jit_err jit_gl_pbo_draw(t_jit_gl_pbo *x)
{
    t_atom s;
    t_jit_err err = JIT_ERR_NONE;
    
    // dummy, does nothing
    return err;
}


t_jit_err jit_gl_pbo_bind(t_jit_gl_pbo *x)
{
    GLuint id;

    if(!x)
        return JIT_ERR_INVALID_PTR;

    if(x->destroy) jit_gl_pbo_destroy(x);
    if(x->recreate || x->id <= 0) jit_gl_pbo_create(x);

    // bind the pbo
    if(x->id > 0)
    {
        id = x->id;
        glBindBufferARB(x->gltarget, id);
        jit_gl_report_error("jit.gl: error binding pixel buffer object!");
    }
    return JIT_ERR_NONE;      
}

t_jit_err jit_gl_pbo_unbind(t_jit_gl_pbo *x)
{
    if(!x)
        return JIT_ERR_INVALID_PTR;

    glBindBufferARB(x->gltarget, 0);   
    jit_gl_report_error("jit.gl: error unbinding pixel buffer object!");
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_pbo_destroy(t_jit_gl_pbo *x)
{
    GLuint id;

    if(!x)
        return JIT_ERR_INVALID_PTR;

    if(x->id > 0)
    {
        id = x->id;
        jit_gl_pbo_unbind(x);
        glDeleteBuffersARB(1, &id);
        x->id = -1;
    }

    x->handle = NULL;
    x->size = 0;
    x->destroy = FALSE;
    
    return JIT_ERR_NONE;
}

t_jit_err jit_gl_pbo_reset(t_jit_gl_pbo *x)
{
    if(!x)
        return JIT_ERR_INVALID_PTR;

    x->id = -1;
    x->handle = NULL;
    x->size = 0;
    x->planecount = 4;
    x->offset[0] = 0;
    x->offset[1] = 0;
    x->dim[0] = 1;
    x->dim[1] = 1;
    x->type = _jit_sym_char;
    x->gltype = jit_gl_pbo_gltype_from_type(x->type);
    x->target = ps_jit_gl_pbo_pixel_pack_buffer;
    x->gltarget = jit_gl_pbo_gltarget_from_target(x->target);
    x->usage = ps_jit_gl_pbo_stream_draw;
    x->glusage = jit_gl_pbo_glusage_from_usage(x->usage);
    x->destroy = FALSE;
    
    return JIT_ERR_NONE;
}
/****************************************************************************/

Copyright © 2008, Cycling '74