Max 5 API Reference

jit.bin.c

/* 
    jit.bin.c
    Copyright 2001-2005 - Cycling '74
    Jeremy Bernstein jeremy@bootsquad.com
    Joshua Kit Clayton jkc@cycling74.com
*/

#include "jit.common.h"
#include "jit.bin.h"

/**
 *  @defgroup binmod Binary Module
    @ingroup jitter
 */

t_jit_err jit_bin_read_matrix_ndim      (t_filehandle fh, long dimcount, long *dim, t_jit_matrix_info *info, char *bp);
t_jit_err jit_bin_read_matrix_char      (t_filehandle fh, long *dim, t_jit_matrix_info *info, char *bp);
t_jit_err jit_bin_read_matrix_long      (t_filehandle fh, long *dim, t_jit_matrix_info *info, char *bp);
t_jit_err jit_bin_read_matrix_float32   (t_filehandle fh, long *dim, t_jit_matrix_info *info, char *bp);
t_jit_err jit_bin_read_matrix_float64   (t_filehandle fh, long *dim, t_jit_matrix_info *info, char *bp);

t_jit_err jit_bin_write_matrix_ndim     (t_filehandle fh, long dimcount, long *dim, t_jit_matrix_info *info, char *bp);
t_jit_err jit_bin_write_matrix_char     (t_filehandle fh, long *dim, t_jit_matrix_info *info, char *bp);
t_jit_err jit_bin_write_matrix_long     (t_filehandle fh, long *dim, t_jit_matrix_info *info, char *bp);
t_jit_err jit_bin_write_matrix_float32  (t_filehandle fh, long *dim, t_jit_matrix_info *info, char *bp);
t_jit_err jit_bin_write_matrix_float64  (t_filehandle fh, long *dim, t_jit_matrix_info *info, char *bp);

/**
 * Reads the header of a JXF binary file.
 *
 * @ingroup binmod 
 *
 * @param   fh          t_filehandle file handle
 * @param   version     version of the binary file format (ie JIT_BIN_VERSION_1)
 * @param   filesize    the size of the file
 * 
 * @return  t_jit_err error code.
 *
 */
t_jit_err jit_bin_read_header(t_filehandle fh, ulong *version, long *filesize)
{
    long err=JIT_ERR_NONE,size;
    long tmp[6];
    
    *version = 0;
    *filesize = 0;
    
    if (fh) {
        size=24;
        sysfile_setpos(fh,fsFromStart,0);
        if ((err=sysfile_read(fh, &size, &tmp))||(size!=24))
            goto out;

        if ((BE_I32(tmp[0])!=JIT_BIN_CHUNK_CONTAINER)&&(BE_I32(tmp[2])!=JIT_BIN_FORMAT)) {
            err = JIT_ERR_GENERIC;
            goto out;
        }
            
        *filesize = BE_I32(tmp[1]);
        
        if ((BE_I32(tmp[3])!=JIT_BIN_CHUNK_FORMAT_VERSION)&&(tmp[4]!=BE_I32(12))) {
            err = JIT_ERR_GENERIC;
            goto out;
        }
        
        *version = BE_I32(tmp[5]);      
    
    } else {
        err = JIT_ERR_INVALID_PTR;
    }
out:    
    return err;
}


/**
 * Reads the the info of a chunk from a JXF binary file.
 *
 * @ingroup binmod 
 *
 * @param   fh          t_filehandle file handle
 * @param   ckid        chunk ID (ie JIT_BIN_CHUNK_CONTAINER, JIT_BIN_CHUNK_MATRIX)
 * @param   cksize      the size of the chunk
 * 
 * @return  t_jit_err error code.
 *
 */
