Max 5 API Reference

jit.sampler.regular.c

/*
 * Copyright 2001-2005 - Cycling '74
 * Derek Gerstmann - derek@cycling74.com
 *
 * Evaluation over n-dim using regularly spaced linearly interpolated 
 * sampling.
 *
 */

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

#include "jit.common.h"
#include "jit.functor.h"

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

typedef struct _jit_functor_sampler_regular_vecdata_fixed
{
    long coord[JIT_MATRIX_MAX_DIMCOUNT];        // coordinates
    long offset[JIT_MATRIX_MAX_DIMCOUNT];       // offsets
    long step[JIT_MATRIX_MAX_DIMCOUNT];         // increments

} t_jit_functor_sampler_regular_vecdata_fixed;

typedef struct _jit_functor_sampler_regular_vecdata_float32
{
    float coord[JIT_MATRIX_MAX_DIMCOUNT];       // coordinates
    float offset[JIT_MATRIX_MAX_DIMCOUNT];      // offsets
    float step[JIT_MATRIX_MAX_DIMCOUNT];        // increments

} t_jit_functor_sampler_regular_vecdata_float32;

typedef struct _jit_functor_sampler_regular_vecdata_float64
{
    double coord[JIT_MATRIX_MAX_DIMCOUNT];      // coordinates
    double offset[JIT_MATRIX_MAX_DIMCOUNT];     // offsets
    double step[JIT_MATRIX_MAX_DIMCOUNT];       // increments

} t_jit_functor_sampler_regular_vecdata_float64;

typedef struct _jit_functor_sampler_regular_vecdata
{
    t_jit_functor_sampler_regular_vecdata_fixed     vfixed;     // fixed vecdata
    t_jit_functor_sampler_regular_vecdata_float32   vfloat32;   // float32 vecdata
    t_jit_functor_sampler_regular_vecdata_float64   vfloat64;   // float64 veecdata

} t_jit_functor_sampler_regular_vecdata;


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

// the classname object
typedef struct _jit_functor_sampler_regular
{
    t_object ob;

    // dimensional offsets
    double offset[JIT_MATRIX_MAX_DIMCOUNT];

    // dimensional scale factors
    double scale[JIT_MATRIX_MAX_DIMCOUNT];

    // dimensional step factors
    double step[JIT_MATRIX_MAX_DIMCOUNT];

    // matrix state info
    long dimcount;
    long planecount;

    // matrix calc update flag
    long update;

    // vector evaluation data
    t_jit_functor_sampler_regular_vecdata vecdata;

} t_jit_functor_eval;

void *_jit_functor_sampler_regular_class;

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

t_jit_err jit_functor_sampler_regular_init(void);
t_jit_functor_eval *jit_functor_sampler_regular_new(void);
void jit_functor_sampler_regular_free(t_jit_functor_eval *x);
void jit_functor_sampler_regular_recalc(t_jit_functor_eval *x);

