Max 5 API Reference

jit.uyvy2ayuv.c

#include "jit.common.h"
#include "jit.uyvy.h"

typedef struct _jit_uyvy2ayuv 
{
    t_object                ob;
    long                    noalpha;
} t_jit_uyvy2ayuv;

void *_jit_uyvy2ayuv_class;

t_jit_uyvy2ayuv *jit_uyvy2ayuv_new(void);
void jit_uyvy2ayuv_free(t_jit_uyvy2ayuv *x);
t_jit_err jit_uyvy2ayuv_matrix_calc(t_jit_uyvy2ayuv *x, void *inputs, void *outputs);
void jit_uyvy2ayuv_calculate_ndim(t_jit_uyvy2ayuv *x, long dimcount, long *dim, long planecount, 
    t_jit_matrix_info *in_minfo, char *bip, t_jit_matrix_info *out_minfo, char *bop);
t_jit_err jit_uyvy2ayuv_init(void);


t_jit_err jit_uyvy2ayuv_init(void) 
{
    long attrflags=0;
    t_jit_object *attr, *mop, *o;
    
    _jit_uyvy2ayuv_class = jit_class_new("jit_uyvy2ayuv",(method)jit_uyvy2ayuv_new,(method)jit_uyvy2ayuv_free,
        sizeof(t_jit_uyvy2ayuv),0L);

    //add mop
    mop = jit_object_new(_jit_sym_jit_mop,1,1); //#inputs,#outputs
    jit_mop_single_type(mop, _jit_sym_char);
    o=jit_object_method(mop,_jit_sym_getoutput,1);
    jit_attr_setlong(o,_jit_sym_dimlink,0);
    jit_attr_setlong(o,_jit_sym_minplanecount,3);
    jit_attr_setlong(o,_jit_sym_maxplanecount,4);
    jit_class_addadornment(_jit_uyvy2ayuv_class,mop);

    attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW ;    
    attr = jit_object_new(_jit_sym_jit_attr_offset,"noalpha",_jit_sym_long,attrflags,
        (method)0L,(method)0L,calcoffset(t_jit_uyvy2ayuv,noalpha));
    jit_class_addattr(_jit_uyvy2ayuv_class,attr);

    //add methods
    jit_class_addmethod(_jit_uyvy2ayuv_class, (method)jit_uyvy2ayuv_matrix_calc,        "matrix_calc",      A_CANT, 0L);

    jit_class_register(_jit_uyvy2ayuv_class);

    return JIT_ERR_NONE;
}


t_jit_err jit_uyvy2ayuv_matrix_calc(t_jit_uyvy2ayuv *x, void *inputs, void *outputs)
{
    t_jit_err err=JIT_ERR_NONE;
    long in_savelock,out_savelock, dimmode;
    t_jit_matrix_info in_minfo,out_minfo;
    char *in_bp,*out_bp;
    long i,dimcount,planecount,dim[JIT_MATRIX_MAX_DIMCOUNT];
    void *in_matrix, *out_matrix;

    in_matrix   = jit_object_method(inputs,_jit_sym_getindex,0);
    out_matrix  = jit_object_method(outputs,_jit_sym_getindex,0);

    if (x&&in_matrix&&out_matrix) {
        
        in_savelock = (long) jit_object_method(in_matrix,_jit_sym_lock,1);
        
        jit_object_method(in_matrix,_jit_sym_getinfo,&in_minfo);

        // make output twice as wide as input
        out_minfo = in_minfo;
        out_minfo.dim[0] *= 2;
        if (x->noalpha)
            out_minfo.planecount = 3;
        jit_object_method(out_matrix,_jit_sym_setinfo,&out_minfo);
                
        out_savelock = (long) jit_object_method(out_matrix,_jit_sym_lock,1);
        jit_object_method(out_matrix,_jit_sym_getinfo,&out_minfo);
        
        jit_object_method(in_matrix,_jit_sym_getdata,&in_bp);
        jit_object_method(out_matrix,_jit_sym_getdata,&out_bp);
        
        if (!in_bp) { err=JIT_ERR_GENERIC; goto out;}
        if (!out_bp) { err=JIT_ERR_GENERIC; goto out;}
        
        //compatible types?
        if ((in_minfo.type!=_jit_sym_char)||(in_minfo.type!=out_minfo.type)) { 
            err=JIT_ERR_MISMATCH_TYPE; 
            goto out;
        }       

        //compatible planes?
        if ((in_minfo.planecount!=4)) { 
            err=JIT_ERR_MISMATCH_PLANE; 
            goto out;
        }       

        //get dimensions/planecount
        dimcount   = out_minfo.dimcount;
        planecount = out_minfo.planecount;          

        //calculate
        jit_parallel_ndim_simplecalc2((method)jit_uyvy2ayuv_calculate_ndim,
            x, dimcount, in_minfo.dim, planecount, &in_minfo, in_bp, &out_minfo, out_bp,
            0 /* flags1 */, 0 /* flags2 */);

    } else {
        return JIT_ERR_INVALID_PTR;
    }
    
out:
    jit_object_method(out_matrix,_jit_sym_lock,out_savelock);
    jit_object_method(in_matrix,_jit_sym_lock,in_savelock);
    return err;
}

//
//recursive functions to handle higher dimension matrices, by processing 2D sections at a time
//


void jit_uyvy2ayuv_calculate_ndim(t_jit_uyvy2ayuv *x, long dimcount, long *dim, long planecount, 
    t_jit_matrix_info *in_minfo, char *bip, t_jit_matrix_info *out_minfo, char *bop)
{
    long i,width,height;
    uchar *ip,*op;
    
    if (dimcount<1) return; //safety
    
    switch(dimcount) {
    case 1:
        dim[1]=1;
    case 2: 
        width  = dim[0];
        height = dim[1];
        
        for (i=0;i<height;i++) {
            ip = (uchar *) bip + i*in_minfo->dimstride[1];
            op = (uchar *) bop + i*out_minfo->dimstride[1];
            // width is input dim
            if (x->noalpha)     
                jit_uyvy2yuv_vector_char(width,ip,op);
            else 
                jit_uyvy2ayuv_vector_char(width,ip,op);
        }
        break;
    default:
        for (i=0;i<dim[dimcount-1];i++) {
            ip = (uchar *) bip + i*in_minfo->dimstride[dimcount-1];
            op = (uchar *) bop + i*out_minfo->dimstride[dimcount-1];
            jit_uyvy2ayuv_calculate_ndim(x,dimcount-1,dim,planecount,in_minfo,(char *)ip,out_minfo,(char *)op);
        }
    }
}


t_jit_uyvy2ayuv *jit_uyvy2ayuv_new(void)
{
    t_jit_uyvy2ayuv *x;
    short i;
        
    if (x=(t_jit_uyvy2ayuv *)jit_object_alloc(_jit_uyvy2ayuv_class)) {
        x->noalpha = 0;
    } else {
        x = NULL;
    }   
    return x;
}

void jit_uyvy2ayuv_free(t_jit_uyvy2ayuv *x)
{
    //nada
}

Copyright © 2008, Cycling '74