t_jit_err jit_bin_read_chunk_info(t_filehandle fh, ulong *ckid, long *cksize)
{
    long err=JIT_ERR_NONE,size;
    long tmp[2];
    
    *ckid = 0;
    *cksize = 0;
    
    if (fh) {
        size=8;
        if ((err=sysfile_read(fh, &size, &tmp))&&(size!=8))
            goto out;

        *ckid   = BE_I32(tmp[0]);
        *cksize = BE_I32(tmp[1]);
        sysfile_setpos(fh,fsFromMark,-8);   
    } else {
        err = JIT_ERR_INVALID_PTR;
    }
out:    
    return err;
}

/**
 * Writes the header of a JXF binary file.
 *
 * @ingroup binmod 
 *
 * @param   fh          t_filehandle file handle
 * @param   filesize    the size of the file
 * 
 * @return  t_jit_err error code.
 *
 */
t_jit_err jit_bin_write_header(t_filehandle fh, long filesize)
{
    long err=JIT_ERR_NONE,size;
    long tmp[6];
    
    if (fh) {
        tmp[0] = BE_I32(JIT_BIN_CHUNK_CONTAINER);
        tmp[1] = BE_I32(filesize);
        tmp[2] = BE_I32(JIT_BIN_FORMAT);
        tmp[3] = BE_I32(JIT_BIN_CHUNK_FORMAT_VERSION);
        tmp[4] = BE_I32(12);
        tmp[5] = BE_I32(JIT_BIN_VERSION_1);
        
        size=24;
        sysfile_setpos(fh,fsFromStart,0);
        err = sysfile_write(fh, &size, &tmp); 
    
    } else {
        err = JIT_ERR_INVALID_PTR;
    }
    
    return err;
}

/**
 * Reads matrix data from a JXF binary file.
 *
 * @ingroup binmod 
 *
 * @param   fh          t_filehandle file handle
 * @param   matrix      the matrix data
 * 
 * @return  t_jit_err error code.
 *
 */
t_jit_err jit_bin_read_matrix(t_filehandle fh, void *matrix)
{
    long err = JIT_ERR_NONE, i;
    t_jit_matrix_info info;
    long dim[JIT_MATRIX_MAX_DIMCOUNT];
    char *bp;
    long savelock;
    long tmp[JIT_MATRIX_MAX_DIMCOUNT],cksize,size,offset,points,typesize,typeID;
    
    if (fh&&matrix) {
    
        //read standard matrix chunk info
        size = 24;
        if (err = sysfile_read(fh, &size, &tmp)) 
            goto out; 

        if (BE_I32(tmp[0])!=JIT_BIN_CHUNK_MATRIX) { 
            err = JIT_ERR_GENERIC;
            goto out;
        }
        
        info.flags = 0;
        
        cksize          = BE_I32(tmp[1]);
        offset          = BE_I32(tmp[2]);
        typeID          = BE_I32(tmp[3]);
        info.planecount = BE_I32(tmp[4]);
        info.dimcount   = BE_I32(tmp[5]);

        switch (typeID) {
        case JIT_BIN_TYPE_CHAR:
            info.type = _jit_sym_char;
            break;
        case JIT_BIN_TYPE_LONG:
            info.type = _jit_sym_long;
            break;
        case JIT_BIN_TYPE_FLOAT32:
            info.type = _jit_sym_float32;
            break;
        case JIT_BIN_TYPE_FLOAT64:
            info.type = _jit_sym_float64;
            break;
        default:
            err = JIT_ERR_GENERIC;
            goto out;
        }
        
        //read dim values
        size = info.dimcount*4;
        if (err = sysfile_read(fh, &size, &tmp)) 
            goto out; 
        
        for (i=0;i<info.dimcount;i++) {
            dim[i] = info.dim[i] = BE_I32(tmp[i]);
        }
        
        //resize the matrix
        
        if (err=(t_jit_err)jit_object_method(matrix,_jit_sym_setinfo,&info))
            goto out;
            
        savelock = (long) jit_object_method(matrix,_jit_sym_lock,1);
        jit_object_method(matrix,_jit_sym_getinfo, &info);
        jit_object_method(matrix, _jit_sym_getdata, &bp);
        if (!bp) { err=JIT_ERR_GENERIC; goto clean;}
                
        //read the data
        err = jit_bin_read_matrix_ndim(fh, info.dimcount, dim, &info, bp);
    } else {
        return JIT_ERR_INVALID_PTR;
    }
    
clean:
    jit_object_method(matrix, gensym("lock"), savelock);
out:
    //exporting this as part of API, so removed error posting -bbn
    //if (err) jit_object_post((t_object *)x,"error %ld reading file", err); 
    return err;
}


