void dobj_iterate(Data_Obj *dp,void (*func)(Data_Obj *,index_t))
{
dimension_t comp,col,row,frm,seq;
/* offsets for sequence, frame, row, pixel, component */
dimension_t s_os, f_os, r_os, p_os, c_os;
s_os=0;
for(seq=0;seq<OBJ_SEQS(dp);seq++){
f_os = s_os;
for(frm=0;frm<OBJ_FRAMES(dp);frm++){
r_os = f_os;
for(row=0;row<OBJ_ROWS(dp);row++){
p_os = r_os;
for(col=0;col<OBJ_COLS(dp);col++){
c_os = p_os;
for(comp=0;comp<OBJ_COMPS(dp);comp++){
(*func)(dp,c_os);
c_os += OBJ_COMP_INC(dp);
}
p_os += OBJ_PXL_INC(dp);
}
r_os += OBJ_ROW_INC(dp);
}
f_os += OBJ_FRM_INC(dp);
}
s_os += OBJ_SEQ_INC(dp);
}
}
//int _wav_to_dp(QSP_ARG_DECL Data_Obj *dp,Wav_Header *hd_p)
FIO_FT_TO_DP_FUNC(wav,Wav_Header)
{
Precision * prec_p;
dimension_t total_samples, samples_per_channel;
switch( hd_p->wh_bits_per_sample ){
case 8: prec_p=PREC_FOR_CODE(PREC_UBY); break;
case 16: prec_p=PREC_FOR_CODE(PREC_IN); break;
default:
sprintf(ERROR_STRING,
"wav_to_dp: unexpected # of bits per sample %d",
hd_p->wh_bits_per_sample);
warn(ERROR_STRING);
return(-1);
}
SET_OBJ_PREC_PTR(dp, prec_p);
SET_OBJ_COMPS(dp, hd_p->wh_n_channels );
total_samples = (dimension_t) (hd_p->wh_datasize / PREC_SIZE( prec_p ));
samples_per_channel = total_samples / OBJ_COMPS(dp);
SET_OBJ_COLS(dp, samples_per_channel);
SET_OBJ_ROWS(dp, 1);
SET_OBJ_FRAMES(dp, 1);
SET_OBJ_SEQS(dp, 1);
SET_OBJ_COMP_INC(dp, 1);
SET_OBJ_PXL_INC(dp, 1);
SET_OBJ_ROW_INC(dp, 1);
SET_OBJ_FRM_INC(dp, 1);
SET_OBJ_SEQ_INC(dp, 1);
SET_OBJ_PARENT(dp, NULL);
SET_OBJ_CHILDREN(dp, NULL);
SET_OBJ_AREA(dp, ram_area_p); /* the default */
/* dp->dt_data = hd_p->image; */ /* where do we allocate data??? */
SET_OBJ_N_TYPE_ELTS(dp, OBJ_COMPS(dp) * OBJ_COLS(dp) * OBJ_ROWS(dp)
* OBJ_FRAMES(dp) * OBJ_SEQS(dp) );
auto_shape_flags(OBJ_SHAPE(dp));
return 0;
}
void _dpair_iterate(QSP_ARG_DECL Data_Obj *dp1,Data_Obj *dp2,void (*func)(QSP_ARG_DECL Data_Obj *,index_t,Data_Obj *,index_t))
{
dimension_t comp,col,row,frm,seq;
/* offsets for sequence, frame, row, pixel, component */
dimension_t s_os1, f_os1, r_os1, p_os1, c_os1;
dimension_t s_os2, f_os2, r_os2, p_os2, c_os2;
s_os1=0;
s_os2=0;
for(seq=0;seq<OBJ_SEQS(dp1);seq++){
f_os1 = s_os1;
f_os2 = s_os2;
for(frm=0;frm<OBJ_FRAMES(dp1);frm++){
r_os1 = f_os1;
r_os2 = f_os2;
for(row=0;row<OBJ_ROWS(dp1);row++){
p_os1 = r_os1;
p_os2 = r_os2;
for(col=0;col<OBJ_COLS(dp1);col++){
c_os1 = p_os1;
c_os2 = p_os2;
for(comp=0;comp<OBJ_COMPS(dp1);comp++){
(*func)(QSP_ARG dp1,c_os1,dp2,c_os2);
c_os1 += OBJ_COMP_INC(dp1);
c_os2 += OBJ_COMP_INC(dp2);
}
p_os1 += OBJ_PXL_INC(dp1);
p_os2 += OBJ_PXL_INC(dp2);
}
r_os1 += OBJ_ROW_INC(dp1);
r_os2 += OBJ_ROW_INC(dp2);
}
f_os1 += OBJ_FRM_INC(dp1);
f_os2 += OBJ_FRM_INC(dp2);
}
s_os1 += OBJ_SEQ_INC(dp1);
s_os2 += OBJ_SEQ_INC(dp2);
}
}
static void _ocl_offset_data(QSP_ARG_DECL Data_Obj *dp, index_t offset)
{
#ifndef USE_OPENCL_SUBREGION
/* The original code used subBuffers, but overlapping subregions
* don't work...
* So instead we use a common memory buffer, but keep track
* of the starting offset (in elements). This offset has
* to be passed to the kernels.
*/
//fprintf(stderr,"ocl_offset_data: obj %s, offset = %d\n",OBJ_NAME(dp),offset);
//fprintf(stderr,"\tparent obj %s, parent offset = %d\n",OBJ_NAME(OBJ_PARENT(dp)),
//OBJ_OFFSET(OBJ_PARENT(dp)));
if( IS_COMPLEX(dp) ){
assert( (offset & 1) == 0 );
offset /= 2;
//fprintf(stderr,"Adjusted offset (%d) for complex object %s\n",offset,OBJ_NAME(dp));
} else if( IS_QUAT(dp) ){
assert( (offset & 3) == 0 );
offset /= 4;
}
SET_OBJ_DATA_PTR(dp,OBJ_DATA_PTR(OBJ_PARENT(dp)));
SET_OBJ_OFFSET( dp, OBJ_OFFSET(OBJ_PARENT(dp)) + offset );
#else // USE_OPENCL_SUBREGION
cl_mem buf;
cl_mem parent_buf;
cl_buffer_region reg;
cl_int status;
int extra_offset;
parent_buf = find_parent_buf(OBJ_PARENT(dp),&extra_offset);
assert( parent_buf != NULL );
reg.origin = (offset+extra_offset) * ELEMENT_SIZE(dp);
// No - the region has to be big enough for all of the elements.
// The safest thing is to include everything from the start
// of the subregion to the end of the parent. Note that this
// cannot handle negative increments!?
// reg.size = OBJ_N_MACH_ELTS(dp) * ELEMENT_SIZE(dp);
// p p p p p p p
// p p c c c p p
// p p p p p p p
// p p c c c p p
reg.size = OBJ_SEQ_INC(dp)*(OBJ_SEQS(dp)-1)
+ OBJ_FRM_INC(dp)*(OBJ_FRAMES(dp)-1)
+ OBJ_ROW_INC(dp)*(OBJ_ROWS(dp)-1)
+ OBJ_PXL_INC(dp)*(OBJ_COLS(dp)-1)
+ OBJ_COMP_INC(dp)*(OBJ_COMPS(dp)-1)
+ 1;
reg.size *= ELEMENT_SIZE(dp);
//fprintf(stderr,"requesting subregion of %ld bytes at offset %ld\n",
//reg.size,reg.origin);
buf = clCreateSubBuffer ( parent_buf,
CL_MEM_READ_WRITE,
CL_BUFFER_CREATE_TYPE_REGION,
®,
&status);
if( status != CL_SUCCESS ){
report_ocl_error(status, "clCreateSubBuffer");
SET_OBJ_DATA_PTR(dp,OBJ_DATA_PTR(OBJ_PARENT(dp)));
} else {
SET_OBJ_DATA_PTR(dp,buf);
}
// BUG - Because this object doesn't "own" the data, the sub-buffer
// won't be released when the object is destroyed, a possible memory
// leak...
// We need to add a special case, or make data releasing a
// platform-specific function...
#endif // USE_OPENCL_SUBREGION
}
