void PtexReader::PackedFace::reduce(FaceData*& face, PtexReader* r, Res newres, PtexUtils::ReduceFn reducefn) { // get reduce lock and make sure we still need to reduce AutoMutex rlocker(r->reducelock); if (face) { // another thread must have generated it while we were waiting AutoLockCache clocker(_cache->cachelock); // make sure it's still there now that we have the lock if (face) { face->ref(); return; } } // allocate a new face and reduce image DataType dt = r->datatype(); int nchan = r->nchannels(); PackedFace* pf = new PackedFace((void**)&face, _cache, newres, _pixelsize, _pixelsize * newres.size()); // reduce and copy into new face reducefn(_data, _pixelsize * _res.u(), _res.u(), _res.v(), pf->_data, _pixelsize * newres.u(), dt, nchan); AutoLockCache clocker(_cache->cachelock); face = pf; // clean up unused data _cache->purgeData(); }
Ptex::Res PtexWriterBase::calcTileRes(Res faceres) { // desired number of tiles = floor(log2(facesize / tilesize)) int facesize = faceres.size() * _pixelSize; int ntileslog2 = PtexUtils::floor_log2(facesize/TileSize); if (ntileslog2 == 0) return faceres; // number of tiles is defined as: // ntileslog2 = ureslog2 + vreslog2 - (tile_ureslog2 + tile_vreslog2) // rearranging to solve for the tile res: // tile_ureslog2 + tile_vreslog2 = ureslog2 + vreslog2 - ntileslog2 int n = faceres.ulog2 + faceres.vlog2 - ntileslog2; // choose u and v sizes for roughly square result (u ~= v ~= n/2) // and make sure tile isn't larger than face Res tileres; tileres.ulog2 = PtexUtils::min((n+1)/2, int(faceres.ulog2)); tileres.vlog2 = PtexUtils::min(n - tileres.ulog2, int(faceres.vlog2)); return tileres; }
void PtexMainWriter::generateReductions() { // first generate "rfaceids", reduction faceids, // which are faceids reordered by decreasing smaller dimension int nfaces = _header.nfaces; _rfaceids.resize(nfaces); _faceids_r.resize(nfaces); PtexUtils::genRfaceids(&_faceinfo[0], nfaces, &_rfaceids[0], &_faceids_r[0]); // determine how many faces in each level, and resize _levels // traverse in reverse rfaceid order to find number of faces // larger than cutoff size of each level for (int rfaceid = nfaces-1, cutoffres = MinReductionLog2; rfaceid >= 0; rfaceid--) { int faceid = _faceids_r[rfaceid]; FaceInfo& face = _faceinfo[faceid]; Res res = face.res; int min = face.isConstant() ? 1 : PtexUtils::min(res.ulog2, res.vlog2); while (min > cutoffres) { // i == last face for current level int size = rfaceid+1; _levels.push_back(LevelRec()); LevelRec& level = _levels.back(); level.pos.resize(size); level.fdh.resize(size); cutoffres++; } } // generate and cache reductions (including const data) // first, find largest face and allocate tmp buffer int buffsize = 0; for (int i = 0; i < nfaces; i++) buffsize = PtexUtils::max(buffsize, _faceinfo[i].res.size()); buffsize *= _pixelSize; char* buff = (char*) malloc(buffsize); int nlevels = int(_levels.size()); for (int i = 1; i < nlevels; i++) { LevelRec& level = _levels[i]; int nextsize = (i+1 < nlevels)? int(_levels[i+1].fdh.size()) : 0; for (int rfaceid = 0, size = int(level.fdh.size()); rfaceid < size; rfaceid++) { // output current reduction for face (previously generated) int faceid = _faceids_r[rfaceid]; Res res = _faceinfo[faceid].res; res.ulog2 -= i; res.vlog2 -= i; int stride = res.u() * _pixelSize; int blocksize = res.size() * _pixelSize; fseeko(_tmpfp, _rpos[faceid], SEEK_SET); readBlock(_tmpfp, buff, blocksize); fseeko(_tmpfp, 0, SEEK_END); level.pos[rfaceid] = ftello(_tmpfp); writeFaceData(_tmpfp, buff, stride, res, level.fdh[rfaceid]); if (!_ok) return; // write a new reduction if needed for next level if (rfaceid < nextsize) { fseeko(_tmpfp, _rpos[faceid], SEEK_SET); writeReduction(_tmpfp, buff, stride, res); } else { // the last reduction for each face is its constant value storeConstValue(faceid, buff, stride, res); } } } fseeko(_tmpfp, 0, SEEK_END); free(buff); }
void PtexReader::TiledFaceBase::reduce(FaceData*& face, PtexReader* r, Res newres, PtexUtils::ReduceFn reducefn) { // get reduce lock and make sure we still need to reduce AutoMutex rlocker(r->reducelock); if (face) { // another thread must have generated it while we were waiting AutoLockCache clocker(_cache->cachelock); // make sure it's still there now that we have the lock if (face) { face->ref(); return; } } /* Tiled reductions should generally only be anisotropic (just u or v, not both) since isotropic reductions are precomputed and stored on disk. (This function should still work for isotropic reductions though.) In the anisotropic case, the number of tiles should be kept the same along the direction not being reduced in order to preserve the laziness of the file access. In contrast, if reductions were not tiled, then any reduction would read all the tiles and defeat the purpose of tiling. */ // keep new face local until fully initialized FaceData* volatile newface = 0; // don't tile if either dimension is 1 (rare, would complicate blendFaces too much) // also, don't tile triangle reductions (too complicated) Res newtileres; bool isTriangle = r->_header.meshtype == mt_triangle; if (newres.ulog2 == 1 || newres.vlog2 == 1 || isTriangle) { newtileres = newres; } else { // propagate the tile res to the reduction newtileres = _tileres; // but make sure tile isn't larger than the new face! if (newtileres.ulog2 > newres.ulog2) newtileres.ulog2 = newres.ulog2; if (newtileres.vlog2 > newres.vlog2) newtileres.vlog2 = newres.vlog2; } // determine how many tiles we will have on the reduction int newntiles = newres.ntiles(newtileres); if (newntiles == 1) { // no need to keep tiling, reduce tiles into a single face // first, get all tiles and check if they are constant (with the same value) PtexFaceData** tiles = (PtexFaceData**) alloca(_ntiles * sizeof(PtexFaceData*)); bool allConstant = true; for (int i = 0; i < _ntiles; i++) { PtexFaceData* tile = tiles[i] = getTile(i); allConstant = (allConstant && tile->isConstant() && (i == 0 || (0 == memcmp(tiles[0]->getData(), tile->getData(), _pixelsize)))); } if (allConstant) { // allocate a new constant face newface = new ConstantFace((void**)&face, _cache, _pixelsize); memcpy(newface->getData(), tiles[0]->getData(), _pixelsize); } else if (isTriangle) { // reassemble all tiles into temporary contiguous image // (triangle reduction doesn't work on tiles) int tileures = _tileres.u(); int tilevres = _tileres.v(); int sstride = _pixelsize * tileures; int dstride = sstride * _ntilesu; int dstepv = dstride * tilevres - sstride*(_ntilesu-1); char* tmp = (char*) malloc(_ntiles * _tileres.size() * _pixelsize); char* tmpptr = tmp; for (int i = 0; i < _ntiles;) { PtexFaceData* tile = tiles[i]; if (tile->isConstant()) PtexUtils::fill(tile->getData(), tmpptr, dstride, tileures, tilevres, _pixelsize); else PtexUtils::copy(tile->getData(), sstride, tmpptr, dstride, tilevres, sstride); i++; tmpptr += i%_ntilesu ? sstride : dstepv; } // allocate a new packed face newface = new PackedFace((void**)&face, _cache, newres, _pixelsize, _pixelsize * newres.size()); // reduce and copy into new face reducefn(tmp, _pixelsize * _res.u(), _res.u(), _res.v(), newface->getData(), _pixelsize * newres.u(), _dt, _nchan); free(tmp); } else { // allocate a new packed face newface = new PackedFace((void**)&face, _cache, newres, _pixelsize, _pixelsize*newres.size()); int tileures = _tileres.u(); int tilevres = _tileres.v(); int sstride = _pixelsize * tileures; int dstride = _pixelsize * newres.u(); int dstepu = dstride/_ntilesu; int dstepv = dstride*newres.v()/_ntilesv - dstepu*(_ntilesu-1); char* dst = (char*) newface->getData(); for (int i = 0; i < _ntiles;) { PtexFaceData* tile = tiles[i]; if (tile->isConstant()) PtexUtils::fill(tile->getData(), dst, dstride, newres.u()/_ntilesu, newres.v()/_ntilesv, _pixelsize); else reducefn(tile->getData(), sstride, tileures, tilevres, dst, dstride, _dt, _nchan); i++; dst += i%_ntilesu ? dstepu : dstepv; } } // release the tiles for (int i = 0; i < _ntiles; i++) tiles[i]->release(); } else { // otherwise, tile the reduced face newface = new TiledReducedFace((void**)&face, _cache, newres, newtileres, _dt, _nchan, this, reducefn); } AutoLockCache clocker(_cache->cachelock); face = newface; // clean up unused data _cache->purgeData(); }