void create_tests(float32_t eps) {
int rows=4;
int cols=3;
int cols2=2;
ambix_matrix_t matrix, *left, *right;
STARTTEST("");
memset(&matrix, 0, sizeof(matrix));
left=ambix_matrix_create();
fail_if((left==NULL), __LINE__, "failed to create left matrix");
fail_if((left->rows || left->cols), __LINE__, "created empty matrix has non-zero size");
fail_if((left!=ambix_matrix_init(rows, cols, left)), __LINE__, "initializing existing matrix* returned new matrix");
fail_if((left->rows!=rows || left->cols!=cols), __LINE__, "created matrix [%dx%d] does not match [%dx%d]", left->rows, left->cols, cols, cols2);
right=ambix_matrix_init(cols, cols2, NULL);
fail_if((right==NULL), __LINE__, "failed to create right matrix");
fail_if((right->rows!=cols || right->cols!=cols2), __LINE__, "created matrix [%dx%d] does not match [%dx%d]", right->rows, right->cols, cols, cols2);
fail_if((&matrix!=ambix_matrix_init(rows, cols2, &matrix)), __LINE__, "initializing existing matrix returned new matrix");
fail_if((matrix.rows!=rows || matrix.cols!=cols2), __LINE__, "initialized matrix [%dx%d] does not match [%dx%d]", matrix.rows, matrix.cols, rows, cols2);
ambix_matrix_deinit(&matrix);
fail_if((matrix.rows || matrix.cols), __LINE__, "deinitialized matrix is non-zero");
ambix_matrix_deinit(left);
fail_if((left->rows || left->cols), __LINE__, "deinitialized matrix is non-zero");
ambix_matrix_destroy(left);
ambix_matrix_destroy(right);
}
void datamul_eye_tests(float32_t eps) {
float32_t errf;
uint64_t frames=4096;
uint32_t channels=16;
float32_t*inputdata;
float32_t*outputdata;
float32_t freq=500;
ambix_matrix_t eye = {0, 0, NULL};
STARTTEST("");
inputdata =data_sine(frames, channels, freq);
outputdata=(float32_t*)malloc(sizeof(float32_t)*frames*channels);
fail_if((NULL==outputdata), __LINE__, "couldn't mallocate outputdata");
ambix_matrix_init(channels, channels, &eye);
ambix_matrix_fill(&eye, AMBIX_MATRIX_IDENTITY);
fail_if(AMBIX_ERR_SUCCESS!=ambix_matrix_multiply_float32(outputdata, &eye, inputdata, frames),
__LINE__, "data multilplication failed");
errf=data_diff(__LINE__, inputdata, outputdata, frames*channels, eps);
fail_if(!(errf<eps), __LINE__, "diffing data multiplication returned %f (>%f)", errf, eps);
#if 0
printf("matrix:\n"); matrix_print(&eye);
printf("input :\n"); data_print(inputdata, frames*channels);
printf("output:\n"); data_print(outputdata,frames*channels);
#endif
free(inputdata);
free(outputdata);
ambix_matrix_deinit(&eye);
}
ambix_err_t ambix_close (ambix_t*ambix) {
ambix_err_t res=AMBIX_ERR_SUCCESS;
if(NULL==ambix) {
return AMBIX_ERR_INVALID_HANDLE;
}
if((ambix->filemode & AMBIX_WRITE) && ambix->pendingHeaders) {
_ambix_write_header(ambix);
}
res=_ambix_close(ambix);
_ambix_adaptorbuffer_destroy(ambix);
ambix_matrix_deinit(&ambix->matrix);
ambix_matrix_deinit(&ambix->matrix2);
free(ambix);
ambix=NULL;
return res;
}
ambix_matrix_t*
ambix_matrix_init(uint32_t rows, uint32_t cols, ambix_matrix_t*orgmtx) {
ambix_matrix_t*mtx=orgmtx;
uint32_t r;
if(!mtx) {
mtx=(ambix_matrix_t*)calloc(1, sizeof(ambix_matrix_t));
if(!mtx)
return NULL;
mtx->data=NULL;
}
ambix_matrix_deinit(mtx);
mtx->rows=rows;
mtx->cols=cols;
if(rows>0 && cols > 0) {
mtx->data=(float32_t**)calloc(rows, sizeof(float32_t*));
for(r=0; r<rows; r++) {
mtx->data[r]=(float32_t*)calloc(cols, sizeof(float32_t));
}
}
return mtx;
}
void check_create_extended(const char*path, ambix_sampleformat_t format, uint32_t chunksize, float32_t eps) {
ambix_info_t info, rinfo, winfo;
ambix_t*ambix=NULL;
float32_t*orgambidata,*ambidata,*resultambidata;
float32_t*orgotherdata,*otherdata,*resultotherdata;
uint32_t framesize=441000;
uint32_t ambichannels=4;
uint32_t extrachannels=2;
float32_t periods=20000;
ambix_matrix_t eye={0,0,NULL};
const ambix_matrix_t*eye2=NULL;
int64_t err64, gotframes;
float32_t diff=0.;
STARTTEST("\n");
printf("test using '%s' [%d] with chunks of %d and eps=%f\n", path, (int)format, (int)chunksize, eps);
resultambidata=(float32_t*)calloc(ambichannels*framesize, sizeof(float32_t));
ambidata=(float32_t*)calloc(ambichannels*framesize, sizeof(float32_t));
resultotherdata=(float32_t*)calloc(extrachannels*framesize, sizeof(float32_t));
otherdata=(float32_t*)calloc(extrachannels*framesize, sizeof(float32_t));
ambix_matrix_init(ambichannels, ambichannels, &eye);
ambix_matrix_fill(&eye, AMBIX_MATRIX_IDENTITY);
memset(&winfo, 0, sizeof(winfo));
memset(&info, 0, sizeof(info));
info.fileformat=AMBIX_EXTENDED;
info.ambichannels=ambichannels;
info.extrachannels=extrachannels;
info.samplerate=44100;
info.sampleformat=format;
memcpy(&rinfo, &info, sizeof(info));
ambix=ambix_open(path, AMBIX_WRITE, &rinfo);
fail_if((NULL==ambix), __LINE__, "couldn't create ambix file '%s' for writing", path);
orgambidata=data_sine (FLOAT32, framesize, ambichannels, periods);
orgotherdata=data_ramp(FLOAT32, framesize, extrachannels);
//data_print(FLOAT32, orgdata, 100);
fail_if((NULL==orgambidata), __LINE__, "couldn't create ambidata %dx%d sine @ %f", (int)framesize, (int)ambichannels, (float)periods);
fail_if((NULL==orgotherdata), __LINE__, "couldn't create otherdata %dx%d sine @ %f", (int)framesize, (int)extrachannels, (float)periods);
memcpy(ambidata, orgambidata, framesize*ambichannels*sizeof(float32_t));
memcpy(otherdata, orgotherdata, framesize*extrachannels*sizeof(float32_t));
fail_if((AMBIX_ERR_SUCCESS!=ambix_set_adaptormatrix(ambix, &eye)),
__LINE__, "failed setting adaptor matrix");
if(chunksize>0) {
uint32_t subframe=chunksize;
uint32_t chunks = framesize/chunksize;
uint32_t framesleft=framesize;
uint32_t frame;
printf("writing %d chunks of %d frames\n", (int)chunks, (int)chunksize);
for(frame=0; frame<chunks; frame++) {
err64=ambix_writef_float32(ambix, ambidata+ambichannels*frame*chunksize, otherdata+extrachannels*frame*chunksize, chunksize);
fail_if((err64!=chunksize), __LINE__, "wrote only %d chunksize of %d", (int)err64, (int)chunksize);
framesleft-=chunksize;
}
subframe=framesleft;
printf("writing rest of %d frames\n", (int)subframe);
err64=ambix_writef_float32(ambix, ambidata+ambichannels*frame*chunksize, otherdata+extrachannels*frame*chunksize, subframe);
fail_if((err64!=subframe), __LINE__, "wrote only %d subframe of %d", (int)err64, (int)subframe);
} else {
err64=ambix_writef_float32(ambix, ambidata, otherdata, framesize);
fail_if((err64!=framesize), __LINE__, "wrote only %d frames of %d", (int)err64, (int)framesize);
}
diff=data_diff(__LINE__, FLOAT32, orgambidata, ambidata, framesize*ambichannels, eps);
fail_if((diff>eps), __LINE__, "ambidata diff %f > %f", diff, eps);
diff=data_diff(__LINE__, FLOAT32, orgotherdata, otherdata, framesize*extrachannels, eps);
fail_if((diff>eps), __LINE__, "otherdata diff %f > %f", diff, eps);
fail_if((AMBIX_ERR_SUCCESS!=ambix_close(ambix)), __LINE__, "closing ambix file %p", ambix);
ambix=NULL;
/* read data back */
ambix=ambix_open(path, AMBIX_READ, &rinfo);
fail_if((NULL==ambix), __LINE__, "couldn't create ambix file '%s' for reading", path);
fail_if((info.fileformat!=rinfo.fileformat), __LINE__, "fileformat mismatch %d!=%d", (int)info.fileformat, (int)rinfo.fileformat);
fail_if((info.samplerate!=rinfo.samplerate), __LINE__, "samplerate mismatch %g!=%g", (float)info.samplerate, (float)rinfo.samplerate);
fail_if((info.sampleformat!=rinfo.sampleformat), __LINE__, "sampleformat mismatch %d!=%d", (int)info.sampleformat, (int)rinfo.sampleformat);
fail_if((info.ambichannels!=rinfo.ambichannels), __LINE__, "ambichannels mismatch %d!=%d", (int)info.ambichannels, (int)rinfo.ambichannels);
fail_if((info.extrachannels!=rinfo.extrachannels), __LINE__, "extrachannels mismatch %d!=%d", (int)info.extrachannels, (int)rinfo.extrachannels);
eye2=ambix_get_adaptormatrix(ambix);
fail_if((NULL==eye2), __LINE__, "failed reading adaptor matrix");
diff=matrix_diff(__LINE__, &eye, eye2, eps);
fail_if((diff>eps), __LINE__, "adaptormatrix diff %f > %f", diff, eps);
gotframes=0;
do {
//err64=ambix_readf_float32(ambix, resultambidata, resultotherdata, framesize);
err64=ambix_readf_float32(ambix,
resultambidata +(gotframes*ambichannels ),
resultotherdata+(gotframes*extrachannels),
(framesize-gotframes));
fail_if((err64<0), __LINE__, "reading frames failed after %d/%d frames", (int)gotframes, (int)framesize);
gotframes+=err64;
} while(err64>0 && gotframes<framesize);
diff=data_diff(__LINE__, FLOAT32, orgambidata, resultambidata, framesize*ambichannels, eps);
fail_if((diff>eps), __LINE__, "ambidata diff %f > %f", diff, eps);
diff=data_diff(__LINE__, FLOAT32, orgotherdata, resultotherdata, framesize*extrachannels, eps);
fail_if((diff>eps), __LINE__, "otherdata diff %f > %f", diff, eps);
fail_if((AMBIX_ERR_SUCCESS!=ambix_close(ambix)), __LINE__, "closing ambix file %p", ambix);
ambix=NULL;
free(resultambidata);
free(ambidata);
free(resultotherdata);
free(otherdata);
free(orgambidata);
free(orgotherdata);
ambix_matrix_deinit(&eye);
ambixtest_rmfile(path);
}
void
ambix_matrix_destroy(ambix_matrix_t*mtx) {
ambix_matrix_deinit(mtx);
free(mtx);
mtx=NULL;
}
void datamul_4_2_tests(uint32_t chunksize, float32_t eps) {
uint32_t r, c, rows, cols;
float32_t errf;
uint64_t frames=8;
uint32_t rawchannels=2;
uint32_t cokchannels=4;
float32_t*inputdata;
float32_t*outputdata;
float32_t*targetdata;
float32_t freq=500;
ambix_matrix_t eye = {0, 0, NULL};
STARTTEST("");
inputdata =data_sine(frames, rawchannels, freq);
targetdata=data_sine(frames, cokchannels, freq);
outputdata=(float32_t*)malloc(sizeof(float32_t)*frames*cokchannels);
fail_if((NULL==outputdata), __LINE__, "couldn't allocate outputdata");
ambix_matrix_init(cokchannels, rawchannels, &eye);
rows=eye.rows;
cols=eye.cols;
for(r=0; r<rows; r++) {
for(c=0; c<cols; c++) {
eye.data[r][c]=(1+r+c)%2;
}
}
#if 0
matrix_print(&eye);
printf("input\n");
data_print(inputdata, rawchannels*frames);
#endif
fail_if(AMBIX_ERR_SUCCESS!=ambix_matrix_multiply_float32(outputdata, &eye, inputdata, frames),
__LINE__, "data multilplication failed");
#if 0
printf("output\n");
data_print(outputdata, cokchannels*frames);
printf("target\n");
data_print(targetdata, cokchannels*frames);
#endif
errf=data_diff(__LINE__, targetdata, outputdata, frames*cokchannels, eps);
fail_if(!(errf<eps), __LINE__, "diffing data multiplication returned %f (>%f)", errf, eps);
#if 0
printf("matrix:\n"); matrix_print(&eye);
printf("input :\n"); data_print(inputdata, frames*channels);
printf("output:\n"); data_print(outputdata,frames*channels);
#endif
ambix_matrix_deinit(&eye);
free(inputdata);
free(outputdata);
free(targetdata);
}
ambix_matrix_t*
_ambix_uuid1_to_matrix(const void*vdata, uint64_t datasize, ambix_matrix_t*orgmtx, int swap) {
const char*cdata=(const char*)vdata;
ambix_matrix_t*mtx=orgmtx;
uint32_t rows;
uint32_t cols;
uint64_t size;
uint32_t index;
if(datasize<(sizeof(rows)+sizeof(cols)))
return NULL;
index = 0;
memcpy(&rows, cdata+index, sizeof(uint32_t));
index += sizeof(uint32_t);
memcpy(&cols, cdata+index, sizeof(uint32_t));
index += sizeof(uint32_t);
if(swap) {
rows=swap4(rows);
cols=swap4(cols);
}
size=rows*cols;
if(rows<1 || cols<1 || size < 1)
goto cleanup;
if(size*sizeof(float32_t) > datasize) {
goto cleanup;
}
if(!mtx) {
mtx=(ambix_matrix_t*)calloc(1, sizeof(ambix_matrix_t));
if(!mtx)
goto cleanup;
}
if(!ambix_matrix_init(rows, cols, mtx))
goto cleanup;
if(swap) {
if(_ambix_matrix_fill_data_byteswapped(mtx, (number32_t*)(cdata+index)) != AMBIX_ERR_SUCCESS)
goto cleanup;
} else {
if(ambix_matrix_fill_data(mtx, (float32_t*)(cdata+index)) != AMBIX_ERR_SUCCESS)
goto cleanup;
}
return mtx;
cleanup:
if(mtx && mtx!=orgmtx) {
ambix_matrix_deinit(mtx);
free(mtx);
mtx=NULL;
}
return NULL;
}