t_jit_err jit_bin_read_matrix_ndim(t_filehandle fh, long dimcount, long *dim, t_jit_matrix_info *info, char *bp)
{
    char *p;
    long i;
    t_jit_err err = JIT_ERR_NONE;
        
    if (dimcount<1) return err; //safety
    
    switch(dimcount) {
    case 1:
        dim[1]=1;
    case 2:
        if (info->type == _jit_sym_char) // these functions located in m2t.c
            err = jit_bin_read_matrix_char(fh, dim, info, bp);
        else if (info->type == _jit_sym_long)
            err = jit_bin_read_matrix_long(fh, dim, info, bp);
        else if (info->type == _jit_sym_float32)
            err = jit_bin_read_matrix_float32(fh, dim, info, bp);
        else if (info->type == _jit_sym_float64)
            err = jit_bin_read_matrix_float64(fh, dim, info, bp);
        break;
    default:
        for (i = 0; i < dim[dimcount-1]; i++) {
            p = bp + i * info->dimstride[dimcount-1];
            jit_bin_read_matrix_ndim(fh, dimcount-1, dim, info, p);
        }
    }
    return err;
}


t_jit_err jit_bin_read_matrix_char(t_filehandle fh, long *dim, t_jit_matrix_info *info, char *bp)
{
    long i,width,height,planecount;
    uchar *p;
    long err=JIT_ERR_NONE;
    long size,size0;
    
    width = dim[0];
    height = dim[1];
    planecount = info->planecount;
    size0 = width*planecount;
    
    for (i=0;i<height;i++) {
        p = (uchar *)(bp + i*info->dimstride[1]);
        size = size0;
        if ((err=sysfile_read(fh,&size,p))||(size!=size0)) {
            //exporting this as part of API, so removed error posting -bbn
            //jit_object_post((t_object *)x,"error %ld reading file", err);
            goto out;
        }
    }   

out:
    return err;
}

t_jit_err jit_bin_read_matrix_long(t_filehandle fh, long *dim, t_jit_matrix_info *info, char *bp)
{
    long i,width,height,planecount;
    uchar *p;
    long err=JIT_ERR_NONE;
    long size,size0;
    
    width = dim[0];
    height = dim[1];
    planecount = info->planecount;
    size0 = width*planecount*4;
    
    for (i=0;i<height;i++) {
        p = (uchar *)(bp + i*info->dimstride[1]);
        size = size0;
        if ((err=sysfile_read(fh,&size,p))||(size!=size0)) {
                //exporting this as part of API, so removed error posting -bbn
                //jit_object_post((t_object *)x,"error %ld reading file", err);
            goto out;
        }
    }
    #ifdef JIT_LITTLE_ENDIAN
    {
        long j,k,tmp,*lp;
    
        for (i=0;i<height;i++) {
            lp = (long *)(bp + i*info->dimstride[1]);
            for (j=0;j<width;j++) {
                for (k=0;k<planecount;k++) {
                    tmp = *lp;
                    *lp++ = SWAP32(tmp);
                }
            }
        }
    }
    #endif
out:    
    return err;
}

