dracox 0.0.1__cp39-cp39-win_amd64.whl

include/draco/core/bit_utils.h

@@ -0,0 +1,127 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File containing a basic set of bit manipulation utilities used within the
+// Draco library.
+
+#ifndef DRACO_CORE_BIT_UTILS_H_
+#define DRACO_CORE_BIT_UTILS_H_
+
+#include <inttypes.h>
+#include <stdint.h>
+
+#include <type_traits>
+
+#if defined(_MSC_VER)
+#include <intrin.h>
+#endif  // defined(_MSC_VER)
+
+namespace draco {
+
+// Returns the number of '1' bits within the input 32 bit integer.
+inline int CountOneBits32(uint32_t n) {
+  n -= ((n >> 1) & 0x55555555);
+  n = ((n >> 2) & 0x33333333) + (n & 0x33333333);
+  return (((n + (n >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;
+}
+
+inline uint32_t ReverseBits32(uint32_t n) {
+  n = ((n >> 1) & 0x55555555) | ((n & 0x55555555) << 1);
+  n = ((n >> 2) & 0x33333333) | ((n & 0x33333333) << 2);
+  n = ((n >> 4) & 0x0F0F0F0F) | ((n & 0x0F0F0F0F) << 4);
+  n = ((n >> 8) & 0x00FF00FF) | ((n & 0x00FF00FF) << 8);
+  return (n >> 16) | (n << 16);
+}
+
+// Copies the |nbits| from the src integer into the |dst| integer using the
+// provided bit offsets |dst_offset| and |src_offset|.
+inline void CopyBits32(uint32_t *dst, int dst_offset, uint32_t src,
+                       int src_offset, int nbits) {
+  const uint32_t mask = (~static_cast<uint32_t>(0)) >> (32 - nbits)
+                                                           << dst_offset;
+  *dst = (*dst & (~mask)) | (((src >> src_offset) << dst_offset) & mask);
+}
+
+// Returns the location of the most significant bit in the input integer |n|.
+// The functionality is not defined for |n == 0|.
+inline int MostSignificantBit(uint32_t n) {
+#if defined(__GNUC__)
+  return 31 ^ __builtin_clz(n);
+#elif defined(_MSC_VER)
+  unsigned long where;
+  _BitScanReverse(&where, n);
+  return (int)where;
+#else
+  uint32_t msb = 0;
+  if (n) {
+    if (0xFFFF0000 & n) { n >>= (1 << 4); msb |= (1 << 4); }
+    if (0x0000FF00 & n) { n >>= (1 << 3); msb |= (1 << 3); }
+    if (0x000000F0 & n) { n >>= (1 << 2); msb |= (1 << 2); }
+    if (0x0000000C & n) { n >>= (1 << 1); msb |= (1 << 1); }
+    if (0x00000002 & n) { msb |= (1 << 0); }
+  } else {
+    msb = -1;
+  }
+  return msb;
+#endif
+}
+
+// Helper function that converts signed integer values into unsigned integer
+// symbols that can be encoded using an entropy encoder.
+void ConvertSignedIntsToSymbols(const int32_t *in, int in_values,
+                                uint32_t *out);
+
+// Converts unsigned integer symbols encoded with an entropy encoder back to
+// signed values.
+void ConvertSymbolsToSignedInts(const uint32_t *in, int in_values,
+                                int32_t *out);
+
+// Helper function that converts a single signed integer value into an unsigned
+// integer symbol that can be encoded using an entropy encoder.
+template <class IntTypeT>
+typename std::make_unsigned<IntTypeT>::type ConvertSignedIntToSymbol(
+    IntTypeT val) {
+  typedef typename std::make_unsigned<IntTypeT>::type UnsignedType;
+  static_assert(std::is_integral<IntTypeT>::value, "IntTypeT is not integral.");
+  // Early exit if val is positive.
+  if (val >= 0) {
+    return static_cast<UnsignedType>(val) << 1;
+  }
+  val = -(val + 1);  // Map -1 to 0, -2 to -1, etc..
+  UnsignedType ret = static_cast<UnsignedType>(val);
+  ret <<= 1;
+  ret |= 1;
+  return ret;
+}
+
+// Converts a single unsigned integer symbol encoded with an entropy encoder
+// back to a signed value.
+template <class IntTypeT>
+typename std::make_signed<IntTypeT>::type ConvertSymbolToSignedInt(
+    IntTypeT val) {
+  static_assert(std::is_integral<IntTypeT>::value, "IntTypeT is not integral.");
+  typedef typename std::make_signed<IntTypeT>::type SignedType;
+  const bool is_positive = !static_cast<bool>(val & 1);
+  val >>= 1;
+  if (is_positive) {
+    return static_cast<SignedType>(val);
+  }
+  SignedType ret = static_cast<SignedType>(val);
+  ret = -ret - 1;
+  return ret;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_BIT_UTILS_H_

include/draco/core/bounding_box.h

@@ -0,0 +1,77 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_BOUNDING_BOX_H_
+#define DRACO_CORE_BOUNDING_BOX_H_
+
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Class for computing the bounding box of points in 3D space.
+class BoundingBox {
+ public:
+  // Creates bounding box object with minimum and maximum points initialized to
+  // the largest positive and the smallest negative values, respectively. The
+  // resulting abstract bounding box effectively has no points and can be
+  // updated by providing any point to Update() method.
+  BoundingBox();
+
+  // Creates bounding box object with minimum and maximum points initialized to
+  // |min_point| and |max_point|, respectively.
+  BoundingBox(const Vector3f &min_point, const Vector3f &max_point);
+
+  // Returns the minimum point of the bounding box.
+  inline const Vector3f &GetMinPoint() const { return min_point_; }
+
+  // Returns the maximum point of the bounding box.
+  inline const Vector3f &GetMaxPoint() const { return max_point_; }
+
+  // Checks if the bounding box object was created with the default constructor
+  // then never updated. Internally, checks if the bounding box minimum and
+  // maximum points hold the largest positive and smallest negative values.
+  bool IsValid() const;
+
+  // Conditionally updates the bounding box with a given |new_point|.
+  void Update(const Vector3f &new_point) {
+    for (int i = 0; i < 3; i++) {
+      if (new_point[i] < min_point_[i]) {
+        min_point_[i] = new_point[i];
+      }
+      if (new_point[i] > max_point_[i]) {
+        max_point_[i] = new_point[i];
+      }
+    }
+  }
+
+  // Updates bounding box with minimum and maximum points of the |other|
+  // bounding box.
+  void Update(const BoundingBox &other) {
+    Update(other.GetMinPoint());
+    Update(other.GetMaxPoint());
+  }
+
+  // Returns the size of the bounding box along each axis.
+  Vector3f Size() const { return max_point_ - min_point_; }
+
+  // Returns the center of the bounding box.
+  Vector3f Center() const { return (min_point_ + max_point_) / 2; }
+
+ private:
+  Vector3f min_point_;
+  Vector3f max_point_;
+};
+}  // namespace draco
+
+#endif  //  DRACO_CORE_BOUNDING_BOX_H_

include/draco/core/constants.h

@@ -0,0 +1,6 @@
+#ifndef DRACO_CORE_CONSTANTS_H_
+#define DRACO_CORE_CONSTANTS_H_
+
+#define DRACO_PI 3.14159265358979323846
+
+#endif  // DRACO_CORE_CONSTANTS_H_

include/draco/core/cycle_timer.h

@@ -0,0 +1,51 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_CYCLE_TIMER_H_
+#define DRACO_CORE_CYCLE_TIMER_H_
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+typedef LARGE_INTEGER DracoTimeVal;
+#else
+#include <sys/time.h>
+typedef timeval DracoTimeVal;
+#endif
+
+#include <cinttypes>
+#include <cstddef>
+
+namespace draco {
+
+class DracoTimer {
+ public:
+  DracoTimer() {}
+  ~DracoTimer() {}
+  void Start();
+  void Stop();
+  int64_t GetInMs();
+
+ private:
+  DracoTimeVal tv_start_;
+  DracoTimeVal tv_end_;
+};
+
+typedef DracoTimer CycleTimer;
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_CYCLE_TIMER_H_

include/draco/core/data_buffer.h

@@ -0,0 +1,82 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DATA_BUFFER_H_
+#define DRACO_CORE_DATA_BUFFER_H_
+
+#include <cstring>
+#include <ostream>
+#include <vector>
+
+#include "draco/core/draco_types.h"
+
+namespace draco {
+
+// Buffer descriptor servers as a unique identifier of a buffer.
+struct DataBufferDescriptor {
+  DataBufferDescriptor() : buffer_id(0), buffer_update_count(0) {}
+  // Id of the data buffer.
+  int64_t buffer_id;
+  // The number of times the buffer content was updated.
+  int64_t buffer_update_count;
+};
+
+// Class used for storing raw buffer data.
+class DataBuffer {
+ public:
+  DataBuffer();
+  bool Update(const void *data, int64_t size);
+  bool Update(const void *data, int64_t size, int64_t offset);
+
+  // Reallocate the buffer storage to a new size keeping the data unchanged.
+  void Resize(int64_t new_size);
+  void WriteDataToStream(std::ostream &stream);
+  // Reads data from the buffer. Potentially unsafe, called needs to ensure
+  // the accessed memory is valid.
+  void Read(int64_t byte_pos, void *out_data, size_t data_size) const {
+    memcpy(out_data, data() + byte_pos, data_size);
+  }
+
+  // Writes data to the buffer. Unsafe, caller must ensure the accessed memory
+  // is valid.
+  void Write(int64_t byte_pos, const void *in_data, size_t data_size) {
+    memcpy(const_cast<uint8_t *>(data()) + byte_pos, in_data, data_size);
+  }
+
+  // Copies data from another buffer to this buffer.
+  void Copy(int64_t dst_offset, const DataBuffer *src_buf, int64_t src_offset,
+            int64_t size) {
+    memcpy(const_cast<uint8_t *>(data()) + dst_offset,
+           src_buf->data() + src_offset, size);
+  }
+
+  void set_update_count(int64_t buffer_update_count) {
+    descriptor_.buffer_update_count = buffer_update_count;
+  }
+  int64_t update_count() const { return descriptor_.buffer_update_count; }
+  size_t data_size() const { return data_.size(); }
+  const uint8_t *data() const { return data_.data(); }
+  uint8_t *data() { return data_.data(); }
+  int64_t buffer_id() const { return descriptor_.buffer_id; }
+  void set_buffer_id(int64_t buffer_id) { descriptor_.buffer_id = buffer_id; }
+
+ private:
+  std::vector<uint8_t> data_;
+  // Counter incremented by Update() calls.
+  DataBufferDescriptor descriptor_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DATA_BUFFER_H_

include/draco/core/decoder_buffer.h

@@ -0,0 +1,216 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DECODER_BUFFER_H_
+#define DRACO_CORE_DECODER_BUFFER_H_
+
+#include <stdint.h>
+
+#include <cstring>
+#include <memory>
+
+#include "draco/core/macros.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class is a wrapper around input data used by MeshDecoder. It provides a
+// basic interface for decoding either typed or variable-bit sized data.
+class DecoderBuffer {
+ public:
+  DecoderBuffer();
+  DecoderBuffer(const DecoderBuffer &buf) = default;
+
+  DecoderBuffer &operator=(const DecoderBuffer &buf) = default;
+
+  // Sets the buffer's internal data. Note that no copy of the input data is
+  // made so the data owner needs to keep the data valid and unchanged for
+  // runtime of the decoder.
+  void Init(const char *data, size_t data_size);
+
+  // Sets the buffer's internal data. |version| is the Draco bitstream version.
+  void Init(const char *data, size_t data_size, uint16_t version);
+
+  // Starts decoding a bit sequence.
+  // decode_size must be true if the size of the encoded bit data was included,
+  // during encoding. The size is then returned to out_size.
+  // Returns false on error.
+  bool StartBitDecoding(bool decode_size, uint64_t *out_size);
+
+  // Ends the decoding of the bit sequence and return to the default
+  // byte-aligned decoding.
+  void EndBitDecoding();
+
+  // Decodes up to 32 bits into out_val. Can be called only in between
+  // StartBitDecoding and EndBitDecoding. Otherwise returns false.
+  bool DecodeLeastSignificantBits32(uint32_t nbits, uint32_t *out_value) {
+    if (!bit_decoder_active()) {
+      return false;
+    }
+    return bit_decoder_.GetBits(nbits, out_value);
+  }
+
+  // Decodes an arbitrary data type.
+  // Can be used only when we are not decoding a bit-sequence.
+  // Returns false on error.
+  template <typename T>
+  bool Decode(T *out_val) {
+    if (!Peek(out_val)) {
+      return false;
+    }
+    pos_ += sizeof(T);
+    return true;
+  }
+
+  bool Decode(void *out_data, size_t size_to_decode) {
+    if (data_size_ < static_cast<int64_t>(pos_ + size_to_decode)) {
+      return false;  // Buffer overflow.
+    }
+    memcpy(out_data, (data_ + pos_), size_to_decode);
+    pos_ += size_to_decode;
+    return true;
+  }
+
+  // Decodes an arbitrary data, but does not advance the reading position.
+  template <typename T>
+  bool Peek(T *out_val) {
+    const size_t size_to_decode = sizeof(T);
+    if (data_size_ < static_cast<int64_t>(pos_ + size_to_decode)) {
+      return false;  // Buffer overflow.
+    }
+    memcpy(out_val, (data_ + pos_), size_to_decode);
+    return true;
+  }
+
+  bool Peek(void *out_data, size_t size_to_peek) {
+    if (data_size_ < static_cast<int64_t>(pos_ + size_to_peek)) {
+      return false;  // Buffer overflow.
+    }
+    memcpy(out_data, (data_ + pos_), size_to_peek);
+    return true;
+  }
+
+  // Discards #bytes from the input buffer.
+  void Advance(int64_t bytes) { pos_ += bytes; }
+
+  // Moves the parsing position to a specific offset from the beginning of the
+  // input data.
+  void StartDecodingFrom(int64_t offset) { pos_ = offset; }
+
+  void set_bitstream_version(uint16_t version) { bitstream_version_ = version; }
+
+  // Returns the data array at the current decoder position.
+  const char *data_head() const { return data_ + pos_; }
+  int64_t remaining_size() const { return data_size_ - pos_; }
+  int64_t decoded_size() const { return pos_; }
+  bool bit_decoder_active() const { return bit_mode_; }
+
+  // Returns the bitstream associated with the data. Returns 0 if unknown.
+  uint16_t bitstream_version() const { return bitstream_version_; }
+
+ private:
+  // Internal helper class to decode bits from a bit buffer.
+  class BitDecoder {
+   public:
+    BitDecoder();
+    ~BitDecoder();
+
+    // Sets the bit buffer to |b|. |s| is the size of |b| in bytes.
+    inline void reset(const void *b, size_t s) {
+      bit_offset_ = 0;
+      bit_buffer_ = static_cast<const uint8_t *>(b);
+      bit_buffer_end_ = bit_buffer_ + s;
+    }
+
+    // Returns number of bits decoded so far.
+    inline uint64_t BitsDecoded() const {
+      return static_cast<uint64_t>(bit_offset_);
+    }
+
+    // Return number of bits available for decoding
+    inline uint64_t AvailBits() const {
+      return ((bit_buffer_end_ - bit_buffer_) * 8) - bit_offset_;
+    }
+
+    inline uint32_t EnsureBits(int k) {
+      DRACO_DCHECK_LE(k, 24);
+      DRACO_DCHECK_LE(static_cast<uint64_t>(k), AvailBits());
+
+      uint32_t buf = 0;
+      for (int i = 0; i < k; ++i) {
+        buf |= PeekBit(i) << i;
+      }
+      return buf;  // Okay to return extra bits
+    }
+
+    inline void ConsumeBits(int k) { bit_offset_ += k; }
+
+    // Returns |nbits| bits in |x|.
+    inline bool GetBits(uint32_t nbits, uint32_t *x) {
+      if (nbits > 32) {
+        return false;
+      }
+      uint32_t value = 0;
+      for (uint32_t bit = 0; bit < nbits; ++bit) {
+        value |= GetBit() << bit;
+      }
+      *x = value;
+      return true;
+    }
+
+   private:
+    // TODO(fgalligan): Add support for error reporting on range check.
+    // Returns one bit from the bit buffer.
+    inline int GetBit() {
+      const size_t off = bit_offset_;
+      const size_t byte_offset = off >> 3;
+      const int bit_shift = static_cast<int>(off & 0x7);
+      if (bit_buffer_ + byte_offset < bit_buffer_end_) {
+        const int bit = (bit_buffer_[byte_offset] >> bit_shift) & 1;
+        bit_offset_ = off + 1;
+        return bit;
+      }
+      return 0;
+    }
+
+    inline int PeekBit(int offset) {
+      const size_t off = bit_offset_ + offset;
+      const size_t byte_offset = off >> 3;
+      const int bit_shift = static_cast<int>(off & 0x7);
+      if (bit_buffer_ + byte_offset < bit_buffer_end_) {
+        const int bit = (bit_buffer_[byte_offset] >> bit_shift) & 1;
+        return bit;
+      }
+      return 0;
+    }
+
+    const uint8_t *bit_buffer_;
+    const uint8_t *bit_buffer_end_;
+    size_t bit_offset_;
+  };
+  friend class BufferBitCodingTest;
+
+  const char *data_;
+  int64_t data_size_;
+
+  // Current parsing position of the decoder.
+  int64_t pos_;
+  BitDecoder bit_decoder_;
+  bool bit_mode_;
+  uint16_t bitstream_version_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DECODER_BUFFER_H_

include/draco/core/divide.h

@@ -0,0 +1,42 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DIVIDE_H_
+#define DRACO_CORE_DIVIDE_H_
+// An implementation of the divide by multiply algorithm
+// https://gmplib.org/~tege/divcnst-pldi94.pdf
+// This file is based off libvpx's divide.h.
+
+#include <stdint.h>
+
+#include <climits>
+
+namespace draco {
+
+struct fastdiv_elem {
+  unsigned mult;
+  unsigned shift;
+};
+
+extern const struct fastdiv_elem vp10_fastdiv_tab[256];
+
+static inline unsigned fastdiv(unsigned x, int y) {
+  unsigned t =
+      ((uint64_t)x * vp10_fastdiv_tab[y].mult) >> (sizeof(x) * CHAR_BIT);
+  return (t + x) >> vp10_fastdiv_tab[y].shift;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DIVIDE_H_