Exemple #1
0
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);
}
Exemple #2
0
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);
}
Exemple #3
0
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;
}
Exemple #4
0
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;
}
Exemple #5
0
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);
}
Exemple #6
0
void
ambix_matrix_destroy(ambix_matrix_t*mtx) {
  ambix_matrix_deinit(mtx);
  free(mtx);
  mtx=NULL;
}
Exemple #7
0
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);
}
Exemple #8
0
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;
}