t_jit_err jit_bin_read_matrix_float32(t_filehandle fh, long *dim, t_jit_matrix_info *info, char *bp)
{
    long i,width,height,planecount;
    uchar *p;
    long err=JIT_ERR_NONE;
    long size,size0;
    
    width = dim[0];
    height = dim[1];
    planecount = info->planecount;
    size0 = width*planecount*4;
    
    for (i=0;i<height;i++) {
        p = (uchar *)(bp + i*info->dimstride[1]);
        size = size0;
        if ((err=sysfile_read(fh,&size,p))||(size!=size0)) {
            //exporting this as part of API, so removed error posting -bbn
            //jit_object_post((t_object *)x,"error %ld reading file", err);
            goto out;
        }
    }
    #ifdef JIT_LITTLE_ENDIAN
    {
        long j,k;
        float tmp,*fp;
    
        for (i=0;i<height;i++) {
            fp = (float *)(bp + i*info->dimstride[1]);
            for (j=0;j<width;j++) {
                for (k=0;k<planecount;k++) {
                    tmp = *fp;
                    *fp++ = swapf32(tmp);
                }
            }
        }
    }
    #endif
out:    
    return err;
}

t_jit_err jit_bin_read_matrix_float64(t_filehandle fh, long *dim, t_jit_matrix_info *info, char *bp)
{
    long i,width,height,planecount;
    uchar *p;
    long err=JIT_ERR_NONE;
    long size,size0;
    
    width = dim[0];
    height = dim[1];
    planecount = info->planecount;
    size0 = width*planecount*8;
    
    for (i=0;i<height;i++) {
        p = (uchar *)(bp + i*info->dimstride[1]);
        size = size0;
        if ((err=sysfile_read(fh,&size,p))||(size!=size0)) {
            //exporting this as part of API, so removed error posting -bbn
            //jit_object_post((t_object *)x,"error %ld reading file", err);
            goto out;
        }
    }
    #ifdef JIT_LITTLE_ENDIAN
    {
        long j,k;
        double tmp,*fp;
    
        for (i=0;i<height;i++) {
            fp = (double *)(bp + i*info->dimstride[1]);
            for (j=0;j<width;j++) {
                for (k=0;k<planecount;k++) {
                    tmp = *fp;
                    *fp++ = swapf64(tmp);
                }
            }
        }
    }
    #endif
out:    
    return err;
}

/**
 * Writes a matrix to a JXF binary file.
 *
 * @ingroup binmod 
 *
 * @param   fh          t_filehandle file handle
 * @param   matrix      the matrix data
 * 
 * @return  t_jit_err error code.
 *
 */
t_jit_err jit_bin_write_matrix(t_filehandle fh, void *matrix)
{
    long err = JIT_ERR_NONE, i;
    t_jit_matrix_info info;
    long dim[JIT_MATRIX_MAX_DIMCOUNT];
    char *bp;
    long savelock;
    long tmp[JIT_MATRIX_MAX_DIMCOUNT],cksize,size,offset,points,typesize,typeID;
    
    if (fh&&matrix) {
        savelock = (long) jit_object_method(matrix,gensym("lock"),1);
        jit_object_method(matrix,gensym("getinfo"), &info);
        jit_object_method(matrix, gensym("getdata"), &bp);
        if (!bp) { err=JIT_ERR_GENERIC; goto out;}
        
        cksize = 24;
        points = 1;
        
        for (i = 0; i < info.dimcount; i++) {
            dim[i] = info.dim[i];
            cksize += 4;
            points *= dim[i]; 
        }
        
        if (info.type==_jit_sym_char) {
            typeID      = JIT_BIN_TYPE_CHAR;
            typesize    = 1;
        } else if (info.type==_jit_sym_long) {
            typeID      = JIT_BIN_TYPE_LONG;
            typesize    = 4;
        } else if (info.type==_jit_sym_float32) {
            typeID      = JIT_BIN_TYPE_FLOAT32;
            typesize    = 4;
        } else if (info.type==_jit_sym_float64) {
            typeID      = JIT_BIN_TYPE_FLOAT64;
            typesize    = 8;
        } else {
            err = JIT_ERR_GENERIC;
            goto out;
        }
        
        offset = cksize;
        cksize += points*info.planecount*typesize;
        
        //write standard matrix chunk info
        tmp[0] = BE_I32(JIT_BIN_CHUNK_MATRIX);
        tmp[1] = BE_I32(cksize);
        tmp[2] = BE_I32(offset);        
        tmp[3] = BE_I32(typeID);
        tmp[4] = BE_I32(info.planecount);
        tmp[5] = BE_I32(info.dimcount);
        size = 24;

        if (err = sysfile_write(fh, &size, &tmp)) { 
            goto out; 
        }

        //write dim values
        for (i=0;i<info.dimcount;i++) 
            tmp[i] = BE_I32(dim[i]);
        size = info.dimcount*4;

        if (err = sysfile_write(fh, &size, &tmp)) { 
            goto out; 
        }
        
        //write the data
        err = jit_bin_write_matrix_ndim(fh, info.dimcount, dim, &info, bp);
    } else {
        err = JIT_ERR_INVALID_PTR;
    }
    
out:
    //exporting this as part of API, so removed error posting -bbn
    //if (err) jit_object_post((t_object *)x,"error %ld writing file", err); 
    jit_object_method(matrix, gensym("lock"), savelock);
    return err;
}
    
