int64_t ambixtest_writef (ambix_t *ambix, ambixtest_presentationformat_t fmt, const void*ambidata , const uint64_t ambioffset, const void*otherdata, const uint64_t otheroffset, int64_t frames) { switch(fmt) { case INT16 : return ambix_writef_int16(ambix, ((const int16_t*)ambidata)+ambioffset, ((const int16_t*)otherdata)+otheroffset, frames); case INT32 : return ambix_writef_int32(ambix, ((const int32_t*)ambidata)+ambioffset, ((const int32_t*)otherdata)+otheroffset, frames); case FLOAT32: return ambix_writef_float32(ambix, ((const float32_t*)ambidata)+ambioffset, ((const float32_t*)otherdata)+otheroffset, frames); case FLOAT64: return ambix_writef_float64(ambix, ((const float64_t*)ambidata)+ambioffset, ((const float64_t*)otherdata)+otheroffset, frames); default : break; } return -1; }
void write_to_disk(struct recorder *d, int nframes) { int nsamples = nframes; ambix_writef_float32(d->sound_file, d->a_buffer, d->e_buffer, nsamples); }
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 check_create_none(const char*path, ambix_sampleformat_t format) { ambix_info_t info, rinfo, winfo; ambix_t*ambix=NULL; float32_t*orgdata,*data,*resultdata; uint32_t frames=44100; uint32_t channels=6; float32_t periods=10; uint32_t err32; float32_t diff=0., eps=1e-30; resultdata=(float32_t*)calloc(channels*frames, sizeof(float32_t)); data=(float32_t*)calloc(channels*frames, sizeof(float32_t)); memset(&winfo, 0, sizeof(winfo)); memset(&info, 0, sizeof(info)); info.fileformat=AMBIX_NONE; info.ambichannels=0; info.extrachannels=channels; 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); orgdata=data_sine(frames, channels, periods); //data_print(orgdata, 100); memcpy(data, orgdata, frames*channels*sizeof(float32_t)); fail_if((NULL==data), __LINE__, "couldn't create data %dx%d sine @ %f", frames, channels, periods); err32=ambix_writef_float32(ambix, NULL, data, frames); fail_if((err32!=frames), __LINE__, "wrote only %d frames of %d", err32, frames); diff=data_diff(__LINE__, orgdata, data, frames*channels, eps); fail_if((diff>eps), __LINE__, "data diff %f > %f", diff, eps); fail_if((AMBIX_ERR_SUCCESS!=ambix_close(ambix)), __LINE__, "closing ambix file %p", ambix); ambix=NULL; 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", info.fileformat, rinfo.fileformat); fail_if((info.samplerate!=rinfo.samplerate), __LINE__, "samplerate mismatch %g!=%g", info.samplerate, rinfo.samplerate); fail_if((info.sampleformat!=rinfo.sampleformat), __LINE__, "sampleformat mismatch %d!=%d", info.sampleformat, rinfo.sampleformat); fail_if((info.ambichannels!=rinfo.ambichannels), __LINE__, "ambichannels mismatch %d!=%d", info.ambichannels, rinfo.ambichannels); fail_if((info.extrachannels!=rinfo.extrachannels), __LINE__, "extrachannels mismatch %d!=%d", info.extrachannels, rinfo.extrachannels); err32=ambix_readf_float32(ambix, NULL, resultdata, frames); fail_if((err32!=frames), __LINE__, "wrote only %d frames of %d", err32, frames); diff=data_diff(__LINE__, orgdata, resultdata, frames*channels, eps); fail_if((diff>eps), __LINE__, "data diff %f > %f", diff, eps); fail_if((AMBIX_ERR_SUCCESS!=ambix_close(ambix)), __LINE__, "closing ambix file %p", ambix); ambix=NULL; free(resultdata); free(data); free(orgdata); unlink(path); }
static void *ambix_write_child_main(void *zz) { t_ambix_write *x = (t_ambix_write*)zz; ambix_t*ambix=NULL; pthread_mutex_lock(&x->x_mutex); while (1) { if (x->x_requestcode == REQUEST_NOTHING) { pthread_cond_signal(&x->x_answercondition); pthread_cond_wait(&x->x_requestcondition, &x->x_mutex); } else if (x->x_requestcode == REQUEST_OPEN) { int sysrtn, writeframes; ambix_info_t ainfo; /* copy file stuff out of the data structure so we can relinquish the mutex while we're in open_soundfile(). */ int64_t onsetframes = x->x_onsetframes; ambix_fileformat_t fileformat = x->x_fileformat; ambix_sampleformat_t sampleformat = x->x_sampleformat; uint32_t ambichannels = x->x_ambichannels; uint32_t xtrachannels = x->x_extrachannels; int localfifosize = x->x_fifosize; float32_t*ambibuf = NULL; float32_t*xtrabuf = NULL; double samplerate = x->x_samplerate; ambix_matrix_t*matrix=NULL; char *filename = strndup(x->x_filename, MAXPDSTRING); if(x->x_matrix) matrix=ambix_matrix_copy(x->x_matrix, matrix); /* alter the request code so that an ensuing "open" will get noticed. */ x->x_requestcode = REQUEST_BUSY; x->x_fileerror = 0; /* open the soundfile with the mutex unlocked */ pthread_mutex_unlock(&x->x_mutex); memset(&ainfo, 0, sizeof(ainfo)); ainfo.fileformat=fileformat; ainfo.ambichannels=ambichannels; ainfo.extrachannels=xtrachannels; ainfo.samplerate=samplerate; ainfo.sampleformat=sampleformat; /* if there's already a file open, close it. This should never happen since ambix_write_open() calls stop if needed and then waits until we're idle. */ if (ambix) ambix_close(ambix); ambix=ambix_open(filename, AMBIX_WRITE, &ainfo); free(filename); if(matrix) { if(ambix) ambix_set_adaptormatrix(ambix, matrix); ambix_matrix_destroy(matrix); matrix=NULL; } if(ambix && onsetframes) { ambix_seek(ambix, onsetframes, SEEK_SET); } if(ambix) { ambibuf = (float32_t*)calloc(localfifosize*ambichannels, sizeof(float32_t)); xtrabuf = (float32_t*)calloc(localfifosize*xtrachannels, sizeof(float32_t)); } pthread_mutex_lock(&x->x_mutex); if(NULL==ambix) { x->x_eof = 1; x->x_fileerror = errno; x->x_requestcode = REQUEST_NOTHING; continue; } /* check if another request has been made; if so, field it */ if (x->x_requestcode != REQUEST_BUSY) continue; x->x_fifotail = 0; /* in a loop, wait for the fifo to have data and write it to disk */ while (x->x_requestcode == REQUEST_BUSY || (x->x_requestcode == REQUEST_CLOSE && x->x_fifohead != x->x_fifotail)) { int fifosize = x->x_fifosize, fifotail; t_sample*buf = x->x_buf; /* if the head is < the tail, we can immediately write from tail to end of fifo to disk; otherwise we hold off writing until there are at least WRITESIZE bytes in the buffer */ if (x->x_fifohead < x->x_fifotail || x->x_fifohead >= x->x_fifotail + WRITFRAMES || (x->x_requestcode == REQUEST_CLOSE && x->x_fifohead != x->x_fifotail)) { writeframes = (x->x_fifohead < x->x_fifotail ? fifosize : x->x_fifohead) - x->x_fifotail; if (writeframes > READFRAMES) writeframes = READFRAMES; } else { pthread_cond_signal(&x->x_answercondition); pthread_cond_wait(&x->x_requestcondition, &x->x_mutex); continue; } fifotail = x->x_fifotail; pthread_mutex_unlock(&x->x_mutex); if(localfifosize<fifosize) { free(ambibuf); free(xtrabuf); localfifosize=fifosize; ambibuf = (float32_t*)calloc(localfifosize*ambichannels, sizeof(float32_t)); xtrabuf = (float32_t*)calloc(localfifosize*xtrachannels, sizeof(float32_t)); } split_samples(buf+fifotail*(ambichannels+xtrachannels), writeframes, ambibuf, ambichannels, xtrabuf, xtrachannels); sysrtn = ambix_writef_float32(ambix, ambibuf, xtrabuf, writeframes); pthread_mutex_lock(&x->x_mutex); if (x->x_requestcode != REQUEST_BUSY && x->x_requestcode != REQUEST_CLOSE) break; if (sysrtn < writeframes) { x->x_fileerror = errno; break; } else { x->x_fifotail += sysrtn; if (x->x_fifotail == fifosize) x->x_fifotail = 0; } /* signal parent in case it's waiting for data */ pthread_cond_signal(&x->x_answercondition); } free(ambibuf);free(xtrabuf); } else if (x->x_requestcode == REQUEST_CLOSE || x->x_requestcode == REQUEST_QUIT) { int quit = (x->x_requestcode == REQUEST_QUIT); if (ambix) { pthread_mutex_unlock(&x->x_mutex); ambix_close(ambix); ambix=NULL; pthread_mutex_lock(&x->x_mutex); } x->x_requestcode = REQUEST_NOTHING; pthread_cond_signal(&x->x_answercondition); if (quit) break; } else { } } pthread_mutex_unlock(&x->x_mutex); return (0); }
void check_create_simple(const char*path, ambix_sampleformat_t format, float32_t eps) { ambix_info_t info, rinfo, winfo; ambix_t*ambix=NULL; float32_t*orgdata,*data,*resultdata; uint32_t frames=441000; uint32_t channels=4; float32_t periods=4724; int64_t err64; float32_t diff=0.; uint32_t gotframes; printf("test using '%s' [%d]\n", path, (int)format); resultdata=(float32_t*)calloc(channels*frames, sizeof(float32_t)); data=(float32_t*)calloc(channels*frames, sizeof(float32_t)); memset(&winfo, 0, sizeof(winfo)); memset(&info, 0, sizeof(info)); info.fileformat=AMBIX_BASIC; info.ambichannels=channels; info.extrachannels=0; 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); orgdata=data_sine(FLOAT32, frames, channels, periods); //data_print(FLOAT32, orgdata, 100); memcpy(data, orgdata, frames*channels*sizeof(float32_t)); fail_if((NULL==data), __LINE__, "couldn't create data %dx%d sine @ %f", (int)frames, (int)channels, (float)periods); err64=ambix_writef_float32(ambix, data, NULL, frames); fail_if((err64!=frames), __LINE__, "wrote only %d frames of %d", (int)err64, (int)frames); diff=data_diff(__LINE__, FLOAT32, orgdata, data, frames*channels, eps); fail_if((diff>eps), __LINE__, "data diff %f > %f", diff, eps); fail_if((AMBIX_ERR_SUCCESS!=ambix_close(ambix)), __LINE__, "closing ambix file %p", ambix); ambix=NULL; 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); gotframes=0; do { err64=ambix_readf_float32(ambix, resultdata+(gotframes*channels), NULL, (frames-gotframes)); fail_if((err64<0), __LINE__, "reading frames failed after %d/%d frames", (int)gotframes, (int)frames); gotframes+=err64; } while(err64>0 && gotframes<frames); diff=data_diff(__LINE__, FLOAT32, orgdata, resultdata, frames*channels, eps); fail_if((diff>eps), __LINE__, "data diff %f > %f", diff, eps); fail_if((AMBIX_ERR_SUCCESS!=ambix_close(ambix)), __LINE__, "closing ambix file %p", ambix); ambix=NULL; free(data); free(resultdata); free(orgdata); ambixtest_rmfile(path); }