Ptex
PtexReader.h
Go to the documentation of this file.
1#ifndef PtexReader_h
2#define PtexReader_h
3
4/*
5PTEX SOFTWARE
6Copyright 2014 Disney Enterprises, Inc. All rights reserved
7
8Redistribution and use in source and binary forms, with or without
9modification, are permitted provided that the following conditions are
10met:
11
12 * Redistributions of source code must retain the above copyright
13 notice, this list of conditions and the following disclaimer.
14
15 * Redistributions in binary form must reproduce the above copyright
16 notice, this list of conditions and the following disclaimer in
17 the documentation and/or other materials provided with the
18 distribution.
19
20 * The names "Disney", "Walt Disney Pictures", "Walt Disney Animation
21 Studios" or the names of its contributors may NOT be used to
22 endorse or promote products derived from this software without
23 specific prior written permission from Walt Disney Pictures.
24
25Disclaimer: THIS SOFTWARE IS PROVIDED BY WALT DISNEY PICTURES AND
26CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
27BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
28FOR A PARTICULAR PURPOSE, NONINFRINGEMENT AND TITLE ARE DISCLAIMED.
29IN NO EVENT SHALL WALT DISNEY PICTURES, THE COPYRIGHT HOLDER OR
30CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND BASED ON ANY
34THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
35(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
36OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
37*/
38
39#ifndef PTEXAPI
40# if defined(_WIN32) || defined(_WINDOWS) || defined(_MSC_VER)
41# ifndef PTEX_STATIC
42# ifdef PTEX_EXPORTS
43# define PTEXAPI __declspec(dllexport)
44# else
45# define PTEXAPI __declspec(dllimport)
46# endif
47# else
48# define PTEXAPI
49# endif
50# else
51# define PTEXAPI
52# endif
53#endif
54
55#include <stdio.h>
56#include <zlib.h>
57#include <vector>
58#include <string>
59#include <map>
60#include <errno.h>
61#include "Ptexture.h"
62#include "PtexIO.h"
63#include "PtexUtils.h"
64
65#include "PtexHashMap.h"
66
68
69class PtexReader : public PtexTexture {
70public:
71 PtexReader(bool premultiply, PtexInputHandler* inputHandler, PtexErrorHandler* errorHandler);
72 virtual ~PtexReader();
73 virtual void release() { delete this; }
74 bool needToOpen() const { return _needToOpen; }
75 bool open(const char* path, Ptex::String& error);
76 void prune();
77 void purge();
78 void setPendingPurge() { _pendingPurge = true; }
79 bool pendingPurge() const { return _pendingPurge; }
80 bool tryClose();
81 bool ok() const { return _ok; }
82 bool isOpen() { return _fp; }
83 void invalidate() {
84 _ok = false;
85 _needToOpen = false;
86 }
87
88 void increaseMemUsed(size_t amount) { if (amount) AtomicAdd(&_memUsed, amount); }
91
92 virtual const char* path() { return _path.c_str(); }
93
94 virtual Info getInfo() {
95 Info info;
103 info.numFaces = _header.nfaces;
104 return info;
105 }
106
112 virtual int alphaChannel() { return _header.alphachan; }
113 virtual int numChannels() { return _header.nchannels; }
114 virtual int numFaces() { return _header.nfaces; }
115 virtual bool hasEdits() { return _hasEdits; }
116 virtual bool hasMipMaps() { return _header.nlevels > 1; }
117
118 virtual PtexMetaData* getMetaData();
119 virtual const Ptex::FaceInfo& getFaceInfo(int faceid);
120 virtual void getData(int faceid, void* buffer, int stride);
121 virtual void getData(int faceid, void* buffer, int stride, Res res);
122 virtual PtexFaceData* getData(int faceid);
123 virtual PtexFaceData* getData(int faceid, Res res);
124 virtual void getPixel(int faceid, int u, int v,
125 float* result, int firstchan, int nchannels);
126 virtual void getPixel(int faceid, int u, int v,
127 float* result, int firstchan, int nchannels,
128 Ptex::Res res);
129
131 int nchannels() const { return _header.nchannels; }
132 int pixelsize() const { return _pixelsize; }
133 const Header& header() const { return _header; }
134 const ExtHeader& extheader() const { return _extheader; }
135 const LevelInfo& levelinfo(int level) const { return _levelinfo[level]; }
136
137 class MetaData : public PtexMetaData {
138 public:
140 : _reader(reader) {}
142 virtual void release() {}
143
144 virtual int numKeys() { return int(_entries.size()); }
145 virtual void getKey(int index, const char*& key, MetaDataType& type)
146 {
147 if (index < 0 || index >= int(_entries.size())) {
148 return;
149 }
150 Entry* e = _entries[index];
151 key = e->key;
152 type = e->type;
153 }
154
155 virtual bool findKey(const char* key, int& index, MetaDataType& type)
156 {
157 MetaMap::iterator iter = _map.find(key);
158 if (iter==_map.end()) {
159 index = -1;
160 return false;
161 }
162 index = iter->second.index;
163 type = iter->second.type;
164 return true;
165 }
166
167 virtual void getValue(const char* key, const char*& value)
168 {
169 int index = -1;
170 MetaDataType type;
171 if (!findKey(key, index, type)) {
172 value = 0;
173 return;
174 }
175 Entry* e = getEntry(index);
176 if (e && e->type == mdt_string) value = (const char*) e->data;
177 else value = 0;
178 }
179
180 virtual void getValue(int index, const char*& value)
181 {
182 if (index < 0 || index >= int(_entries.size())) { value = 0; return; }
183 Entry* e = getEntry(index);
184 if (e && e->type == mdt_string) value = (const char*) e->data;
185 else value = 0;
186 }
187
188 template<typename T>
189 void getValue(int index, MetaDataType requestedType, const T*& value, int& count)
190 {
191 if (index < 0 || index >= int(_entries.size())) {
192 value = 0;
193 count = 0;
194 return;
195 }
196 Entry* e = getEntry(index);
197 if (e && e->type == requestedType) {
198 value = (const T*) e->data;
199 count = int(e->datasize/sizeof(T));
200 }
201 else { value = 0; count = 0; }
202 }
203
204 template<typename T>
205 void getValue(const char* key, MetaDataType requestedType, const T*& value, int& count)
206 {
207 int index = -1;
208 MetaDataType type;
209 findKey(key, index, type);
210 getValue<T>(index, requestedType, value, count);
211 }
212
213 virtual void getValue(const char* key, const int8_t*& value, int& count)
214 {
215 getValue<int8_t>(key, mdt_int8, value, count);
216 }
217
218 virtual void getValue(int index, const int8_t*& value, int& count)
219 {
220 getValue<int8_t>(index, mdt_int8, value, count);
221 }
222
223 virtual void getValue(const char* key, const int16_t*& value, int& count)
224 {
225 getValue<int16_t>(key, mdt_int16, value, count);
226 }
227
228 virtual void getValue(int index, const int16_t*& value, int& count)
229 {
230 getValue<int16_t>(index, mdt_int16, value, count);
231 }
232
233 virtual void getValue(const char* key, const int32_t*& value, int& count)
234 {
235 getValue<int32_t>(key, mdt_int32, value, count);
236 }
237
238 virtual void getValue(int index, const int32_t*& value, int& count)
239 {
240 getValue<int32_t>(index, mdt_int32, value, count);
241 }
242
243 virtual void getValue(const char* key, const float*& value, int& count)
244 {
245 getValue<float>(key, mdt_float, value, count);
246 }
247
248 virtual void getValue(int index, const float*& value, int& count)
249 {
250 getValue<float>(index, mdt_float, value, count);
251 }
252
253 virtual void getValue(const char* key, const double*& value, int& count)
254 {
255 getValue<double>(key, mdt_double, value, count);
256 }
257
258 virtual void getValue(int index, const double*& value, int& count)
259 {
260 getValue<double>(index, mdt_double, value, count);
261 }
262
263 void addEntry(uint8_t keysize, const char* key, uint8_t datatype,
264 uint32_t datasize, const void* data, size_t& metaDataMemUsed)
265 {
266 Entry* e = newEntry(keysize, key, datatype, datasize, metaDataMemUsed);
267 e->data = new char[datasize];
268 memcpy(e->data, data, datasize);
269 metaDataMemUsed += datasize;
270 }
271
272 void addLmdEntry(uint8_t keysize, const char* key, uint8_t datatype,
273 uint32_t datasize, FilePos filepos, uint32_t zipsize,
274 size_t& metaDataMemUsed)
275 {
276 Entry* e = newEntry(keysize, key, datatype, datasize, metaDataMemUsed);
277 e->isLmd = true;
278 e->lmdData = 0;
279 e->lmdPos = filepos;
280 e->lmdZipSize = zipsize;
281 }
282
284 {
285 return sizeof(*this) + sizeof(Entry*) * _entries.capacity();
286 }
287
288 protected:
290 {
291 public:
293 : _data(new char [size]) {}
294 virtual ~LargeMetaData() { delete [] _data; }
295 void* data() { return _data; }
296 private:
298 char* _data;
299 };
300
301 struct Entry {
302 const char* key; // ptr to map key string
303 MetaDataType type; // meta data type
304 uint32_t datasize; // size of data in bytes
305 char* data; // if lmd, data only valid when lmd is loaded and ref'ed
306 bool isLmd; // true if data is a large meta data block
307 LargeMetaData* lmdData; // large meta data (lazy-loaded)
308 FilePos lmdPos; // large meta data file position
309 uint32_t lmdZipSize; // large meta data size on disk
310 uint32_t index; // index in vector
311
313 key(0), type(MetaDataType(0)), datasize(0), data(0),
314 isLmd(0), lmdData(0), lmdPos(0), lmdZipSize(0) {}
315 ~Entry() { clear(); }
316 void clear() {
317 if (isLmd) {
318 isLmd = 0;
319 if (lmdData) { delete lmdData; lmdData = 0; }
320 lmdPos = 0;
321 lmdZipSize = 0;
322 }
323 else {
324 if (data) { delete [] data; }
325 }
326 data = 0;
327 }
328 };
329
330
331 Entry* newEntry(uint8_t keysize, const char* key, uint8_t datatype, uint32_t datasize, size_t& metaDataMemUsed)
332 {
333 std::pair<MetaMap::iterator,bool> result =
334 _map.insert(std::make_pair(std::string(key, keysize), Entry()));
335 Entry* e = &result.first->second;
336 bool newentry = result.second;
337 uint32_t index = 0;
338 if (newentry) {
339 index = uint32_t(_entries.size());
340 _entries.push_back(e);
341 }
342 else {
343 index = e->index;
344 e->clear();
345 }
346 e->key = result.first->first.c_str();
348 e->datasize = datasize;
349 e->index = index;
350 metaDataMemUsed += sizeof(std::string) + keysize + 1 + sizeof(Entry);
351 return e;
352 }
353
354 PTEXAPI Entry* getEntry(int index);
355
357 typedef std::map<std::string, Entry> MetaMap;
359 std::vector<Entry*> _entries;
360 };
361
362
363 class ConstDataPtr : public PtexFaceData {
364 public:
365 ConstDataPtr(void* data, int pixelsize)
366 : _data(data), _pixelsize(pixelsize) {}
367 virtual void release() { delete this; }
368 virtual Ptex::Res res() { return 0; }
369 virtual bool isConstant() { return true; }
370 virtual void getPixel(int, int, void* result)
371 { memcpy(result, _data, _pixelsize); }
372 virtual void* getData() { return _data; }
373 virtual bool isTiled() { return false; }
374 virtual Ptex::Res tileRes() { return 0; }
375 virtual PtexFaceData* getTile(int) { return 0; }
376
377 protected:
378 void* _data;
380 };
381
382
383 class FaceData : public PtexFaceData {
384 public:
385 FaceData(Res resArg)
386 : _res(resArg) {}
387 virtual ~FaceData() {}
388 virtual void release() { }
389 virtual Ptex::Res res() { return _res; }
390 virtual FaceData* reduce(PtexReader*, Res newres, PtexUtils::ReduceFn, size_t& newMemUsed) = 0;
391 protected:
392 Res _res;
393 };
394
395 class PackedFace : public FaceData {
396 public:
397 PackedFace(Res resArg, int pixelsize, int size)
398 : FaceData(resArg),
399 _pixelsize(pixelsize), _data(new char [size]) {}
400 void* data() { return _data; }
401 virtual bool isConstant() { return false; }
402 virtual void getPixel(int u, int v, void* result)
403 {
404 memcpy(result, _data + (v*_res.u() + u) * _pixelsize, _pixelsize);
405 }
406 virtual void* getData() { return _data; }
407 virtual bool isTiled() { return false; }
408 virtual Ptex::Res tileRes() { return _res; }
409 virtual PtexFaceData* getTile(int) { return 0; }
410 virtual FaceData* reduce(PtexReader*, Res newres, PtexUtils::ReduceFn, size_t& newMemUsed);
411
412 protected:
413 virtual ~PackedFace() { delete [] _data; }
414
416 char* _data;
417 };
418
419 class ConstantFace : public PackedFace {
420 public:
423 virtual bool isConstant() { return true; }
424 virtual void getPixel(int, int, void* result) { memcpy(result, _data, _pixelsize); }
425 virtual FaceData* reduce(PtexReader*, Res newres, PtexUtils::ReduceFn, size_t& newMemUsed);
426 };
427
428 class ErrorFace : public ConstantFace {
430 public:
431 ErrorFace(void* errorPixel, int pixelsize, bool deleteOnRelease)
432 : ConstantFace(pixelsize), _deleteOnRelease(deleteOnRelease)
433 {
434 memcpy(_data, errorPixel, pixelsize);
435 }
436 virtual void release() { if (_deleteOnRelease) delete this; }
437 };
438
439 class TiledFaceBase : public FaceData {
440 public:
441 TiledFaceBase(PtexReader* reader, Res resArg, Res tileresArg)
442 : FaceData(resArg),
443 _reader(reader),
444 _tileres(tileresArg)
445 {
446 _dt = reader->datatype();
447 _nchan = reader->nchannels();
449 _ntilesu = _res.ntilesu(tileresArg);
450 _ntilesv = _res.ntilesv(tileresArg);
452 _tiles.resize(_ntiles);
453 }
454
455 virtual void release() { }
456 virtual bool isConstant() { return false; }
457 virtual void getPixel(int u, int v, void* result);
458 virtual void* getData() { return 0; }
459 virtual bool isTiled() { return true; }
460 virtual Ptex::Res tileRes() { return _tileres; }
461 virtual FaceData* reduce(PtexReader*, Res newres, PtexUtils::ReduceFn, size_t& newMemUsed);
462 Res tileres() const { return _tileres; }
463 int ntilesu() const { return _ntilesu; }
464 int ntilesv() const { return _ntilesv; }
465 int ntiles() const { return _ntiles; }
466
467 protected:
468 size_t baseExtraMemUsed() { return _tiles.size() * sizeof(_tiles[0]); }
469
470 virtual ~TiledFaceBase() {
471 for (std::vector<FaceData*>::iterator i = _tiles.begin(); i != _tiles.end(); ++i) {
472 if (*i) delete *i;
473 }
474 }
475
484 std::vector<FaceData*> _tiles;
485 };
486
487
488 class TiledFace : public TiledFaceBase {
489 public:
490 TiledFace(PtexReader* reader, Res resArg, Res tileresArg, int levelid)
491 : TiledFaceBase(reader, resArg, tileresArg),
492 _levelid(levelid)
493 {
494 _fdh.resize(_ntiles),
495 _offsets.resize(_ntiles);
496 }
497 virtual PtexFaceData* getTile(int tile)
498 {
499 FaceData*& f = _tiles[tile];
500 if (!f) readTile(tile, f);
501 return f;
502 }
503 void readTile(int tile, FaceData*& data);
504 size_t memUsed() {
505 return sizeof(*this) + baseExtraMemUsed() + _fdh.size() * (sizeof(_fdh[0]) + sizeof(_offsets[0]));
506 }
507
508 protected:
509 friend class PtexReader;
511 std::vector<FaceDataHeader> _fdh;
512 std::vector<FilePos> _offsets;
513 };
514
515
517 public:
518 TiledReducedFace(PtexReader* reader, Res resArg, Res tileresArg,
519 TiledFaceBase* parentface, PtexUtils::ReduceFn reducefn)
520 : TiledFaceBase(reader, resArg, tileresArg),
521 _parentface(parentface),
522 _reducefn(reducefn)
523 {
524 }
526 {
527 }
528 virtual PtexFaceData* getTile(int tile);
529
530 size_t memUsed() { return sizeof(*this) + baseExtraMemUsed(); }
531
532 protected:
535 };
536
537
538 class Level {
539 public:
540 std::vector<FaceDataHeader> fdh;
541 std::vector<FilePos> offsets;
542 std::vector<FaceData*> faces;
543
544 Level(int nfaces)
545 : fdh(nfaces),
546 offsets(nfaces),
547 faces(nfaces) {}
548
550 for (std::vector<FaceData*>::iterator i = faces.begin(); i != faces.end(); ++i) {
551 if (*i) delete *i;
552 }
553 }
554
555 size_t memUsed() {
556 return sizeof(*this) + fdh.size() * (sizeof(fdh[0]) +
557 sizeof(offsets[0]) +
558 sizeof(faces[0]));
559 }
560 };
561
562
563protected:
564 void setError(const char* error)
565 {
566 std::string msg = error;
567 msg += " PtexFile: ";
568 msg += _path;
569 msg += "\n";
570 if (_err) _err->reportError(msg.c_str());
571 else std::cerr << msg;
572 _ok = 0;
573 }
574
575 FilePos tell() { return _pos; }
576 void seek(FilePos pos)
577 {
578 if (!_fp && !reopenFP()) return;
579 logBlockRead();
580 if (pos != _pos) {
581 _io->seek(_fp, pos);
582 _pos = pos;
583 }
584 }
585
586 void closeFP();
587 bool reopenFP();
588 bool readBlock(void* data, int size, bool reportError=true);
589 bool readZipBlock(void* data, int zipsize, int unzipsize);
590 Level* getLevel(int levelid)
591 {
592 Level*& level = _levels[levelid];
593 if (!level) readLevel(levelid, level);
594 return level;
595 }
596
597 uint8_t* getConstData() { return _constdata; }
598 FaceData* getFace(int levelid, Level* level, int faceid, Res res)
599 {
600 FaceData*& face = level->faces[faceid];
601 if (!face) readFace(levelid, level, faceid, res);
602 return face;
603 }
604
605 void readFaceInfo();
606 void readLevelInfo();
607 void readConstData();
608 void readLevel(int levelid, Level*& level);
609 void readFace(int levelid, Level* level, int faceid, Res res);
610 void readFaceData(FilePos pos, FaceDataHeader fdh, Res res, int levelid, FaceData*& face);
611 void readMetaData();
612 void readMetaDataBlock(MetaData* metadata, FilePos pos, int zipsize, int memsize, size_t& metaDataMemUsed);
613 void readLargeMetaDataHeaders(MetaData* metadata, FilePos pos, int zipsize, int memsize, size_t& metaDataMemUsed);
614 void readEditData();
615 void readEditFaceData();
616 void readEditMetaData();
617
618 FaceData* errorData(bool deleteOnRelease=false)
619 {
620 return new ErrorFace(&_errorPixel[0], _pixelsize, deleteOnRelease);
621 }
622
623 void computeOffsets(FilePos pos, int noffsets, const FaceDataHeader* fdh, FilePos* offsets)
624 {
625 FilePos* end = offsets + noffsets;
626 while (offsets != end) { *offsets++ = pos; pos += fdh->blocksize(); fdh++; }
627 }
628
630 {
631 char* buffer;
632 public:
634 virtual Handle open(const char* path) {
635 FILE* fp = fopen(path, "rb");
636 if (fp) {
637 buffer = new char [IBuffSize];
638 setvbuf(fp, buffer, _IOFBF, IBuffSize);
639 }
640 else buffer = 0;
641 return (Handle) fp;
642 }
643 virtual void seek(Handle handle, int64_t pos) { fseeko((FILE*)handle, pos, SEEK_SET); }
644 virtual size_t read(void* bufferArg, size_t size, Handle handle) {
645 return fread(bufferArg, size, 1, (FILE*)handle) == 1 ? size : 0;
646 }
647 virtual bool close(Handle handle) {
648 bool ok = handle && (fclose((FILE*)handle) == 0);
649 if (buffer) { delete [] buffer; buffer = 0; }
650 return ok;
651 }
652 virtual const char* lastError() { return strerror(errno); }
653 };
654
656 DefaultInputHandler _defaultIo; // Default IO handler
657 PtexInputHandler* _io; // IO handler
658 PtexErrorHandler* _err; // Error handler
659 bool _premultiply; // true if reader should premultiply the alpha chan
660 bool _ok; // flag set to false if open or read error occurred
661 bool _needToOpen; // true if file needs to be opened (or reopened after a purge)
662 bool _pendingPurge; // true if a purge attempt was made but file was busy
664 FilePos _pos; // current seek position
665 std::string _path; // current file path
666 Header _header; // the header
667 ExtHeader _extheader; // extended header
668 FilePos _faceinfopos; // file positions of data sections
676 int _pixelsize; // size of a pixel in bytes
677 uint8_t* _constdata; // constant pixel value per face
678 MetaData* _metadata; // meta data (read on demand)
679 bool _hasEdits; // has edit blocks
680
681 std::vector<FaceInfo> _faceinfo; // per-face header info
682 std::vector<uint32_t> _rfaceids; // faceids sorted in reduction order
683 std::vector<LevelInfo> _levelinfo; // per-level header info
684 std::vector<FilePos> _levelpos; // file position of each level's data
685 std::vector<Level*> _levels; // level data (read on demand)
686
687 struct MetaEdit
688 {
692 };
693 std::vector<MetaEdit> _metaedits;
694
695 struct FaceEdit
696 {
700 };
701 std::vector<FaceEdit> _faceedits;
702
704 int64_t _val;
705 public:
707 ReductionKey(uint32_t faceid, Res res)
708 : _val( int64_t(faceid)<<32 | uint32_t(16777619*((res.val()<<16) ^ faceid)) ) {}
709
710 void copy(volatile ReductionKey& key) volatile
711 {
712 _val = key._val;
713 }
714
715 void move(volatile ReductionKey& key) volatile
716 {
717 _val = key._val;
718 }
719
720 bool matches(const ReductionKey& key) volatile
721 {
722 return _val == key._val;
723 }
724 bool isEmpty() volatile { return _val==-1; }
725 uint32_t hash() volatile
726 {
727 return uint32_t(_val);
728 }
729 };
732 std::vector<char> _errorPixel; // referenced by errorData()
733
734 z_stream_s _zstream;
736 volatile size_t _memUsed;
737 volatile size_t _opens;
738 volatile size_t _blockReads;
739};
740
742
743#endif
Contains PtexHashMap, a lightweight multi-threaded hash table.
const int IBuffSize
Definition: PtexIO.h:113
off_t FilePos
Definition: PtexPlatform.h:99
PTEX_INLINE T AtomicAdd(volatile T *target, T value)
Definition: PtexPlatform.h:209
PTEX_INLINE T AtomicIncrement(volatile T *target)
Definition: PtexPlatform.h:225
#define PTEXAPI
Definition: PtexReader.h:51
#define PTEX_NAMESPACE_END
Definition: PtexVersion.h:62
Public API classes for reading, writing, caching, and filtering Ptex files.
Custom handler interface redirecting Ptex error messages.
Definition: Ptexture.h:658
virtual void reportError(const char *error)=0
Per-face texture data accessor.
Definition: Ptexture.h:406
Custom handler interface for intercepting and redirecting Ptex input stream calls.
Definition: Ptexture.h:619
virtual void seek(Handle handle, int64_t pos)=0
Seek to an absolute byte position in the input stream.
Meta data accessor.
Definition: Ptexture.h:328
virtual bool isConstant()
True if this data block is constant.
Definition: PtexReader.h:369
virtual Ptex::Res res()
Resolution of the texture held by this data block.
Definition: PtexReader.h:368
virtual void release()
Release resources held by this pointer (pointer becomes invalid).
Definition: PtexReader.h:367
virtual bool isTiled()
True if this data block is tiled.
Definition: PtexReader.h:373
virtual void * getData()
Access the data from this data block.
Definition: PtexReader.h:372
virtual void getPixel(int, int, void *result)
Read a single texel from the data block.
Definition: PtexReader.h:370
virtual Ptex::Res tileRes()
Resolution of each tile in this data block.
Definition: PtexReader.h:374
virtual PtexFaceData * getTile(int)
Access a tile from the data block.
Definition: PtexReader.h:375
ConstDataPtr(void *data, int pixelsize)
Definition: PtexReader.h:365
virtual void getPixel(int, int, void *result)
Read a single texel from the data block.
Definition: PtexReader.h:424
ConstantFace(int pixelsize)
Definition: PtexReader.h:421
virtual bool isConstant()
True if this data block is constant.
Definition: PtexReader.h:423
virtual FaceData * reduce(PtexReader *, Res newres, PtexUtils::ReduceFn, size_t &newMemUsed)
Definition: PtexReader.cpp:966
virtual void seek(Handle handle, int64_t pos)
Seek to an absolute byte position in the input stream.
Definition: PtexReader.h:643
virtual bool close(Handle handle)
Close a file.
Definition: PtexReader.h:647
virtual size_t read(void *bufferArg, size_t size, Handle handle)
Read a number of bytes from the file.
Definition: PtexReader.h:644
virtual Handle open(const char *path)
Open a file in read mode.
Definition: PtexReader.h:634
virtual const char * lastError()
Return the last error message encountered.
Definition: PtexReader.h:652
virtual void release()
Release resources held by this pointer (pointer becomes invalid).
Definition: PtexReader.h:436
ErrorFace(void *errorPixel, int pixelsize, bool deleteOnRelease)
Definition: PtexReader.h:431
virtual Ptex::Res res()
Resolution of the texture held by this data block.
Definition: PtexReader.h:389
virtual FaceData * reduce(PtexReader *, Res newres, PtexUtils::ReduceFn, size_t &newMemUsed)=0
virtual void release()
Release resources held by this pointer (pointer becomes invalid).
Definition: PtexReader.h:388
FaceData(Res resArg)
Definition: PtexReader.h:385
Level(int nfaces)
Definition: PtexReader.h:544
std::vector< FilePos > offsets
Definition: PtexReader.h:541
std::vector< FaceDataHeader > fdh
Definition: PtexReader.h:540
std::vector< FaceData * > faces
Definition: PtexReader.h:542
size_t memUsed()
Definition: PtexReader.h:555
LargeMetaData(const LargeMetaData &)
virtual void getValue(int index, const int8_t *&value, int &count)
Query the value of a given meta data entry by index.
Definition: PtexReader.h:218
virtual void release()
Release resources held by this pointer (pointer becomes invalid).
Definition: PtexReader.h:142
Entry * newEntry(uint8_t keysize, const char *key, uint8_t datatype, uint32_t datasize, size_t &metaDataMemUsed)
Definition: PtexReader.h:331
virtual void getKey(int index, const char *&key, MetaDataType &type)
Definition: PtexReader.h:145
virtual void getValue(int index, const double *&value, int &count)
Query the value of a given meta data entry by index.
Definition: PtexReader.h:258
virtual void getValue(const char *key, const int8_t *&value, int &count)
Query the value of a given meta data entry.
Definition: PtexReader.h:213
virtual void getValue(int index, const char *&value)
Query the value of a given meta data entry by index.
Definition: PtexReader.h:180
void addEntry(uint8_t keysize, const char *key, uint8_t datatype, uint32_t datasize, const void *data, size_t &metaDataMemUsed)
Definition: PtexReader.h:263
virtual void getValue(int index, const float *&value, int &count)
Query the value of a given meta data entry by index.
Definition: PtexReader.h:248
void getValue(const char *key, MetaDataType requestedType, const T *&value, int &count)
Definition: PtexReader.h:205
virtual bool findKey(const char *key, int &index, MetaDataType &type)
Definition: PtexReader.h:155
virtual void getValue(int index, const int16_t *&value, int &count)
Query the value of a given meta data entry by index.
Definition: PtexReader.h:228
MetaData(PtexReader *reader)
Definition: PtexReader.h:139
virtual void getValue(const char *key, const int32_t *&value, int &count)
Query the value of a given meta data entry.
Definition: PtexReader.h:233
virtual int numKeys()
Query number of meta data entries stored in file.
Definition: PtexReader.h:144
virtual void getValue(int index, const int32_t *&value, int &count)
Query the value of a given meta data entry by index.
Definition: PtexReader.h:238
virtual void getValue(const char *key, const double *&value, int &count)
Query the value of a given meta data entry.
Definition: PtexReader.h:253
PtexReader * _reader
Definition: PtexReader.h:356
virtual void getValue(const char *key, const char *&value)
Query the value of a given meta data entry.
Definition: PtexReader.h:167
std::map< std::string, Entry > MetaMap
Definition: PtexReader.h:357
virtual void getValue(const char *key, const float *&value, int &count)
Query the value of a given meta data entry.
Definition: PtexReader.h:243
void addLmdEntry(uint8_t keysize, const char *key, uint8_t datatype, uint32_t datasize, FilePos filepos, uint32_t zipsize, size_t &metaDataMemUsed)
Definition: PtexReader.h:272
void getValue(int index, MetaDataType requestedType, const T *&value, int &count)
Definition: PtexReader.h:189
Entry * getEntry(int index)
Definition: PtexReader.cpp:343
std::vector< Entry * > _entries
Definition: PtexReader.h:359
virtual void getValue(const char *key, const int16_t *&value, int &count)
Query the value of a given meta data entry.
Definition: PtexReader.h:223
virtual PtexFaceData * getTile(int)
Access a tile from the data block.
Definition: PtexReader.h:409
PackedFace(Res resArg, int pixelsize, int size)
Definition: PtexReader.h:397
virtual bool isTiled()
True if this data block is tiled.
Definition: PtexReader.h:407
virtual Ptex::Res tileRes()
Resolution of each tile in this data block.
Definition: PtexReader.h:408
virtual FaceData * reduce(PtexReader *, Res newres, PtexUtils::ReduceFn, size_t &newMemUsed)
Definition: PtexReader.cpp:949
virtual bool isConstant()
True if this data block is constant.
Definition: PtexReader.h:401
virtual void getPixel(int u, int v, void *result)
Read a single texel from the data block.
Definition: PtexReader.h:402
virtual void * getData()
Access the data from this data block.
Definition: PtexReader.h:406
bool isEmpty() volatile
Definition: PtexReader.h:724
ReductionKey(uint32_t faceid, Res res)
Definition: PtexReader.h:707
void move(volatile ReductionKey &key) volatile
Definition: PtexReader.h:715
uint32_t hash() volatile
Definition: PtexReader.h:725
bool matches(const ReductionKey &key) volatile
Definition: PtexReader.h:720
void copy(volatile ReductionKey &key) volatile
Definition: PtexReader.h:710
TiledFaceBase(PtexReader *reader, Res resArg, Res tileresArg)
Definition: PtexReader.h:441
std::vector< FaceData * > _tiles
Definition: PtexReader.h:484
virtual bool isTiled()
True if this data block is tiled.
Definition: PtexReader.h:459
virtual FaceData * reduce(PtexReader *, Res newres, PtexUtils::ReduceFn, size_t &newMemUsed)
Definition: PtexReader.cpp:979
virtual void * getData()
Access the data from this data block.
Definition: PtexReader.h:458
virtual void release()
Release resources held by this pointer (pointer becomes invalid).
Definition: PtexReader.h:455
virtual Ptex::Res tileRes()
Resolution of each tile in this data block.
Definition: PtexReader.h:460
virtual bool isConstant()
True if this data block is constant.
Definition: PtexReader.h:456
virtual void getPixel(int u, int v, void *result)
Read a single texel from the data block.
std::vector< FaceDataHeader > _fdh
Definition: PtexReader.h:511
TiledFace(PtexReader *reader, Res resArg, Res tileresArg, int levelid)
Definition: PtexReader.h:490
virtual PtexFaceData * getTile(int tile)
Access a tile from the data block.
Definition: PtexReader.h:497
void readTile(int tile, FaceData *&data)
Definition: PtexReader.cpp:635
std::vector< FilePos > _offsets
Definition: PtexReader.h:512
TiledFaceBase * _parentface
Definition: PtexReader.h:533
virtual PtexFaceData * getTile(int tile)
Access a tile from the data block.
PtexUtils::ReduceFn * _reducefn
Definition: PtexReader.h:534
TiledReducedFace(PtexReader *reader, Res resArg, Res tileresArg, TiledFaceBase *parentface, PtexUtils::ReduceFn reducefn)
Definition: PtexReader.h:518
void readLevelInfo()
Definition: PtexReader.cpp:298
ReductionMap _reductions
Definition: PtexReader.h:731
bool reopenFP()
Definition: PtexReader.cpp:240
bool ok() const
Definition: PtexReader.h:81
DataType datatype() const
Definition: PtexReader.h:130
void readEditFaceData()
Definition: PtexReader.cpp:502
bool _premultiply
Definition: PtexReader.h:659
FilePos _constdatapos
Definition: PtexReader.h:669
void readMetaDataBlock(MetaData *metadata, FilePos pos, int zipsize, int memsize, size_t &metaDataMemUsed)
Definition: PtexReader.cpp:414
const ExtHeader & extheader() const
Definition: PtexReader.h:134
virtual int numFaces()
Number of faces stored in file.
Definition: PtexReader.h:114
void setPendingPurge()
Definition: PtexReader.h:78
void readFaceInfo()
Definition: PtexReader.cpp:277
virtual Ptex::BorderMode vBorderMode()
Mode for filtering texture access beyond mesh border.
Definition: PtexReader.h:110
std::string _path
Definition: PtexReader.h:665
uint8_t * _constdata
Definition: PtexReader.h:677
std::vector< FilePos > _levelpos
Definition: PtexReader.h:684
void readEditData()
Definition: PtexReader.cpp:468
virtual void getPixel(int faceid, int u, int v, float *result, int firstchan, int nchannels)
Access a single texel from the highest resolution texture .
Definition: PtexReader.cpp:893
virtual Info getInfo()
Definition: PtexReader.h:94
std::vector< FaceEdit > _faceedits
Definition: PtexReader.h:701
volatile size_t _opens
Definition: PtexReader.h:737
bool isOpen()
Definition: PtexReader.h:82
virtual void release()
Release resources held by this pointer (pointer becomes invalid).
Definition: PtexReader.h:73
void increaseMemUsed(size_t amount)
Definition: PtexReader.h:88
virtual const char * path()
Path that file was opened with.
Definition: PtexReader.h:92
FaceData * getFace(int levelid, Level *level, int faceid, Res res)
Definition: PtexReader.h:598
void purge()
Definition: PtexReader.cpp:115
FilePos _editdatapos
Definition: PtexReader.h:675
FilePos tell()
Definition: PtexReader.h:575
Level * getLevel(int levelid)
Definition: PtexReader.h:590
FaceData * errorData(bool deleteOnRelease=false)
Definition: PtexReader.h:618
virtual ~PtexReader()
Definition: PtexReader.cpp:93
bool _hasEdits
Definition: PtexReader.h:679
bool _needToOpen
Definition: PtexReader.h:661
virtual Ptex::BorderMode uBorderMode()
Mode for filtering texture access beyond mesh border.
Definition: PtexReader.h:109
void computeOffsets(FilePos pos, int noffsets, const FaceDataHeader *fdh, FilePos *offsets)
Definition: PtexReader.h:623
void readConstData()
Definition: PtexReader.cpp:319
virtual PtexMetaData * getMetaData()
Access meta data.
Definition: PtexReader.cpp:335
bool needToOpen() const
Definition: PtexReader.h:74
virtual int alphaChannel()
Index of alpha channel (if any).
Definition: PtexReader.h:112
ExtHeader _extheader
Definition: PtexReader.h:667
FilePos _leveldatapos
Definition: PtexReader.h:671
virtual void getData(int faceid, void *buffer, int stride)
Access texture data for a face at highest-resolution.
Definition: PtexReader.cpp:711
PtexErrorHandler * _err
Definition: PtexReader.h:658
const Header & header() const
Definition: PtexReader.h:133
void readEditMetaData()
Definition: PtexReader.cpp:533
FilePos _faceinfopos
Definition: PtexReader.h:668
std::vector< LevelInfo > _levelinfo
Definition: PtexReader.h:683
PtexHashMap< ReductionKey, FaceData * > ReductionMap
Definition: PtexReader.h:730
PtexReader(bool premultiply, PtexInputHandler *inputHandler, PtexErrorHandler *errorHandler)
Definition: PtexReader.cpp:71
virtual bool hasMipMaps()
True if the file has mipmaps.
Definition: PtexReader.h:116
z_stream_s _zstream
Definition: PtexReader.h:734
PtexInputHandler * _io
Definition: PtexReader.h:657
virtual const Ptex::FaceInfo & getFaceInfo(int faceid)
Access resolution and adjacency information about a face.
Definition: PtexReader.cpp:267
FilePos _metadatapos
Definition: PtexReader.h:672
void readLargeMetaDataHeaders(MetaData *metadata, FilePos pos, int zipsize, int memsize, size_t &metaDataMemUsed)
Definition: PtexReader.cpp:440
void closeFP()
Definition: PtexReader.cpp:230
int _pixelsize
Definition: PtexReader.h:676
bool _pendingPurge
Definition: PtexReader.h:662
bool pendingPurge() const
Definition: PtexReader.h:79
Mutex readlock
Definition: PtexReader.h:655
void readFace(int levelid, Level *level, int faceid, Res res)
Definition: PtexReader.cpp:627
FilePos _levelinfopos
Definition: PtexReader.h:670
FilePos _lmdheaderpos
Definition: PtexReader.h:673
virtual bool hasEdits()
True if the file has edit blocks.
Definition: PtexReader.h:115
int nchannels() const
Definition: PtexReader.h:131
FilePos _lmddatapos
Definition: PtexReader.h:674
void prune()
Definition: PtexReader.cpp:104
std::vector< uint32_t > _rfaceids
Definition: PtexReader.h:682
std::vector< MetaEdit > _metaedits
Definition: PtexReader.h:693
volatile size_t _memUsed
Definition: PtexReader.h:736
DefaultInputHandler _defaultIo
Definition: PtexReader.h:656
volatile size_t _blockReads
Definition: PtexReader.h:738
Header _header
Definition: PtexReader.h:666
void readFaceData(FilePos pos, FaceDataHeader fdh, Res res, int levelid, FaceData *&face)
Definition: PtexReader.cpp:641
void seek(FilePos pos)
Definition: PtexReader.h:576
bool readBlock(void *data, int size, bool reportError=true)
Definition: PtexReader.cpp:548
MetaData * _metadata
Definition: PtexReader.h:678
std::vector< Level * > _levels
Definition: PtexReader.h:685
size_t _baseMemUsed
Definition: PtexReader.h:735
std::vector< FaceInfo > _faceinfo
Definition: PtexReader.h:681
void invalidate()
Definition: PtexReader.h:83
virtual Ptex::MeshType meshType()
Type of mesh for which texture data is defined.
Definition: PtexReader.h:107
virtual Ptex::EdgeFilterMode edgeFilterMode()
Mode for filtering textures across edges.
Definition: PtexReader.h:111
int pixelsize() const
Definition: PtexReader.h:132
PtexInputHandler::Handle _fp
Definition: PtexReader.h:663
bool readZipBlock(void *data, int zipsize, int unzipsize)
Definition: PtexReader.cpp:563
void readMetaData()
Definition: PtexReader.cpp:381
void logBlockRead()
Definition: PtexReader.h:90
void logOpen()
Definition: PtexReader.h:89
void readLevel(int levelid, Level *&level)
Definition: PtexReader.cpp:595
virtual Ptex::DataType dataType()
Type of data stored in file.
Definition: PtexReader.h:108
std::vector< char > _errorPixel
Definition: PtexReader.h:732
uint8_t * getConstData()
Definition: PtexReader.h:597
virtual int numChannels()
Number of channels stored in file.
Definition: PtexReader.h:113
FilePos _pos
Definition: PtexReader.h:664
bool open(const char *path, Ptex::String &error)
Definition: PtexReader.cpp:137
const LevelInfo & levelinfo(int level) const
Definition: PtexReader.h:135
bool tryClose()
Definition: PtexReader.cpp:219
void setError(const char *error)
Definition: PtexReader.h:564
Interface for reading data from a ptex file.
Definition: Ptexture.h:457
Memory-managed string.
Definition: Ptexture.h:296
void ReduceFn(const void *src, int sstride, int ures, int vres, void *dst, int dstride, DataType dt, int nchannels)
Definition: PtexUtils.h:185
int DataSize(DataType dt)
Look up size of given data type (in bytes).
Definition: Ptexture.h:130
DataType
Type of data stored in texture file.
Definition: Ptexture.h:72
MeshType
Type of base mesh for which the textures are defined.
Definition: Ptexture.h:66
BorderMode
How to handle mesh border when filtering.
Definition: Ptexture.h:86
MetaDataType
Type of meta data entry.
Definition: Ptexture.h:102
@ mdt_string
Null-terminated string.
Definition: Ptexture.h:103
@ mdt_float
Single-precision (32-bit) floating point.
Definition: Ptexture.h:107
@ mdt_int32
Signed 32-bit integer.
Definition: Ptexture.h:106
@ mdt_int8
Signed 8-bit integer.
Definition: Ptexture.h:104
@ mdt_double
Double-precision (32-bit) floating point.
Definition: Ptexture.h:108
@ mdt_int16
Signed 16-bit integer.
Definition: Ptexture.h:105
EdgeFilterMode
How to handle transformation across edges when filtering.
Definition: Ptexture.h:80
uint16_t edgefiltermode
Definition: PtexIO.h:68
uint16_t vbordermode
Definition: PtexIO.h:67
uint16_t ubordermode
Definition: PtexIO.h:65
uint32_t blocksize() const
Definition: PtexIO.h:84
Definition: PtexIO.h:44
uint16_t nlevels
Definition: PtexIO.h:51
uint16_t nchannels
Definition: PtexIO.h:50
uint32_t meshtype
Definition: PtexIO.h:47
uint32_t datatype
Definition: PtexIO.h:48
int32_t alphachan
Definition: PtexIO.h:49
uint32_t nfaces
Definition: PtexIO.h:52
FaceDataHeader fdh
Definition: PtexReader.h:699
LargeMetaData * lmdData
Definition: PtexReader.h:307
Get most commonly used info in a single call for convenience / efficiency.
Definition: Ptexture.h:486
BorderMode uBorderMode
Definition: Ptexture.h:489
BorderMode vBorderMode
Definition: Ptexture.h:490
EdgeFilterMode edgeFilterMode
Definition: Ptexture.h:491
DataType dataType
Definition: Ptexture.h:488
MeshType meshType
Definition: Ptexture.h:487
Information about a face, as stored in the Ptex file header.
Definition: Ptexture.h:229
Pixel resolution of a given texture.
Definition: Ptexture.h:159