31 #ifndef OPENVDB_IO_COMPRESSION_HAS_BEEN_INCLUDED 32 #define OPENVDB_IO_COMPRESSION_HAS_BEEN_INCLUDED 111 enum { isReal =
false };
116 enum { isReal =
true };
121 enum { isReal =
true };
127 enum { isReal =
true };
132 enum { isReal =
true };
138 enum { isReal =
true };
143 enum { isReal =
true };
186 if (data ==
nullptr) {
188 is.seekg(
sizeof(T) * count, std::ios_base::cur);
190 is.read(reinterpret_cast<char*>(data),
sizeof(T) * count);
198 readData<std::string>(std::istream& is, std::string* data,
Index count, uint32_t )
200 for (
Index i = 0; i < count; ++i) {
206 std::string buffer(len+1,
' ');
207 is.read(&buffer[0], len+1);
208 if (data !=
nullptr) data[i].assign(buffer, 0, len);
220 static inline void read(std::istream& is, T* data,
Index count, uint32_t compression) {
221 readData(is, data, count, compression);
228 static inline void read(std::istream& is, T* data,
Index count, uint32_t compression) {
229 if (count < 1)
return;
230 if (data ==
nullptr) {
232 readData<HalfT>(is,
nullptr, count, compression);
234 std::vector<HalfT> halfData(count);
235 readData<HalfT>(is, reinterpret_cast<HalfT*>(&halfData[0]), count, compression);
237 std::copy(halfData.begin(), halfData.end(), data);
258 bloscToStream(os, reinterpret_cast<const char*>(data),
sizeof(T), count);
260 zipToStream(os, reinterpret_cast<const char*>(data),
sizeof(T) * count);
262 os.write(reinterpret_cast<const char*>(data),
sizeof(T) * count);
269 writeData<std::string>(std::ostream& os,
const std::string* data,
Index count,
272 for (
Index i = 0; i < count; ++i) {
273 const size_t len = data[i].size();
275 os.write(data[i].c_str(), len+1);
288 static inline void write(std::ostream& os,
const T* data,
Index count, uint32_t compression) {
296 static inline void write(std::ostream& os,
const T* data,
Index count, uint32_t compression) {
297 if (count < 1)
return;
299 std::vector<HalfT> halfData(count);
300 for (
Index i = 0; i < count; ++i) halfData[i] = RealToHalf<T>::convert(data[i]);
301 writeData<HalfT>(os, reinterpret_cast<const HalfT*>(&halfData[0]), count, compression);
307 struct HalfWriter<true, double> {
308 using HalfT = RealToHalf<double>::HalfT;
309 static inline void write(std::ostream& os,
const double* data,
Index count,
310 uint32_t compression)
312 if (count < 1)
return;
314 std::vector<HalfT> halfData(count);
315 for (
Index i = 0; i < count; ++i) halfData[i] = RealToHalf<double>::convert(data[i]);
316 writeData<HalfT>(os, reinterpret_cast<const HalfT*>(&halfData[0]), count, compression);
337 template<
typename ValueT,
typename MaskT>
340 const MaskT& valueMask,
bool fromHalf)
346 const bool seek = (destBuf ==
nullptr);
353 if (seek && !maskCompressed) {
354 is.seekg(1, std::ios_base::cur);
356 is.read(reinterpret_cast<char*>(&metadata), 1);
360 ValueT background = zeroVal<ValueT>();
362 background = *static_cast<const ValueT*>(bgPtr);
364 ValueT inactiveVal1 = background;
365 ValueT inactiveVal0 =
374 is.seekg(
sizeof(ValueT), std::ios_base::cur);
376 is.read(reinterpret_cast<char*>(&inactiveVal0),
sizeof(ValueT));
381 is.seekg(
sizeof(ValueT), std::ios_base::cur);
383 is.read(reinterpret_cast<char*>(&inactiveVal1),
sizeof(ValueT));
396 is.seekg(selectionMask.memUsage(), std::ios_base::cur);
398 selectionMask.load(is);
402 ValueT* tempBuf = destBuf;
403 std::unique_ptr<ValueT[]> scopedTempBuf;
405 Index tempCount = destCount;
410 tempCount = valueMask.countOn();
411 if (!seek && tempCount != destCount) {
414 scopedTempBuf.reset(
new ValueT[tempCount]);
415 tempBuf = scopedTempBuf.get();
422 is, (seek ?
nullptr : tempBuf), tempCount, compression);
424 readData<ValueT>(is, (seek ?
nullptr : tempBuf), tempCount, compression);
430 if (!seek && maskCompressed && tempCount != destCount) {
434 for (
Index destIdx = 0, tempIdx = 0; destIdx < MaskT::SIZE; ++destIdx) {
435 if (valueMask.isOn(destIdx)) {
437 destBuf[destIdx] = tempBuf[tempIdx];
441 destBuf[destIdx] = (selectionMask.isOn(destIdx) ? inactiveVal1 : inactiveVal0);
460 template<
typename ValueT,
typename MaskT>
463 const MaskT& valueMask,
const MaskT& childMask,
bool toHalf)
467 static inline bool eq(
const ValueT& a,
const ValueT& b) {
476 Index tempCount = srcCount;
477 ValueT* tempBuf = srcBuf;
478 std::unique_ptr<ValueT[]> scopedTempBuf;
483 os.write(reinterpret_cast<const char*>(&metadata), 1);
491 const ValueT zero = zeroVal<ValueT>();
492 ValueT background = zero;
494 background = *static_cast<const ValueT*>(bgPtr);
498 ValueT inactiveVal[2] = { background, background };
499 int numUniqueInactiveVals = 0;
500 for (
typename MaskT::OffIterator it = valueMask.beginOff();
501 numUniqueInactiveVals < 3 && it; ++it)
506 if (childMask.isOn(idx))
continue;
508 const ValueT& val = srcBuf[idx];
509 const bool unique = !(
510 (numUniqueInactiveVals > 0 && Local::eq(val, inactiveVal[0])) ||
511 (numUniqueInactiveVals > 1 && Local::eq(val, inactiveVal[1]))
514 if (numUniqueInactiveVals < 2) inactiveVal[numUniqueInactiveVals] = val;
515 ++numUniqueInactiveVals;
521 if (numUniqueInactiveVals == 1) {
522 if (!Local::eq(inactiveVal[0], background)) {
529 }
else if (numUniqueInactiveVals == 2) {
531 if (!Local::eq(inactiveVal[0], background) && !Local::eq(inactiveVal[1], background)) {
536 }
else if (Local::eq(inactiveVal[1], background)) {
548 }
else if (Local::eq(inactiveVal[0], background)) {
554 std::swap(inactiveVal[0], inactiveVal[1]);
559 std::swap(inactiveVal[0], inactiveVal[1]);
563 }
else if (numUniqueInactiveVals > 2) {
567 os.write(reinterpret_cast<const char*>(&metadata), 1);
575 os.write(reinterpret_cast<const char*>(&inactiveVal[0]),
sizeof(ValueT));
578 os.write(reinterpret_cast<const char*>(&inactiveVal[1]),
sizeof(ValueT));
583 os.write(reinterpret_cast<const char*>(&truncatedVal),
sizeof(ValueT));
587 os.write(reinterpret_cast<const char*>(&truncatedVal),
sizeof(ValueT));
599 scopedTempBuf.reset(
new ValueT[srcCount]);
600 tempBuf = scopedTempBuf.get();
608 for (
typename MaskT::OnIterator it = valueMask.beginOn(); it; ++it, ++tempCount) {
609 tempBuf[tempCount] = srcBuf[it.pos()];
616 for (
Index srcIdx = 0; srcIdx < srcCount; ++srcIdx) {
617 if (valueMask.isOn(srcIdx)) {
618 tempBuf[tempCount] = srcBuf[srcIdx];
621 if (Local::eq(srcBuf[srcIdx], inactiveVal[1])) {
622 selectionMask.setOn(srcIdx);
626 assert(tempCount == valueMask.countOn());
629 selectionMask.save(os);
638 writeData(os, tempBuf, tempCount, compress);
646 #endif // OPENVDB_IO_COMPRESSION_HAS_BEEN_INCLUDED Definition: Compression.h:96
Vec2< float > Vec2s
Definition: Vec2.h:558
Index32 Index
Definition: Types.h:61
General-purpose arithmetic and comparison routines, most of which accept arbitrary value types (or at...
T truncateRealToHalf(const T &val)
Return the given value truncated to 16-bit float precision.
Definition: Compression.h:153
static HalfT convert(const Vec3s &val)
Definition: Compression.h:140
OPENVDB_API void unzipFromStream(std::istream &, char *data, size_t numBytes)
bool isExactlyEqual(const T0 &a, const T1 &b)
Return true if a is exactly equal to b.
Definition: Math.h:395
Vec3< double > Vec3d
Definition: Vec3.h:679
typename RealToHalf< T >::HalfT HalfT
Definition: Compression.h:227
OPENVDB_API SharedPtr< StreamMetadata > getStreamMetadataPtr(std::ios_base &)
Return a shared pointer to an object that stores metadata (file format, compression scheme,...
OPENVDB_API std::string compressionToString(uint32_t flags)
Return a string describing the given compression flags.
Definition: Compression.h:78
T HalfT
Definition: Compression.h:112
static HalfT convert(double val)
Definition: Compression.h:124
math::Vec3< half > Vec3H
Definition: Types.h:82
static HalfT convert(const T &val)
Definition: Compression.h:113
uint32_t Index32
Definition: Types.h:59
half HalfT
Definition: Compression.h:122
Definition: Compression.h:95
Definition: Compression.h:284
static void read(std::istream &is, T *data, Index count, uint32_t compression)
Definition: Compression.h:220
OPENVDB_API uint32_t getFormatVersion(std::ios_base &)
Return the file format version number associated with the given input stream.
#define OPENVDB_VERSION_NAME
The version namespace name for this library version.
Definition: version.h:136
half HalfT
Definition: Compression.h:117
static HalfT convert(const Vec2s &val)
Definition: Compression.h:129
typename RealToHalf< T >::HalfT HalfT
Definition: Compression.h:295
OPENVDB_API void bloscToStream(std::ostream &, const char *data, size_t valSize, size_t numVals)
OPENVDB_API void zipToStream(std::ostream &, const char *data, size_t numBytes)
Definition: Compression.h:99
T negative(const T &val)
Return the unary negation of the given value.
Definition: Math.h:108
Definition: Compression.h:216
Definition: Compression.h:81
math::Vec2< half > Vec2H
Definition: Types.h:73
Definition: Exceptions.h:40
void writeData(std::ostream &os, const T *data, Index count, uint32_t compression)
Definition: Compression.h:255
Definition: Compression.h:100
Vec2< double > Vec2d
Definition: Vec2.h:559
static void write(std::ostream &os, const T *data, Index count, uint32_t compression)
Definition: Compression.h:296
OPENVDB_API void bloscFromStream(std::istream &, char *data, size_t numBytes)
Definition: Compression.h:79
static void read(std::istream &is, T *data, Index count, uint32_t compression)
Definition: Compression.h:228
Definition: Compression.h:98
RealToHalf and its specializations define a mapping from floating-point data types to analogous half ...
Definition: Compression.h:110
static HalfT convert(const Vec2d &val)
Definition: Compression.h:135
static void write(std::ostream &os, const T *data, Index count, uint32_t compression)
Definition: Compression.h:288
Definition: version.h:229
Definition: Compression.h:97
void readData(std::istream &is, T *data, Index count, uint32_t compression)
Read data from a stream.
Definition: Compression.h:179
static HalfT convert(const Vec3d &val)
Definition: Compression.h:146
OPENVDB_API const void * getGridBackgroundValuePtr(std::ios_base &)
Return a pointer to the background value of the grid currently being read from or written to the give...
void writeCompressedValues(std::ostream &os, ValueT *srcBuf, Index srcCount, const MaskT &valueMask, const MaskT &childMask, bool toHalf)
Definition: Compression.h:462
OPENVDB_API uint32_t getDataCompression(std::ios_base &)
Return a bitwise OR of compression option flags (COMPRESS_ZIP, COMPRESS_ACTIVE_MASK,...
#define OPENVDB_USE_VERSION_NAMESPACE
Definition: version.h:188
Definition: Compression.h:94
Definition: Compression.h:80
Vec3< float > Vec3s
Definition: Vec3.h:678
void readCompressedValues(std::istream &is, ValueT *destBuf, Index destCount, const MaskT &valueMask, bool fromHalf)
Definition: Compression.h:339
static HalfT convert(float val)
Definition: Compression.h:118