int do_mod_mul(int a, int b) {
int ret = 0;
if (mul_func == NULL)
kprintf("module mod-mul not loaded.\n");
else
ret = mul_func(a, b);
return ret;
}
static int arithm_test( void* arg )
{
double success_error_level = 0;
int param = (int)arg;
int func = param / 256;
int depth = (param % 256) % 8;
int channels = (param % 256) / 8;
int mattype;
int seed = -1;//atsGetSeed();
int btpix, max_img_bytes;
int merr_i = 0, i;
double max_err = 0.;
uchar *src1data, *src2data, *dstdata, *dstdbdata, *maskdata;
CvRandState rng_state;
AtsBinArithmMaskFunc bin_func = 0;
AtsUnArithmMaskFunc un_func = 0;
AtsBinArithmFunc mul_func = 0;
CvScalar alpha, beta, gamma;
CvMat gammaarr;
alpha = beta = gamma = cvScalarAll(0);
read_arithm_params();
if( !(ATS_RANGE( depth, dt_l, dt_h+1 ) &&
ATS_RANGE( channels, ch_l, ch_h+1 ))) return TRS_UNDEF;
cvInitMatHeader( &gammaarr, 1, 1, CV_64FC4, gamma.val );
switch( func )
{
case 0:
bin_func = cvAdd;
alpha = beta = cvScalarAll(1);
break;
case 1:
bin_func = cvSub;
alpha = cvScalarAll(1);
beta = cvScalarAll(-1);
break;
case 2:
mul_func = cvMul;
break;
case 3:
un_func = cvAddS;
alpha = cvScalarAll(1);
break;
case 4:
un_func = cvSubRS;
alpha = cvScalarAll(-1);
break;
default:
assert(0);
return TRS_FAIL;
}
mattype = depth + channels*8;
depth = depth == 0 ? IPL_DEPTH_8U : depth == 1 ? IPL_DEPTH_8S :
depth == 2 ? IPL_DEPTH_16S : depth == 3 ? IPL_DEPTH_32S :
depth == 4 ? IPL_DEPTH_32F : IPL_DEPTH_64F;
channels = channels + 1;
cvRandInit( &rng_state, 0, 1, seed );
max_img_bytes = (max_img_size + 32) * (max_img_size + 2) * cvPixSize(mattype);
src1data = (uchar*)cvAlloc( max_img_bytes );
src2data = (uchar*)cvAlloc( max_img_bytes );
dstdata = (uchar*)cvAlloc( max_img_bytes );
dstdbdata = (uchar*)cvAlloc( max_img_bytes );
maskdata = (uchar*)cvAlloc( max_img_bytes / cvPixSize(mattype));
btpix = ((depth & 255)/8)*channels;
if( depth == IPL_DEPTH_32F )
success_error_level = FLT_EPSILON * img32f_range * (mul_func ? img32f_range : 2.f);
else if( depth == IPL_DEPTH_64F )
success_error_level = DBL_EPSILON * img32f_range * (mul_func ? img32f_range : 2.f);
for( i = 0; i < base_iters; i++ )
{
int continuous = (cvRandNext( &rng_state ) % 3) == 0;
int is_mask_op = mul_func ? 0 : ((cvRandNext( &rng_state ) % 3) == 0);
int step1, step2, step, mstep;
CvMat src1, src2, dst1, dst2, mask, dst;
double err;
int w, h;
w = cvRandNext( &rng_state ) % (max_img_size - min_img_size) + min_img_size;
h = cvRandNext( &rng_state ) % (max_img_size - min_img_size) + min_img_size;
step1 = step2 = step = w*btpix;
mstep = w;
if( !continuous )
{
step1 += (cvRandNext( &rng_state ) % 4)*(btpix/channels);
step2 += (cvRandNext( &rng_state ) % 4)*(btpix/channels);
step += (cvRandNext( &rng_state ) % 4)*(btpix/channels);
mstep += (cvRandNext( &rng_state ) % 4);
}
switch( depth )
{
case IPL_DEPTH_8U:
cvRandSetRange( &rng_state, 0, img8u_range );
break;
case IPL_DEPTH_8S:
cvRandSetRange( &rng_state, -img8s_range, img8s_range );
break;
case IPL_DEPTH_16S:
cvRandSetRange( &rng_state, -img16s_range, img16s_range );
break;
case IPL_DEPTH_32S:
cvRandSetRange( &rng_state, -img32s_range, img32s_range );
break;
case IPL_DEPTH_32F:
case IPL_DEPTH_64F:
cvRandSetRange( &rng_state, -img32f_range, img32f_range );
break;
}
cvInitMatHeader( &src1, h, w, mattype, src1data, step1 );
cvInitMatHeader( &src2, h, w, mattype, src2data, step2 );
cvInitMatHeader( &dst1, h, w, mattype, dstdata, step );
cvInitMatHeader( &dst2, h, w, mattype, dstdbdata, step );
cvInitMatHeader( &mask, h, w, CV_8UC1, maskdata, mstep );
cvRand( &rng_state, &src1 );
switch( cvRandNext(&rng_state) % 3 )
{
case 0:
memcpy( &dst, &src1, sizeof(dst));
break;
case 1:
if( un_func )
memcpy( &dst, &src1, sizeof(dst));
else
memcpy( &dst, &src2, sizeof(dst));
break;
default:
memcpy( &dst, &dst1, sizeof(dst));
break;
}
if( un_func )
{
if( depth == IPL_DEPTH_8U )
cvRandSetRange( &rng_state, -img8u_range, img8u_range );
cvRand( &rng_state, &gammaarr );
}
else
{
cvRand( &rng_state, &src2 );
}
if( is_mask_op )
{
const int upper = 4;
if( dst.data.ptr == dst1.data.ptr )
cvRand( &rng_state, &dst );
cvRandSetRange( &rng_state, 0, upper );
cvRand( &rng_state, &mask );
atsLinearFunc( &mask, cvScalarAll(1), 0, cvScalarAll(0),
cvScalarAll(2-upper), &mask );
}
if( !mul_func )
{
atsLinearFunc( &src1, alpha, un_func ? 0 : &src2, beta, gamma, &dst2 );
if( is_mask_op )
{
cvXorS( &mask, cvScalarAll(1), &mask );
cvCopy( &dst, &dst2, &mask );
cvXorS( &mask, cvScalarAll(1), &mask );
}
if( un_func )
un_func( &src1, gamma, &dst, is_mask_op ? &mask : 0 );
else
bin_func( &src1, &src2, &dst, is_mask_op ? &mask : 0 );
}
else
{
atsMul( &src1, &src2, &dst2 );
mul_func( &src1, &src2, &dst );
}
/*if( i == 9 )
{
putchar('.');
}*/
//cvXor( &dst2, &dst, &dst2 );
err = cvNorm( &dst2, &dst, CV_C );
if( err > max_err )
{
max_err = err;
merr_i = i;
if( max_err > success_error_level )
goto test_exit;
}
}
test_exit:
cvFree( (void**)&src1data );
cvFree( (void**)&src2data );
cvFree( (void**)&dstdata );
cvFree( (void**)&dstdbdata );
cvFree( (void**)&maskdata );
trsWrite( ATS_LST, "Max err is %g at iter = %d, seed = %08x",
max_err, merr_i, seed );
return max_err <= success_error_level ?
trsResult( TRS_OK, "No errors" ) :
trsResult( TRS_FAIL, "Bad accuracy" );
}