t_jit_err jit_bin_write_matrix_ndim(t_filehandle fh, long dimcount, long *dim, t_jit_matrix_info *info, char *bp)
{
    char *p;
    long i;
    t_jit_err err = JIT_ERR_NONE;
        
    if (dimcount<1) return err; //safety
    
    switch(dimcount) {
    case 1:
        dim[1]=1;
    case 2:
        if (info->type == _jit_sym_char) // these functions located in m2t.c
            err = jit_bin_write_matrix_char(fh, dim, info, bp);
        else if (info->type == _jit_sym_long)
            err = jit_bin_write_matrix_long(fh, dim, info, bp);
        else if (info->type == _jit_sym_float32)
            err = jit_bin_write_matrix_float32(fh, dim, info, bp);
        else if (info->type == _jit_sym_float64)
            err = jit_bin_write_matrix_float64(fh, dim, info, bp);
        break;
    default:
        for (i = 0; i < dim[dimcount-1]; i++) {
            p = bp + i * info->dimstride[dimcount-1];
            jit_bin_write_matrix_ndim(fh, dimcount-1, dim, info, p);
        }
    }
    return err;
}

t_jit_err jit_bin_write_matrix_char(t_filehandle fh, long *dim, t_jit_matrix_info *info, char *bp)
{
    long i,width,height,planecount;
    uchar *p;
    long err=JIT_ERR_NONE;
    long size,size0;
    
    width = dim[0];
    height = dim[1];
    planecount = info->planecount;
    size0 = width*planecount;
    
    for (i=0;i<height;i++) {
        p = (uchar *)(bp + i*info->dimstride[1]);
        size = size0;
        if ((err=sysfile_write(fh,&size,p))||(size!=size0)) {
            //exporting this as part of API, so removed error posting -bbn
            //jit_object_post((t_object *)x,"error %ld writing file", err);
            goto out;
        }
    }   

out:
    return err;
}

t_jit_err jit_bin_write_matrix_long(t_filehandle fh, long *dim, t_jit_matrix_info *info, char *bp)
{
    long i,width,height,planecount;
    uchar *p;
    long err=JIT_ERR_NONE;
    long size,size0;
#ifdef JIT_LITTLE_ENDIAN
    long j,k,tmp,*p0,*p1,*p2;
#endif
    
    width = dim[0];
    height = dim[1];
    planecount = info->planecount;
    size0 = width*planecount*4;

#ifdef JIT_LITTLE_ENDIAN
    if (!(p0=(long *)jit_getbytes(size0))) {
        //exporting this as part of API, so removed error posting -bbn
        //jit_object_post((t_object *)x,"could not allocate memory to write file");
        goto out;
    }
#endif
    
    for (i=0;i<height;i++) {
        p = (uchar *)(bp + i*info->dimstride[1]);
        size = size0;
#ifdef JIT_LITTLE_ENDIAN
        p1 = p0;
        p2 = (long *)p;
        for (j=0;j<width;j++) {
            for (k=0;k<planecount;k++) {
                tmp = *p2++;
                *p1++ = SWAP32(tmp);
            }
        }
        p = (uchar *)p0;
#endif
        if ((err=sysfile_write(fh,&size,p))||(size!=size0)) {
            //exporting this as part of API, so removed error posting -bbn
            //jit_object_post((t_object *)x,"error %ld writing file", err);
            goto out;
        }
    }

#ifdef JIT_LITTLE_ENDIAN
    jit_freebytes(p0,size0);
#endif

out:    
    return err;
}