t_jit_err jit_functor_sampler_regular_setattr_scale(t_jit_functor_eval *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_sampler_regular_setattr_offset(t_jit_functor_eval *x, void *attr, long argc, t_atom *argv);

t_jit_err jit_functor_sampler_regular_matrix_calc(
    t_jit_functor_eval *x, void *inputs, void *outputs);

void jit_functor_sampler_regular_calculate_ndim(
    t_jit_functor_eval *x, long dimcount, long *dim, long planecount,
    t_jit_matrix_info *out_minfo, char *bop, t_jit_parallel_ndim_worker *w);

void jit_functor_sampler_regular_calculate_char_ndim_recurse(
    t_jit_functor_eval *x, long dimcount, long *dim, long planecount,
    t_jit_matrix_info *out_minfo, char *bop, t_jit_parallel_ndim_worker *w,
    t_jit_functor_sampler_regular_vecdata_fixed *vp);

void jit_functor_sampler_regular_calculate_long_ndim_recurse(
    t_jit_functor_eval *x, long dimcount, long *dim, long planecount,
    t_jit_matrix_info *out_minfo, char *bop, t_jit_parallel_ndim_worker *w,
    t_jit_functor_sampler_regular_vecdata_fixed *vp);

void jit_functor_sampler_regular_calculate_float32_ndim_recurse(
    t_jit_functor_eval *x, long dimcount, long *dim, long planecount,
    t_jit_matrix_info *out_minfo, char *bop, t_jit_parallel_ndim_worker *w,
    t_jit_functor_sampler_regular_vecdata_float32 *vp);

void jit_functor_sampler_regular_calculate_float64_ndim_recurse(
    t_jit_functor_eval *x, long dimcount, long *dim, long planecount,
    t_jit_matrix_info *out_minfo, char *bop, t_jit_parallel_ndim_worker *w,
    t_jit_functor_sampler_regular_vecdata_float64 *vp);

void jit_functor_sampler_regular_vector_char(
    t_jit_functor_eval *x, long n, t_jit_functor_sampler_regular_vecdata_fixed *v,
    t_jit_op_info *out, t_jit_parallel_ndim_worker *w);

void jit_functor_sampler_regular_vector_long(
    t_jit_functor_eval *x, long n, t_jit_functor_sampler_regular_vecdata_fixed *v,
    t_jit_op_info *out, t_jit_parallel_ndim_worker *w);

void jit_functor_sampler_regular_vector_float32(
    t_jit_functor_eval *x, long n, t_jit_functor_sampler_regular_vecdata_float32 *v,
    t_jit_op_info *out, t_jit_parallel_ndim_worker *w);

void jit_functor_sampler_regular_vector_float64(
    t_jit_functor_eval *x, long n, t_jit_functor_sampler_regular_vecdata_float64 *v,
    t_jit_op_info *out, t_jit_parallel_ndim_worker *w);

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

t_jit_err jit_functor_sampler_regular_init(void)
{
    long attrflags=0;
    void *mop, *attr;

    // create class
    _jit_functor_sampler_regular_class = jit_class_new("jit_functor_sampler_regular",
        (method)jit_functor_sampler_regular_new,(method)jit_functor_sampler_regular_free,
        sizeof(t_jit_functor_eval),0L);

    // add mop
    mop = jit_object_new(_jit_sym_jit_mop,0,1);
    jit_class_addadornment(_jit_functor_sampler_regular_class,mop);

    // add matrix methods
    jit_class_addmethod(_jit_functor_sampler_regular_class, (method)jit_functor_sampler_regular_matrix_calc, "matrix_calc", A_CANT, 0L);

    //user opaque attributes
    attrflags = JIT_ATTR_GET_DEFER_LOW | JIT_ATTR_SET_USURP_LOW;
    attr = jit_object_new(_jit_sym_jit_attr_offset_array,"offset",_jit_sym_float64,JIT_MATRIX_MAX_DIMCOUNT,attrflags,
        (method)0L,(method)jit_functor_sampler_regular_setattr_offset,NULL/*fixed*/,calcoffset(t_jit_functor_eval,offset));
    jit_class_addattr(_jit_functor_sampler_regular_class,attr);
    attr = jit_object_new(_jit_sym_jit_attr_offset_array,"scale",_jit_sym_float64,JIT_MATRIX_MAX_DIMCOUNT,attrflags,
        (method)0L,(method)jit_functor_sampler_regular_setattr_scale,NULL/*fixed*/,calcoffset(t_jit_functor_eval,scale));
    jit_class_addattr(_jit_functor_sampler_regular_class,attr);

    // register class
    jit_class_register(_jit_functor_sampler_regular_class);
    return JIT_ERR_NONE;
}

t_jit_functor_eval *jit_functor_sampler_regular_new(void)
{
    long i, p;
    t_jit_functor_eval *x;

    if (x=(t_jit_functor_eval *)jit_object_alloc(_jit_functor_sampler_regular_class)) {

        x->update = TRUE;

        // init object
        jit_functor_sampler_regular_recalc(x);

    } else {
        x = NULL;
    }
    return x;
}

void jit_functor_sampler_regular_free(t_jit_functor_eval *x)
{
    // zippo
    return;
}

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

void jit_functor_sampler_regular_recalc( t_jit_functor_eval *x )
{
    // reset update flag
    x->update = TRUE;
}

t_jit_err jit_functor_sampler_regular_setattr_offset(t_jit_functor_eval *x, void *attr, long argc, t_atom *argv)
{
    long i;
    double v;
    char changed = FALSE; // changed flag

    if (x) {
        for(i = 0; i < argc && i < JIT_MATRIX_MAX_DIMCOUNT; i++)
        {
            v = jit_atom_getfloat(argv+i);

            if(x->offset[i] != v) {
                x->offset[i] = v;
                changed = TRUE;
            }
        }
        if(changed)
            jit_functor_sampler_regular_recalc(x);

        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_sampler_regular_setattr_scale(t_jit_functor_eval *x, void *attr, long argc, t_atom *argv)
{
    long i;
    double v;
    char changed = FALSE; // changed flag

    if (x) {
        for(i = 0; i < argc && i < JIT_MATRIX_MAX_DIMCOUNT; i++)
        {
            v = jit_atom_getfloat(argv+i);

            if(x->scale[i] != v) {
                x->scale[i] = v;
                changed = TRUE;
            }
        }
        if(changed)
            jit_functor_sampler_regular_recalc(x);

        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

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

t_jit_err jit_functor_sampler_regular_matrix_calc(t_jit_functor_eval *x, void *inputs, void *outputs)
{
    t_jit_err err=JIT_ERR_NONE;
    long out_savelock;
    t_jit_matrix_info out_minfo;
    char *out_bp;
    long i,dimcount,planecount,dim[JIT_MATRIX_MAX_DIMCOUNT];
    void *out_matrix;

    out_matrix  = jit_object_method(outputs,_jit_sym_getindex,0);

    if (out_matrix && x && x->update) {
        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(out_matrix,_jit_sym_getdata,&out_bp);

        if (!out_bp) { err=JIT_ERR_INVALID_OUTPUT; goto out;}

        // get dimensions/planecount
        x->dimcount = out_minfo.dimcount;
        x->planecount = out_minfo.planecount;

        // initialize dimensions and vecdata
        for( i = 0 ; i < x->dimcount; i++) {

            dim[i] = out_minfo.dim[i];

            if(dim[i] != 0)
                x->step[i] = x->scale[i] * 1.0 / (dim[i] - 1.0);
            else
                x->step[i] = x->scale[i];
        }

        // evaluate
        jit_parallel_ndim_simplecalc1((method)jit_functor_sampler_regular_calculate_ndim,
            x, out_minfo.dimcount, out_minfo.dim, out_minfo.planecount,
            &out_minfo, out_bp, 0 );

        // reset update flag
        x->update = FALSE;

    } else if(x == NULL){
        return JIT_ERR_INVALID_PTR;
    }

out:
    jit_object_method(out_matrix,gensym("lock"),out_savelock);
    return err;
}

void jit_functor_sampler_regular_calculate_ndim(
    t_jit_functor_eval *x, long dimcount, long *dim, long planecount,
    t_jit_matrix_info *out_minfo, char *bop, t_jit_parallel_ndim_worker *w)
{
    long i;
    t_jit_functor_sampler_regular_vecdata_fixed vecfixed;
    t_jit_functor_sampler_regular_vecdata_float32 vecfloat32;
    t_jit_functor_sampler_regular_vecdata_float64 vecfloat64;

    if( dimcount < 1 ) return; //safety

    if (out_minfo->type == _jit_sym_char)
    {
        // initialize dimensions and vecdata
        for( i = 0 ; i < dimcount; i++) {
            vecfixed.offset[i] = DoubleToFixed(x->offset[i]);
            vecfixed.step[i] = DoubleToFixed(x->step[i]);
            vecfixed.coord[i] = FloatToFixed(FixedToFloat(vecfixed.offset[i]) + w->offset[i] * FixedToFloat(vecfixed.step[i]));
        }

        // perform recursive evaluation
        jit_functor_sampler_regular_calculate_char_ndim_recurse(x, dimcount, dim, planecount, out_minfo, bop, w, &vecfixed);
    }
    else if (out_minfo->type == _jit_sym_long)
    {
        // initialize dimensions and vecdata
        for( i = 0 ; i < dimcount; i++) {
            vecfixed.offset[i] = DoubleToFixed(x->offset[i]);
            vecfixed.step[i] = DoubleToFixed(x->step[i]);
            vecfixed.coord[i] = FloatToFixed(FixedToFloat(vecfixed.offset[i]) + w->offset[i] * FixedToFloat(vecfixed.step[i]));
        }

        // perform recursive evaluation
        jit_functor_sampler_regular_calculate_long_ndim_recurse(x, dimcount, dim, planecount, out_minfo, bop, w, &vecfixed);
    }
    else if (out_minfo->type == _jit_sym_float32)
    {
        // initialize dimensions and vecdata
        for( i = 0 ; i < dimcount; i++) {
            vecfloat32.offset[i] = (float)x->offset[i];
            vecfloat32.step[i] = (float)x->step[i];
            vecfloat32.coord[i] = vecfloat32.offset[i] + w->offset[i] * vecfloat32.step[i];
        }

        // perform recursive evaluation
        jit_functor_sampler_regular_calculate_float32_ndim_recurse(x, dimcount, dim, planecount, out_minfo, bop, w, &vecfloat32);
    }
    else if (out_minfo->type == _jit_sym_float64)
    {
        // initialize dimensions and vecdata
        for( i = 0 ; i < dimcount; i++) {
            vecfloat64.offset[i] = (double)x->offset[i];
            vecfloat64.step[i] = (double)x->step[i];
            vecfloat64.coord[i] = vecfloat64.offset[i] + w->offset[i] * vecfloat64.step[i];
        }

        // perform recursive evaluation
        jit_functor_sampler_regular_calculate_float64_ndim_recurse(x, dimcount, dim, planecount, out_minfo, bop, w, &vecfloat64);
    }
}

void jit_functor_sampler_regular_calculate_char_ndim_recurse(
    t_jit_functor_eval *x, long dimcount, long *dim, long planecount,
    t_jit_matrix_info *out_minfo, char *bop, t_jit_parallel_ndim_worker *w,
    t_jit_functor_sampler_regular_vecdata_fixed *vp)
{
    char *cop,*op;
    long i,j,n,p,tmp;
    t_jit_op_info out_opinfo;

    // initialize dimensions and vecdata
    switch( dimcount ){
    case 1:
        // set y dimension to 1 and evaluate in 2d
        dim[1] = 1;

    case 2:

        n = dim[0];
        out_opinfo.stride = 1;

        // evaluate 2d slice
        for (i=0;i<dim[1];i++){

            // get offset buffer pointer
            out_opinfo.p = bop + i*out_minfo->dimstride[1];

            // calculate coordinates
            if(i == 0)
                vp->coord[1] = FloatToFixed(FixedToFloat(vp->offset[1]) + w->offset[1] * FixedToFloat(vp->step[1]));
            else
                vp->coord[1] += vp->step[1];

            // evaluate 2d vector
            jit_functor_sampler_regular_vector_char(x, n, vp, &out_opinfo, w);
        }
        break;

    default:

        // recursively evaluate
        for (i=0;i<dim[dimcount-1];i++) {

            // get offset buffer pointer
            cop = bop + i*out_minfo->dimstride[dimcount-1];

            // calculate coordinates
            if(i == 0) {
                vp->coord[dimcount-1] = FloatToFixed(FixedToFloat(vp->offset[dimcount-1]) + w->offset[dimcount-1] * FixedToFloat(vp->step[dimcount-1]));
            } else {
                vp->coord[dimcount-1] += vp->step[dimcount-1];
            }

            // evaluate recursively
            jit_functor_sampler_regular_calculate_char_ndim_recurse(x, dimcount-1, dim, planecount, out_minfo, cop, w, vp);
        }
        break;
    };
}

void jit_functor_sampler_regular_calculate_long_ndim_recurse(
    t_jit_functor_eval *x, long dimcount, long *dim, long planecount,
    t_jit_matrix_info *out_minfo, char *bop, t_jit_parallel_ndim_worker *w,
    t_jit_functor_sampler_regular_vecdata_fixed *vp)
{
    char *cop,*op;
    long i,j,n,p,tmp;
    t_jit_op_info out_opinfo;

    // initialize dimensions and vecdata
    switch( dimcount ){
    case 1:

        // set y dimension to 1 and evaluate in 2d
        dim[1] = 1;

    case 2:

        n = dim[0];
        out_opinfo.stride = 1;

        // evaluate 2d slice
        for (i=0;i<dim[1];i++){

            // get offset buffer pointer
            out_opinfo.p = bop + i*out_minfo->dimstride[1];

            // calculate coordinates
            if(i == 0)
                vp->coord[1] = FloatToFixed(FixedToFloat(vp->offset[1]) + w->offset[1] * FixedToFloat(vp->step[1]));
            else
                vp->coord[1] += vp->step[1];

            // evaluate 2d vector
            jit_functor_sampler_regular_vector_long(x, n, vp, &out_opinfo, w);
        }
        break;

    default:

        // recursively evaluate
        for (i=0;i<dim[dimcount-1];i++) {

            // get offset buffer pointer
            cop = bop + i*out_minfo->dimstride[dimcount-1];

            // calculate coordinates
            if(i == 0) {
                vp->coord[dimcount-1] = FloatToFixed(FixedToFloat(vp->offset[dimcount-1]) + w->offset[dimcount-1] * FixedToFloat(vp->step[dimcount-1]));
            } else {
                vp->coord[dimcount-1] += vp->step[dimcount-1];
            }

            // evaluate recursively
            jit_functor_sampler_regular_calculate_long_ndim_recurse(x, dimcount-1, dim, planecount, out_minfo, cop, w, vp);
        }
        break;
    };
}

void jit_functor_sampler_regular_calculate_float32_ndim_recurse(
    t_jit_functor_eval *x, long dimcount, long *dim, long planecount,
    t_jit_matrix_info *out_minfo, char *bop, t_jit_parallel_ndim_worker *w,
    t_jit_functor_sampler_regular_vecdata_float32 *vp)
{
    char *cop,*op;
    long i,j,n,p,tmp;
    t_jit_op_info out_opinfo;


    // initialize dimensions and vecdata
    switch( dimcount ){
    case 1:
        // set y dimension to 1 and evaluate in 2d
        dim[1] = 1;

    case 2:

        n = dim[0];
        out_opinfo.stride = 1;

        // evaluate 2d slice
        for (i=0;i<dim[1];i++){

            // get offset buffer pointer
            out_opinfo.p = bop + i*out_minfo->dimstride[1];

            // calculate coordinates
            if(i == 0)
                vp->coord[1] = vp->offset[1] + w->offset[1] * vp->step[1];
            else
                vp->coord[1] += vp->step[1];

            // evaluate 2d vector
            jit_functor_sampler_regular_vector_float32(x, n, vp, &out_opinfo, w);
        }
        break;

    default:

        // recursively evaluate
        for (i=0;i<dim[dimcount-1];i++) {

            // get offset buffer pointer
            cop = bop + i*out_minfo->dimstride[dimcount-1];

            // calculate coordinates
            if(i == 0) {
                vp->coord[dimcount-1] = vp->offset[dimcount-1] + w->offset[dimcount-1] * vp->step[dimcount-1];
            } else {
                vp->coord[dimcount-1] += vp->step[dimcount-1];
            }

            // evaluate recursively
            jit_functor_sampler_regular_calculate_float32_ndim_recurse(x, dimcount-1, dim, planecount, out_minfo, cop, w, vp);
        }
        break;
    };
}

void jit_functor_sampler_regular_calculate_float64_ndim_recurse(
    t_jit_functor_eval *x, long dimcount, long *dim, long planecount,
    t_jit_matrix_info *out_minfo, char *bop, t_jit_parallel_ndim_worker *w,
    t_jit_functor_sampler_regular_vecdata_float64 *vp)
{
    char *cop,*op;
    long i,j,n,p,tmp;
    t_jit_op_info out_opinfo;


    // initialize dimensions and vecdata
    switch( dimcount ){
    case 1:
        // set y dimension to 1 and evaluate in 2d
        dim[1] = 1;

    case 2:

        n = dim[0];
        out_opinfo.stride = 1;

        // evaluate 2d slice
        for (i=0;i<dim[1];i++){

            // get offset buffer pointer
            out_opinfo.p = bop + i*out_minfo->dimstride[1];

            // calculate coordinates
            if(i == 0)
                vp->coord[1] = vp->offset[1] + w->offset[1] * vp->step[1];
            else
                vp->coord[1] += vp->step[1];

            // evaluate 2d vector
            jit_functor_sampler_regular_vector_float64(x, n, vp, &out_opinfo, w);
        }
        break;

    default:

        // recursively evaluate
        for (i=0;i<dim[dimcount-1];i++) {

            // get offset buffer pointer
            cop = bop + i*out_minfo->dimstride[dimcount-1];

            // calculate coordinates
            if(i == 0) {
                vp->coord[dimcount-1] = vp->offset[dimcount-1] + w->offset[dimcount-1] * vp->step[dimcount-1];
            } else {
                vp->coord[dimcount-1] += vp->step[dimcount-1];
            }

            // evaluate recursively
            jit_functor_sampler_regular_calculate_float64_ndim_recurse(x, dimcount-1, dim, planecount, out_minfo, cop, w, vp);
        }
        break;
    };
}
/*************************************************************************/

void jit_functor_sampler_regular_vector_char(
    t_jit_functor_eval *x, long n, t_jit_functor_sampler_regular_vecdata_fixed *v,
    t_jit_op_info *out, t_jit_parallel_ndim_worker *w)
{
    long i, j, d, p;
    long os;
    uchar *op;
    long val;
    long pos[JIT_MATRIX_MAX_DIMCOUNT];

    op  = ((uchar *)out->p);
    os  = out->stride;

    for (i = 0; i < n; i++)
    {
        // calculate current coordinate
        if(i == 0) {
            v->coord[0] = FloatToFixed(FixedToFloat(v->offset[0]) + w->offset[0] * FixedToFloat(v->step[0]));
        } else {
            v->coord[0] += v->step[0];
        }

        if(x->planecount > 1)
        {
            // apply dimensional coordinate to planar data
            for (p = 0; p < x->planecount && p < x->dimcount; p++) {
                op[p] = v->coord[p];
            }
            op += x->planecount;
        }
        else
        {
            *op = v->coord[0];
            op += os;
        }
    }
}

void jit_functor_sampler_regular_vector_long(
    t_jit_functor_eval *x, long n, t_jit_functor_sampler_regular_vecdata_fixed *v,
    t_jit_op_info *out, t_jit_parallel_ndim_worker *w)
{
    long i, j, d, p;
    long os;
    long *op;
    long val;
    long pos[JIT_MATRIX_MAX_DIMCOUNT];

    op  = ((long *)out->p);
    os  = out->stride;

    for (i = 0; i < n; i++)
    {
        // calculate current coordinate
        if(i == 0) {
            v->coord[0] = FloatToFixed(FixedToFloat(v->offset[0]) + w->offset[0] * FixedToFloat(v->step[0]));
        } else {
            v->coord[0] += v->step[0];
        }

        if(x->planecount > 1)
        {
            // apply dimensional coordinate to planar data
            for (p = 0; p < x->planecount && p < x->dimcount; p++) {
                op[p] = v->coord[p];
            }
            op += x->planecount;
        }
        else
        {
            *op = v->coord[0];
            op += os;
        }
    }
}

void jit_functor_sampler_regular_vector_float32(
    t_jit_functor_eval *x, long n, t_jit_functor_sampler_regular_vecdata_float32 *v,
    t_jit_op_info *out, t_jit_parallel_ndim_worker *w)
{
    long i, j, d, p;
    long os;
    float *op;
    float val;
    float pos[JIT_MATRIX_MAX_DIMCOUNT];

    op  = ((float *)out->p);
    os  = out->stride;

    for (i = 0; i < n; i++)
    {
        // calculate current coordinate
        if(i == 0) {
            v->coord[0] = w->offset[0] * v->step[0] + v->offset[0];
        } else {
            v->coord[0] += v->step[0];
        }

        if(x->planecount > 1)
        {
            // apply dimensional coordinate to planar data
            for (p = 0; p < x->planecount && p < x->dimcount; p++) {
                op[p] = v->coord[p];
            }
            op += x->planecount;
        }
        else
        {
            *op = v->coord[0];
            op += os;
        }
    }
}

void jit_functor_sampler_regular_vector_float64(
    t_jit_functor_eval *x, long n, t_jit_functor_sampler_regular_vecdata_float64 *v,
    t_jit_op_info *out, t_jit_parallel_ndim_worker *w)
{
    long i, j, d, p;
    long os;
    double *op;
    double val;
    double pos[JIT_MATRIX_MAX_DIMCOUNT];

    op  = ((double *)out->p);
    os  = out->stride;

    for (i = 0; i < n; i++)
    {
        // calculate current coordinate
        if(i == 0) {
            v->coord[0] = w->offset[0] * v->step[0] + v->offset[0];
        } else {
            v->coord[0] += v->step[0];
        }

        if(x->planecount > 1)
        {
            // apply dimensional coordinate to planar data
            for (p = 0; p < x->planecount && p < x->dimcount; p++) {
                op[p] = v->coord[p];
            }
            op += x->planecount;
        }
        else
        {
            *op = v->coord[0];
            op += os;
        }
    }
}

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

Copyright © 2008, Cycling '74