int _nrrdContentSet_nva(Nrrd *nout, const char *func, char *content, const char *format, va_list arg) { char me[]="_nrrdContentSet_nva", err[BIFF_STRLEN], *buff; buff = (char *)malloc(128*AIR_STRLEN_HUGE); if (!buff) { sprintf(err, "%s: couln't alloc buffer!", me); biffAdd(NRRD, err); return 1; } nout->content = (char *)airFree(nout->content); /* we are currently praying that this won't overflow the "buff" array */ /* HEY: replace with vsnprintf or whatever when its available */ vsprintf(buff, format, arg); nout->content = (char *)calloc(strlen("(,)") + airStrlen(func) + 1 /* '(' */ + airStrlen(content) + 1 /* ',' */ + airStrlen(buff) + 1 /* ')' */ + 1, sizeof(char)); /* '\0' */ if (!nout->content) { sprintf(err, "%s: couln't alloc output content!", me); biffAdd(NRRD, err); airFree(buff); return 1; } sprintf(nout->content, "%s(%s%s%s)", func, content, airStrlen(buff) ? "," : "", buff); airFree(buff); /* no NULL assignment, else compile warnings */ return 0; }
/* ** _nrrdGzDestroy() ** ** Cleans up then free the given _NrrdGzStream. Returns a zlib error code. ** Try freeing in the reverse order of allocations. FILE* s->file is not ** closed. Because we didn't allocate it, we shouldn't delete it. */ static int _nrrdGzDestroy(_NrrdGzStream *s) { static const char me[]="_nrrdGzDestroy"; int error = Z_OK; if (s == NULL) { biffAddf(NRRD, "%s: invalid stream", me); return 1; } s->msg = (char *)airFree(s->msg); if (s->stream.state != NULL) { if (s->mode == 'w') { error = deflateEnd(&(s->stream)); } else if (s->mode == 'r') { error = inflateEnd(&(s->stream)); } } if (error != Z_OK) { biffAddf(NRRD, "%s: %s", me, _NRRD_GZ_ERR_MSG(error)); } if (s->z_err < 0) error = s->z_err; if (error != Z_OK) { biffAddf(NRRD, "%s: %s", me, _NRRD_GZ_ERR_MSG(error)); } s->inbuf = (Byte *)airFree(s->inbuf); s->outbuf = (Byte *)airFree(s->outbuf); airFree(s); /* avoiding unused value warnings, no NULL set */ return error != Z_OK; }
/* ******** nrrdContentSet ** ** Kind of like sprintf, but for the content string of the nrrd. ** ** Whether or not we write a new content for an old nrrd ("nin") with ** NULL content is decided here, according to ** nrrdStateAlwaysSetContent. ** ** Does the string allocation and some attempts at error detection. ** Does allow nout==nin, which requires some care. */ int nrrdContentSet_va(Nrrd *nout, const char *func, const Nrrd *nin, const char *format, ...) { static const char me[]="nrrdContentSet_va"; va_list ap; char *content; if (!(nout && func && nin && format)) { biffAddf(NRRD, "%s: got NULL pointer", me); return 1; } if (nrrdStateDisableContent) { /* we kill content always */ nout->content = (char *)airFree(nout->content); return 0; } if (!nin->content && !nrrdStateAlwaysSetContent) { /* there's no input content, and we're not supposed to invent any content, so after freeing nout's content we're done */ nout->content = (char *)airFree(nout->content); return 0; } /* we copy the input nrrd content first, before blowing away the output content, in case nout == nin */ content = _nrrdContentGet(nin); va_start(ap, format); if (_nrrdContentSet_nva(nout, func, content, format, ap)) { biffAddf(NRRD, "%s:", me); va_end(ap); free(content); return 1; } va_end(ap); free(content); return 0; }
/* ******** nrrdNix() ** ** does nothing with the array data inside, just does whatever is needed ** to free the nrrd itself ** ** returns NULL ** ** this does NOT use biff */ Nrrd * nrrdNix(Nrrd *nrrd) { int ii; if (nrrd) { for (ii=0; ii<NRRD_DIM_MAX; ii++) { _nrrdAxisInfoInit(&(nrrd->axis[ii])); } for (ii=0; ii<NRRD_SPACE_DIM_MAX; ii++) { nrrd->spaceUnits[ii] = (char *)airFree(nrrd->spaceUnits[ii]); } nrrd->content = (char *)airFree(nrrd->content); nrrd->sampleUnits = (char *)airFree(nrrd->sampleUnits); nrrdCommentClear(nrrd); nrrd->cmtArr = airArrayNix(nrrd->cmtArr); nrrdKeyValueClear(nrrd); nrrd->kvpArr = airArrayNix(nrrd->kvpArr); airFree(nrrd); } return NULL; }
/* ******** meetPullVolNix ** ** this frees stuff allocated meetPullVolParse and meetPullVolLoadMulti */ meetPullVol * meetPullVolNix(meetPullVol *mpv) { if (mpv) { if (!mpv->leeching && mpv->nin) { nrrdNuke(mpv->nin); } if (mpv->numSS) { unsigned int ssi; if (mpv->ninSS) { /* need this check because the mpv may not have benefitted from meetPullVolLoadMulti, so it might be incomplete */ for (ssi=0; ssi<mpv->numSS; ssi++) { if (!mpv->leeching) { nrrdNuke(mpv->ninSS[ssi]); } } airFree(mpv->ninSS); } airFree(mpv->posSS); } airFree(mpv->fileName); airFree(mpv->volName); airFree(mpv); } return NULL; }
/* ** _ell_inv ** ** Invert NNxNN matrix based on LU-decomposition ** ** The given matrix is copied, turned into its LU-decomposition, and ** then repeated backsubstitution is used to get successive columns of ** the inverse. */ int _ell_inv(double *inv, double *_mat, size_t NN) { static const char me[]="_ell_inv"; size_t ii, jj, *indx=NULL; double *col=NULL, *mat=NULL; int ret=0; if (!( (col = (double*)calloc(NN, sizeof(double))) && (mat = (double*)calloc(NN*NN, sizeof(double))) && (indx = (size_t*)calloc(NN, sizeof(size_t))) )) { biffAddf(ELL, "%s: couldn't allocate all buffers", me); ret = 1; goto seeya; } memcpy(mat, _mat, NN*NN*sizeof(double)); if (_ell_LU_decomp(mat, indx, NN)) { biffAddf(ELL, "%s: trouble", me); ret = 1; goto seeya; } for (jj=0; jj<NN; jj++) { memset(col, 0, NN*sizeof(double)); col[jj] = 1.0; _ell_LU_back_sub(mat, indx, col, NN); /* set column jj of inv to result of backsub */ for (ii=0; ii<NN; ii++) { inv[ii*NN + jj] = col[ii]; } } seeya: airFree(col); airFree(mat); airFree(indx); return ret; }
baneClip * baneClipNix(baneClip *clip) { if (clip) { airFree(clip->name); airFree(clip); } return NULL; }
tkwbSlide * tkwbSlideNix(tkwbSlide *slide) { slide->title = (char *)airFree(slide->title); slide->image = (char *)airFree(slide->image); slide->text = (char *)airFree(slide->text); slide = (tkwbSlide *)airFree(slide); return NULL; }
pullInfoSpec * pullInfoSpecNix(pullInfoSpec *ispec) { if (ispec) { airFree(ispec->volName); airFree(ispec); } return NULL; }
miteThread * miteThreadNix(miteThread *mtt) { mtt->ansMiteVal = (double *)airFree(mtt->ansMiteVal); mtt->directAnsMiteVal = (double **)airFree(mtt->directAnsMiteVal); airMopOkay(mtt->rmop); airFree(mtt); return NULL; }
biffMsg * biffMsgNix(biffMsg *msg) { if (msg && msg != biffMsgNoop) { airFree(msg->key); airArrayLenSet(msg->errArr, 0); /* frees all msg->err[i] */ airArrayNuke(msg->errArr); airFree(msg); } return NULL; }
tenExperSpec* tenExperSpecNix(tenExperSpec *espec) { if (espec) { airFree(espec->bval); airFree(espec->grad); /* espec->wght = airFree(espec->wght); */ airFree(espec); } return NULL; }
coilTask * _coilTaskNix(coilTask *task) { if (task) { task->thread = airThreadNix(task->thread); task->_iv3 = (coil_t *)airFree(task->_iv3); task->iv3 = (coil_t **)airFree(task->iv3); free(task); } return NULL; }
int limnPolyDataAlloc(limnPolyData *pld, unsigned int infoBitFlag, unsigned int vertNum, unsigned int indxNum, unsigned int primNum) { char me[]="limnPolyDataAlloc", err[BIFF_STRLEN]; if (!pld) { sprintf(err, "%s: got NULL pointer", me); biffAdd(LIMN, err); return 1; } if (vertNum != pld->xyzwNum) { pld->xyzw = (float *)airFree(pld->xyzw); if (vertNum) { pld->xyzw = (float *)calloc(vertNum, 4*sizeof(float)); if (!pld->xyzw) { sprintf(err, "%s: couldn't allocate %u xyzw", me, vertNum); biffAdd(LIMN, err); return 1; } } pld->xyzwNum = vertNum; } if (_limnPolyDataInfoAlloc(pld, infoBitFlag, vertNum)) { sprintf(err, "%s: couldn't allocate info", me); biffAdd(LIMN, err); return 1; } if (indxNum != pld->indxNum) { pld->indx = (unsigned int *)airFree(pld->indx); if (indxNum) { pld->indx = (unsigned int *)calloc(indxNum, sizeof(unsigned int)); if (!pld->indx) { sprintf(err, "%s: couldn't allocate %u indices", me, indxNum); biffAdd(LIMN, err); return 1; } } pld->indxNum = indxNum; } if (primNum != pld->primNum) { pld->type = (unsigned char *)airFree(pld->type); pld->icnt = (unsigned int *)airFree(pld->icnt); if (primNum) { pld->type = (unsigned char *)calloc(primNum, sizeof(unsigned char)); pld->icnt = (unsigned int *)calloc(primNum, sizeof(unsigned int)); if (!(pld->type && pld->icnt)) { sprintf(err, "%s: couldn't allocate %u primitives", me, primNum); biffAdd(LIMN, err); return 1; } } pld->primNum = primNum; } return 0; }
NrrdIoState * nrrdIoStateNix(NrrdIoState *nio) { nio->path = (char *)airFree(nio->path); nio->base = (char *)airFree(nio->base); nio->line = (char *)airFree(nio->line); nio->dataFNFormat = (char *)airFree(nio->dataFNFormat); nio->dataFNArr = airArrayNuke(nio->dataFNArr); /* the NrrdIoState never owned nio->oldData; we don't free it */ airFree(nio); /* no NULL assignment, else compile warnings */ return NULL; }
pullVolume * pullVolumeNix(pullVolume *vol) { if (vol) { vol->name = airFree(vol->name); vol->ksp00 = nrrdKernelSpecNix(vol->ksp00); vol->ksp11 = nrrdKernelSpecNix(vol->ksp11); vol->ksp22 = nrrdKernelSpecNix(vol->ksp22); vol->kspSS = nrrdKernelSpecNix(vol->kspSS); vol->gctx = gageContextNix(vol->gctx); airFree(vol); } return NULL; }
void mossSamplerEmpty (mossSampler *smplr) { if (smplr) { smplr->ivc = (float *)airFree(smplr->ivc); smplr->xFslw = (double *)airFree(smplr->xFslw); smplr->yFslw = (double *)airFree(smplr->yFslw); smplr->xIdx = (int *)airFree(smplr->xIdx); smplr->yIdx = (int *)airFree(smplr->yIdx); smplr->fdiam = 0; smplr->ncol = 0; } return; }
airThreadMutex * airThreadMutexNix(airThreadMutex *mutex) { CloseHandle(mutex->handle); mutex = airFree(mutex); return mutex; }
int coilFinish(coilContext *cctx) { char me[]="coilFinish", err[BIFF_STRLEN]; unsigned int tidx; if (!cctx) { sprintf(err, "%s: got NULL pointer", me); biffAdd(COIL, err); return 1; } if (cctx->verbose > 1) { fprintf(stderr, "%s: finishing workers\n", me); } cctx->finished = AIR_TRUE; if (cctx->numThreads > 1) { airThreadBarrierWait(cctx->filterBarrier); for (tidx=1; tidx<cctx->numThreads; tidx++) { airThreadJoin(cctx->task[tidx]->thread, &(cctx->task[tidx]->returnPtr)); cctx->task[tidx]->thread = airThreadNix(cctx->task[tidx]->thread); cctx->task[tidx] = _coilTaskNix(cctx->task[tidx]); } } cctx->task[0]->thread = airThreadNix(cctx->task[0]->thread); cctx->task[0] = _coilTaskNix(cctx->task[0]); cctx->task = (coilTask **)airFree(cctx->task); if (cctx->numThreads > 1) { cctx->nextSliceMutex = airThreadMutexNix(cctx->nextSliceMutex); cctx->filterBarrier = airThreadBarrierNix(cctx->filterBarrier); cctx->updateBarrier = airThreadBarrierNix(cctx->updateBarrier); } return 0; }
gageKind * _meetGageKindParse(const char *_str, int constOnly) { char *str; gageKind *ret; if (!_str) { return NULL; } str = airToLower(airStrdup(_str)); if (!str) { return NULL; } if (!strcmp(gageKindScl->name, str)) { ret = gageKindScl; } else if (!strcmp(gageKindVec->name, str)) { ret = gageKindVec; } else if (!strcmp(tenGageKind->name, str)) { ret = tenGageKind; } else if (!constOnly && !strcmp(TEN_DWI_GAGE_KIND_NAME, str)) { ret = tenDwiGageKindNew(); } else { ret = NULL; } airFree(str); return ret; }
/* ******** nrrdKeyValueAdd ** ** This will COPY the given strings, and so does not depend on ** them existing past the return of this function ** ** NOTE: Despite what might be most logical, there is no effort made ** here to cleanup key or value, including any escaping or filtering ** that might be warranted for white space other than \n ** ** does NOT use BIFF */ int nrrdKeyValueAdd(Nrrd *nrrd, const char *key, const char *value) { unsigned int ki; int found; if (!( nrrd && key && value )) { /* got NULL pointer */ return 1; } if (!strlen(key)) { /* reject empty keys */ return 1; } ki = _kvpIdxFind(nrrd, key, &found); if (found) { /* over-writing value for an existing key, so have to free old value */ airFree(nrrd->kvp[1 + 2*ki]); nrrd->kvp[1 + 2*ki] = airStrdup(value); } else { /* adding value for a new key */ ki = airArrayLenIncr(nrrd->kvpArr, 1); nrrd->kvp[0 + 2*ki] = airStrdup(key); nrrd->kvp[1 + 2*ki] = airStrdup(value); } return 0; }
miteRender * _miteRenderNew(void) { miteRender *mrr; mrr = (miteRender *)calloc(1, sizeof(miteRender)); if (mrr) { mrr->rmop = airMopNew(); if (!mrr->rmop) { airFree(mrr); return NULL; } mrr->ntxf = NULL; mrr->ntxfNum = 0; mrr->sclPvlIdx = -1; mrr->vecPvlIdx = -1; mrr->tenPvlIdx = -1; mrr->normalSpec = gageItemSpecNew(); airMopAdd(mrr->rmop, mrr->normalSpec, (airMopper)gageItemSpecNix, airMopAlways); mrr->shadeSpec = miteShadeSpecNew(); airMopAdd(mrr->rmop, mrr->shadeSpec, (airMopper)miteShadeSpecNix, airMopAlways); mrr->time0 = AIR_NAN; GAGE_QUERY_RESET(mrr->queryMite); mrr->queryMiteNonzero = AIR_FALSE; } return mrr; }
int dyeColorParse(dyeColor *col, char *_str) { char me[]="dyeColorParse", err[128], *str; char *colon, *valS; float v0, v1, v2; int spc; if (!(col && _str)) { sprintf(err, "%s: got NULL pointer", me); biffAdd(DYE, err); return 1; } if (!(str = airStrdup(_str))) { sprintf(err, "%s: couldn't strdup!", me); biffAdd(DYE, err); return 1; } if (!(colon = strchr(str, ':'))) { sprintf(err, "%s: given string \"%s\" didn't contain colon", me, str); biffAdd(DYE, err); return 1; } *colon = '\0'; valS = colon+1; if (3 != sscanf(valS, "%g,%g,%g", &v0, &v1, &v2)) { sprintf(err, "%s: couldn't parse three floats from \"%s\"", me, valS); biffAdd(DYE, err); return 1; } spc = dyeStrToSpace(str); if (dyeSpaceUnknown == spc) { sprintf(err, "%s: couldn't parse colorspace from \"%s\"", me, str); biffAdd(DYE, err); return 1; } str = (char *)airFree(str); dyeColorSet(col, spc, v0, v1, v2); return 0; }
/* ******** nrrdSpaceSet ** ** What to use to set space, when a value from nrrdSpace enum is known, ** or, to nullify all space-related information when passed nrrdSpaceUnknown */ int nrrdSpaceSet(Nrrd *nrrd, int space) { static const char me[]="nrrdSpaceSet"; unsigned axi, saxi; if (!nrrd) { biffAddf(NRRD, "%s: got NULL pointer", me); return 1; } if (nrrdSpaceUnknown == space) { nrrd->space = nrrdSpaceUnknown; nrrd->spaceDim = 0; for (axi=0; axi<NRRD_DIM_MAX; axi++) { nrrdSpaceVecSetNaN(nrrd->axis[axi].spaceDirection); } for (saxi=0; saxi<NRRD_SPACE_DIM_MAX; saxi++) { airFree(nrrd->spaceUnits[saxi]); nrrd->spaceUnits[saxi] = NULL; } nrrdSpaceVecSetNaN(nrrd->spaceOrigin); } else { if (airEnumValCheck(nrrdSpace, space)) { biffAddf(NRRD, "%s: given space (%d) not valid", me, space); return 1; } nrrd->space = space; nrrd->spaceDim = nrrdSpaceDimension(space); } return 0; }
echoGlobalState * echoGlobalStateNix(echoGlobalState *state) { airFree(state); /* mutex freed at end of echoRTRender() */ return NULL; }
void nrrdIoStateInit(NrrdIoState *nio) { if (nio) { nio->path = (char *)airFree(nio->path); nio->base = (char *)airFree(nio->base); nio->line = (char *)airFree(nio->line); nio->dataFNFormat = (char *)airFree(nio->dataFNFormat); /* the way IO to/from strings works, I don't think this should be freed */ nio->headerStringRead = NULL; nio->headerStringWrite = NULL; airArrayLenSet(nio->dataFNArr, 0); /* closing this is always someone else's responsibility */ nio->headerFile = NULL; nio->dataFile = NULL; nio->dataFileDim = 0; nio->dataFNMin = 0; nio->dataFNMax = 0; nio->dataFNStep = 0; nio->dataFNIndex = -1; nio->lineLen = 0; nio->pos = 0; nio->endian = airEndianUnknown; nio->lineSkip = 0; nio->headerStrlen = 0; nio->headerStrpos = 0; nio->byteSkip = 0; memset(nio->seen, 0, (NRRD_FIELD_MAX+1)*sizeof(int)); nio->detachedHeader = AIR_FALSE; nio->bareText = nrrdDefaultWriteBareText; nio->charsPerLine = nrrdDefaultWriteCharsPerLine; nio->valsPerLine = nrrdDefaultWriteValsPerLine; nio->skipData = AIR_FALSE; nio->keepNrrdDataFileOpen = AIR_FALSE; nio->zlibLevel = -1; nio->zlibStrategy = nrrdZlibStrategyDefault; nio->bzip2BlockSize = -1; nio->learningHeaderStrlen = AIR_FALSE; nio->oldData = NULL; nio->oldDataSize = 0; nio->format = nrrdFormatUnknown; nio->encoding = nrrdEncodingUnknown; } return; }
/* ** doesn't set pld->xyzwNum, only the per-attribute xxxNum variables */ int _limnPolyDataInfoAlloc(limnPolyData *pld, unsigned int infoBitFlag, unsigned int vertNum) { char me[]="_limnPolyDataInfoAlloc", err[BIFF_STRLEN]; if (vertNum != pld->rgbaNum && ((1 << limnPolyDataInfoRGBA) & infoBitFlag)) { pld->rgba = (unsigned char *)airFree(pld->rgba); if (vertNum) { pld->rgba = (unsigned char *)calloc(vertNum, 4*sizeof(unsigned char)); if (!pld->rgba) { sprintf(err, "%s: couldn't allocate %u rgba", me, vertNum); biffAdd(LIMN, err); return 1; } } pld->rgbaNum = vertNum; } if (vertNum != pld->normNum && ((1 << limnPolyDataInfoNorm) & infoBitFlag)) { pld->norm = (float *)airFree(pld->norm); if (vertNum) { pld->norm = (float *)calloc(vertNum, 4*sizeof(float)); if (!pld->norm) { sprintf(err, "%s: couldn't allocate %u norm", me, vertNum); biffAdd(LIMN, err); return 1; } } pld->normNum = vertNum; } if (vertNum != pld->tex2Num && ((1 << limnPolyDataInfoTex2) & infoBitFlag)) { pld->tex2 = (float *)airFree(pld->tex2); if (vertNum) { pld->tex2 = (float *)calloc(vertNum, 4*sizeof(float)); if (!pld->tex2) { sprintf(err, "%s: couldn't allocate %u tex2", me, vertNum); biffAdd(LIMN, err); return 1; } } pld->tex2Num = vertNum; } return 0; }
void _nrrdAxisInfoInit(NrrdAxisInfo *axis) { int dd; if (axis) { axis->size = 0; axis->spacing = axis->thickness = AIR_NAN; axis->min = axis->max = AIR_NAN; for (dd=0; dd<NRRD_SPACE_DIM_MAX; dd++) { axis->spaceDirection[dd] = AIR_NAN; } axis->center = nrrdCenterUnknown; axis->kind = nrrdKindUnknown; axis->label = (char *)airFree(axis->label); axis->units = (char *)airFree(axis->units); } }
airThreadBarrier * airThreadBarrierNix(airThreadBarrier *barrier) { barrier->doneMutex = airThreadMutexNix(barrier->doneMutex); barrier->doneCond = airThreadCondNix(barrier->doneCond); airFree(barrier); return NULL; }
baneRange * baneRangeNix(baneRange *range) { if (range) { airFree(range); } return NULL; }