t_jit_err jit_bin_write_matrix_float32(t_filehandle fh, long *dim, t_jit_matrix_info *info, char *bp)
{
    long i,width,height,planecount;
    uchar *p;
    long err=JIT_ERR_NONE;
    long size,size0;
#ifdef JIT_LITTLE_ENDIAN
    long j,k;
    float tmp,*p0,*p1,*p2;
#endif
    
    width = dim[0];
    height = dim[1];
    planecount = info->planecount;
    size0 = width*planecount*4;

#ifdef JIT_LITTLE_ENDIAN
    if (!(p0=(float *)jit_getbytes(size0))) {
        //exporting this as part of API, so removed error posting -bbn
        //jit_object_post((t_object *)x,"could not allocate memory to write file");
        goto out;
    }
#endif
    
    for (i=0;i<height;i++) {
        p = (uchar *)(bp + i*info->dimstride[1]);
        size = size0;
#ifdef JIT_LITTLE_ENDIAN
        p1 = p0;
        p2 = (float *)p;
        for (j=0;j<width;j++) {
            for (k=0;k<planecount;k++) {
                tmp = *p2++;
                *p1++ = swapf32(tmp);
            }
        }
        p = (uchar *)p0;
#endif
        if ((err=sysfile_write(fh,&size,p))||(size!=size0)) {
            //exporting this as part of API, so removed error posting -bbn
            //jit_object_post((t_object *)x,"error %ld writing file", err);
            goto out;
        }
    }

#ifdef JIT_LITTLE_ENDIAN
    jit_freebytes(p0,size0);
#endif

out:    
    return err;
}

t_jit_err jit_bin_write_matrix_float64(t_filehandle fh, long *dim, t_jit_matrix_info *info, char *bp)
{
    long i,width,height,planecount;
    uchar *p;
    long err=JIT_ERR_NONE;
    long size,size0;
#ifdef JIT_LITTLE_ENDIAN
    long j,k;
    double tmp,*p0,*p1,*p2;
#endif

    width = dim[0];
    height = dim[1];
    planecount = info->planecount;
    size0 = width*planecount*8;

#ifdef JIT_LITTLE_ENDIAN
    if (!(p0=(double *)jit_getbytes(size0))) {
        //exporting this as part of API, so removed error posting -bbn
        //jit_object_post((t_object *)x,"could not allocate memory to write file");
        goto out;
    }
#endif

    for (i=0;i<height;i++) {
        p = (uchar *)(bp + i*info->dimstride[1]);
        size = size0;
#ifdef JIT_LITTLE_ENDIAN
        p1 = p0;
        p2 = (double *)p;
        for (j=0;j<width;j++) {
            for (k=0;k<planecount;k++) {
                tmp = *p2++;
                *p1++ = swapf64(tmp);
            }
        }
        p = (uchar *)p0;
#endif
        if ((err=sysfile_write(fh,&size,p))||(size!=size0)) {
            //exporting this as part of API, so removed error posting -bbn
            //jit_object_post((t_object *)x,"error %ld writing file", err);
            goto out;
        }
    }

#ifdef JIT_LITTLE_ENDIAN
    jit_freebytes(p0,size0);
#endif

out:    
    return err;
}

Copyright © 2008, Cycling '74