4#ifndef OPENVDB_IO_COMPRESSION_HAS_BEEN_INCLUDED 
    5#define OPENVDB_IO_COMPRESSION_HAS_BEEN_INCLUDED 
   80template <
typename ValueT, 
typename MaskT>
 
   84    static inline bool eq(
const ValueT& a, 
const ValueT& b) {
 
 
   89        const MaskT& valueMask, 
const MaskT& childMask,
 
   90        const ValueT* srcBuf, 
const ValueT& background)
 
   94        int numUniqueInactiveVals = 0;
 
   95        for (
typename MaskT::OffIterator it = valueMask.beginOff();
 
   96            numUniqueInactiveVals < 3 && it; ++it)
 
  101            if (childMask.isOn(idx)) 
continue;
 
  103            const ValueT& val = srcBuf[idx];
 
  104            const bool unique = !(
 
  109                if (numUniqueInactiveVals < 2) 
inactiveVal[numUniqueInactiveVals] = val;
 
  110                ++numUniqueInactiveVals;
 
  116        if (numUniqueInactiveVals == 1) {
 
  124        } 
else if (numUniqueInactiveVals == 2) {
 
  158        } 
else if (numUniqueInactiveVals > 2) {
 
 
 
  251    const bool seek = data == 
nullptr;
 
  257    if (metadata && seek && hasCompression) {
 
  258        size_t compressedSize = metadata->getCompressedSize(metadataOffset);
 
  259        is.seekg(compressedSize, std::ios_base::cur);
 
  265        is.seekg(
sizeof(T) * count, std::ios_base::cur);
 
  267        is.read(
reinterpret_cast<char*
>(data), 
sizeof(T) * count);
 
 
  277    for (
Index i = 0; i < count; ++i) {
 
  283        std::string buffer(len+1, 
' ');
 
  284        is.read(&buffer[0], len+1);
 
  285        if (data != 
nullptr) data[i].assign(buffer, 0, len);
 
 
  308        if (count < 1) 
return;
 
  309        if (data == 
nullptr) {
 
  313            std::vector<HalfT> halfData(count); 
 
  315                metadata, metadataOffset);
 
  317            std::copy(halfData.begin(), halfData.end(), data);
 
 
 
  330        return zipToStreamSize(
reinterpret_cast<const char*
>(data), 
sizeof(T) * count);
 
  332        return sizeof(T) * count;
 
 
  344    for (
Index i = 0; i < count; ++i) {
 
  345        const size_t len = data[i].size();
 
  346        size += 
sizeof(size_t) + (len+1);
 
 
  367        bloscToStream(os, 
reinterpret_cast<const char*
>(data), 
sizeof(T), count);
 
  369        zipToStream(os, 
reinterpret_cast<const char*
>(data), 
sizeof(T) * count);
 
  371        os.write(
reinterpret_cast<const char*
>(data), 
sizeof(T) * count);
 
 
  381    for (
Index i = 0; i < count; ++i) {
 
  382        const size_t len = data[i].size();
 
  384        os.write(data[i].c_str(), len+1);
 
 
  409        if (count < 1) 
return size_t(0);
 
  411        std::vector<HalfT> halfData(count);
 
  412        for (
Index i = 0; i < count; ++i) halfData[i] = RealToHalf<T>::convert(data[i]);
 
 
  416        if (count < 1) 
return;
 
  418        std::vector<HalfT> halfData(count);
 
  419        for (
Index i = 0; i < count; ++i) halfData[i] = RealToHalf<T>::convert(data[i]);
 
 
 
  426struct HalfWriter<true, double> {
 
  427    using HalfT = RealToHalf<double>::HalfT;
 
  428    static inline size_t writeSize(
const double* data, 
Index count, uint32_t 
compression)
 
  430        if (count < 1) 
return size_t(0);
 
  432        std::vector<HalfT> halfData(count);
 
  433        for (
Index i = 0; i < count; ++i) halfData[i] = RealToHalf<double>::convert(data[i]);
 
  434        return writeDataSize<HalfT>(
reinterpret_cast<const HalfT*
>(&halfData[0]), count, 
compression);
 
  436    static inline void write(std::ostream& os, 
const double* data, 
Index count,
 
  439        if (count < 1) 
return;
 
  441        std::vector<HalfT> halfData(count);
 
  442        for (
Index i = 0; i < count; ++i) halfData[i] = RealToHalf<double>::convert(data[i]);
 
  443        writeData<HalfT>(os, 
reinterpret_cast<const HalfT*
>(&halfData[0]), count, 
compression);
 
  464template<
typename ValueT, 
typename MaskT>
 
  467    const MaskT& valueMask, 
bool fromHalf)
 
  474    const bool seek = (destBuf == 
nullptr);
 
  480    uint64_t leafIndex(0);
 
  481    if (seek && meta && meta->delayedLoadMeta()) {
 
  484        leafIndex = meta->leaf();
 
  491        if (seek && !maskCompressed) {
 
  492            is.seekg(1, std::ios_base::cur);
 
  493        } 
else if (seek && delayLoadMeta) {
 
  494            metadata = delayLoadMeta->getMask(leafIndex);
 
  495            is.seekg(1, std::ios_base::cur);
 
  497            is.read(
reinterpret_cast<char*
>(&metadata), 1);
 
  503        background = *
static_cast<const ValueT*
>(bgPtr);
 
  505    ValueT inactiveVal1 = background;
 
  506    ValueT inactiveVal0 =
 
  515            is.seekg(
sizeof(ValueT), std::ios_base::cur);
 
  517            is.read(
reinterpret_cast<char*
>(&inactiveVal0), 
sizeof(ValueT));
 
  522                is.seekg(
sizeof(ValueT), std::ios_base::cur);
 
  524                is.read(
reinterpret_cast<char*
>(&inactiveVal1), 
sizeof(ValueT));
 
  537            is.seekg(selectionMask.memUsage(), std::ios_base::cur);
 
  539            selectionMask.load(is);
 
  543    ValueT* tempBuf = destBuf;
 
  544    std::unique_ptr<ValueT[]> scopedTempBuf;
 
  546    Index tempCount = destCount;
 
  551        tempCount = valueMask.countOn();
 
  552        if (!seek && tempCount != destCount) {
 
  555            scopedTempBuf.reset(
new ValueT[tempCount]);
 
  556            tempBuf = scopedTempBuf.get();
 
  563            is, (seek ? 
nullptr : tempBuf), tempCount, 
compression, delayLoadMeta.get(), leafIndex);
 
  566            is, (seek ? 
nullptr : tempBuf), tempCount, 
compression, delayLoadMeta.get(), leafIndex);
 
  572    if (!seek && maskCompressed && tempCount != destCount) {
 
  576        for (
Index destIdx = 0, tempIdx = 0; destIdx < MaskT::SIZE; ++destIdx) {
 
  577            if (valueMask.isOn(destIdx)) {
 
  579                destBuf[destIdx] = tempBuf[tempIdx];
 
  583                destBuf[destIdx] = (selectionMask.isOn(destIdx) ? inactiveVal1 : inactiveVal0);
 
 
  590template<
typename ValueT, 
typename MaskT>
 
  593    const MaskT& valueMask, uint8_t maskMetadata, 
bool toHalf, uint32_t compress)
 
  595    using NonConstValueT = 
typename std::remove_const<ValueT>::type;
 
  599    Index tempCount = srcCount;
 
  600    ValueT* tempBuf = srcBuf;
 
  601    std::unique_ptr<NonConstValueT[]> scopedTempBuf;
 
  607        Index64 onVoxels = valueMask.countOn();
 
  610            scopedTempBuf.reset(
new NonConstValueT[onVoxels]);
 
  611            NonConstValueT* localTempBuf = scopedTempBuf.get();
 
  614            for (
typename MaskT::OnIterator it = valueMask.beginOn(); it; ++it, ++tempCount) {
 
  615                localTempBuf[tempCount] = srcBuf[it.pos()];
 
  618            tempBuf = scopedTempBuf.get();
 
  625            tempBuf, tempCount, compress);
 
 
  644template<
typename ValueT, 
typename MaskT>
 
  647    const MaskT& valueMask, 
const MaskT& childMask, 
bool toHalf)
 
  653    Index tempCount = srcCount;
 
  654    ValueT* tempBuf = srcBuf;
 
  655    std::unique_ptr<ValueT[]> scopedTempBuf;
 
  660        os.write(
reinterpret_cast<const char*
>(&metadata), 1);
 
  669        ValueT background = zero;
 
  671            background = *
static_cast<const ValueT*
>(bgPtr);
 
  675        metadata = maskCompressData.
metadata;
 
  677        os.write(
reinterpret_cast<const char*
>(&metadata), 1);
 
  685                os.write(
reinterpret_cast<const char*
>(&maskCompressData.
inactiveVal[0]), 
sizeof(ValueT));
 
  688                    os.write(
reinterpret_cast<const char*
>(&maskCompressData.
inactiveVal[1]), 
sizeof(ValueT));
 
  693                os.write(
reinterpret_cast<const char*
>(&truncatedVal), 
sizeof(ValueT));
 
  697                    os.write(
reinterpret_cast<const char*
>(&truncatedVal), 
sizeof(ValueT));
 
  709            scopedTempBuf.reset(
new ValueT[srcCount]);
 
  710            tempBuf = scopedTempBuf.get();
 
  718                for (
typename MaskT::OnIterator it = valueMask.beginOn(); it; ++it, ++tempCount) {
 
  719                    tempBuf[tempCount] = srcBuf[it.pos()];
 
  726                for (
Index srcIdx = 0; srcIdx < srcCount; ++srcIdx) {
 
  727                    if (valueMask.isOn(srcIdx)) { 
 
  728                        tempBuf[tempCount] = srcBuf[srcIdx];
 
  732                            selectionMask.setOn(srcIdx); 
 
  739                selectionMask.save(os);
 
  748        writeData(os, tempBuf, tempCount, compress);
 
 
#define OPENVDB_ASSERT(X)
Definition Assert.h:41
General-purpose arithmetic and comparison routines, most of which accept arbitrary value types (or at...
Definition StreamCompression.h:34
OPENVDB_API uint32_t getDataCompression(std::ios_base &)
Return a bitwise OR of compression option flags (COMPRESS_ZIP, COMPRESS_ACTIVE_MASK,...
OPENVDB_API size_t zipToStreamSize(const char *data, size_t numBytes)
void writeCompressedValues(std::ostream &os, ValueT *srcBuf, Index srcCount, const MaskT &valueMask, const MaskT &childMask, bool toHalf)
Definition Compression.h:646
OPENVDB_API uint32_t getFormatVersion(std::ios_base &)
Return the file format version number associated with the given input stream.
OPENVDB_API void zipToStream(std::ostream &, const char *data, size_t numBytes)
@ COMPRESS_BLOSC
Definition Compression.h:57
@ COMPRESS_NONE
Definition Compression.h:54
@ COMPRESS_ACTIVE_MASK
Definition Compression.h:56
@ COMPRESS_ZIP
Definition Compression.h:55
T truncateRealToHalf(const T &val)
Return the given value truncated to 16-bit float precision.
Definition Compression.h:217
OPENVDB_API void unzipFromStream(std::istream &, char *data, size_t numBytes)
OPENVDB_API size_t bloscToStreamSize(const char *data, size_t valSize, size_t numVals)
OPENVDB_API void bloscToStream(std::ostream &, const char *data, size_t valSize, size_t numVals)
void readCompressedValues(std::istream &is, ValueT *destBuf, Index destCount, const MaskT &valueMask, bool fromHalf)
Definition Compression.h:466
void writeData(std::ostream &os, const T *data, Index count, uint32_t compression)
Definition Compression.h:364
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...
OPENVDB_API std::string compressionToString(uint32_t flags)
Return a string describing the given compression flags.
OPENVDB_API SharedPtr< StreamMetadata > getStreamMetadataPtr(std::ios_base &)
Return a shared pointer to an object that stores metadata (file format, compression scheme,...
OPENVDB_API void bloscFromStream(std::istream &, char *data, size_t numBytes)
@ MASK_AND_NO_INACTIVE_VALS
Definition Compression.h:73
@ MASK_AND_TWO_INACTIVE_VALS
Definition Compression.h:75
@ NO_MASK_AND_MINUS_BG
Definition Compression.h:71
@ NO_MASK_AND_ONE_INACTIVE_VAL
Definition Compression.h:72
@ MASK_AND_ONE_INACTIVE_VAL
Definition Compression.h:74
@ NO_MASK_AND_ALL_VALS
Definition Compression.h:76
@ NO_MASK_OR_INACTIVE_VALS
Definition Compression.h:70
void readData(std::istream &is, T *data, Index count, uint32_t compression, DelayedLoadMetadata *metadata=nullptr, size_t metadataOffset=size_t(0))
Read data from a stream.
Definition Compression.h:248
size_t writeCompressedValuesSize(ValueT *srcBuf, Index srcCount, const MaskT &valueMask, uint8_t maskMetadata, bool toHalf, uint32_t compress)
Definition Compression.h:592
size_t writeDataSize(const T *data, Index count, uint32_t compression)
Definition Compression.h:325
Vec2< double > Vec2d
Definition Vec2.h:533
Vec2< float > Vec2s
Definition Vec2.h:532
Vec3< double > Vec3d
Definition Vec3.h:665
T negative(const T &val)
Return the unary negation of the given value.
Definition Math.h:128
bool isExactlyEqual(const T0 &a, const T1 &b)
Return true if a is exactly equal to b.
Definition Math.h:443
internal::half half
Definition Types.h:29
Vec3< float > Vec3s
Definition Vec3.h:664
math::Vec2< math::half > Vec2H
Definition Types.h:66
Index32 Index
Definition Types.h:54
math::Vec3< math::half > Vec3H
Definition Types.h:75
constexpr T zeroVal()
Return the value of type T that corresponds to zero.
Definition Math.h:70
@ OPENVDB_FILE_VERSION_NODE_MASK_COMPRESSION
Definition version.h.in:262
uint32_t Index32
Definition Types.h:52
uint64_t Index64
Definition Types.h:53
Definition Exceptions.h:13
static void read(std::istream &is, T *data, Index count, uint32_t compression, DelayedLoadMetadata *metadata=nullptr, size_t metadataOffset=size_t(0))
Definition Compression.h:297
typename RealToHalf< T >::HalfT HalfT
Definition Compression.h:305
static void read(std::istream &is, T *data, Index count, uint32_t compression, DelayedLoadMetadata *metadata=nullptr, size_t metadataOffset=size_t(0))
Definition Compression.h:306
Definition Compression.h:293
static size_t writeSize(const T *data, Index count, uint32_t compression)
Definition Compression.h:397
static void write(std::ostream &os, const T *data, Index count, uint32_t compression)
Definition Compression.h:400
static size_t writeSize(const T *data, Index count, uint32_t compression)
Definition Compression.h:408
typename RealToHalf< T >::HalfT HalfT
Definition Compression.h:407
static void write(std::ostream &os, const T *data, Index count, uint32_t compression)
Definition Compression.h:415
Definition Compression.h:393
Definition Compression.h:82
int8_t metadata
Definition Compression.h:163
MaskCompress(const MaskT &valueMask, const MaskT &childMask, const ValueT *srcBuf, const ValueT &background)
Definition Compression.h:88
static bool eq(const ValueT &a, const ValueT &b)
Definition Compression.h:84
ValueT inactiveVal[2]
Definition Compression.h:164
Vec2H HalfT
Definition Compression.h:197
@ isReal
Definition Compression.h:196
static HalfT convert(const Vec2d &val)
Definition Compression.h:199
Vec2H HalfT
Definition Compression.h:192
@ isReal
Definition Compression.h:191
static HalfT convert(const Vec2s &val)
Definition Compression.h:193
@ isReal
Definition Compression.h:207
Vec3H HalfT
Definition Compression.h:208
static HalfT convert(const Vec3d &val)
Definition Compression.h:210
Vec3H HalfT
Definition Compression.h:203
@ isReal
Definition Compression.h:202
static HalfT convert(const Vec3s &val)
Definition Compression.h:204
math::half HalfT
Definition Compression.h:186
@ isReal
Definition Compression.h:185
static HalfT convert(double val)
Definition Compression.h:188
static HalfT convert(float val)
Definition Compression.h:182
@ isReal
Definition Compression.h:180
math::half HalfT
Definition Compression.h:181
RealToHalf and its specializations define a mapping from floating-point data types to analogous half ...
Definition Compression.h:174
@ isReal
Definition Compression.h:175
T HalfT
Definition Compression.h:176
static HalfT convert(const T &val)
Definition Compression.h:177
#define OPENVDB_VERSION_NAME
The version namespace name for this library version.
Definition version.h.in:121
#define OPENVDB_USE_VERSION_NAMESPACE
Definition version.h.in:218