introducing binary safe type cast utility.

Sources/Core/Math.h

@@ -23,10 +23,12 @@
 #include <algorithm> // std::max / std::min
 #include <cstdint> // uint32_t --> msvc
 #include <cmath>
+#include <cstring>
 #include <random>
 #include <string>
 #include <vector>
 #include <functional>
+#include <type_traits>
 #include <mutex>
 
 namespace spades {
@@ -973,6 +975,20 @@ namespace spades {
  std::string TrimSpaces(const std::string &);
 
  float SmoothStep(float);
+
+ /*
+ * binary safe cast, unlike traditional c++ cast operators, it needs to operate on a matching type size
+ *
+ * if the code updates to c++ 20 it can be dropped
+ */
+ template<bool dest, class src> using EnableIf = typename std::enable_if<dest, src>::type;
+ template<class dest, class src>
+ EnableIf<sizeof(dest) == sizeof(src) && std::is_trivially_copyable<dest>::value && std::is_trivially_copyable<src>::value, dest>
+ SafeCast(const src& s) {
+ dest d;
+ std::memcpy(&d, &s, sizeof(dest));
+ return d;
+ }
 }
 
 namespace std {

Sources/Core/OpusAudioStream.cpp

@@ -69,19 +69,19 @@ namespace spades {
  switch (whence) {
  case SEEK_CUR:
  self.stream->SetPosition(
- static_cast<std::uint64_t>(offset + self.stream->GetPosition()));
+ SafeCast<std::uint64_t>(offset + self.stream->GetPosition()));
  break;
  case SEEK_SET: self.stream->SetPosition(static_cast<std::uint64_t>(offset)); break;
  case SEEK_END:
  self.stream->SetPosition(
- static_cast<std::uint64_t>(offset + self.stream->GetLength()));
+ SafeCast<std::uint64_t>(offset + self.stream->GetLength()));
  break;
  }
  return 0;
  };
  opusCallback->tell = [](void *stream) -> opus_int64 {
  auto &self = *reinterpret_cast<OpusAudioStream *>(stream);
- return static_cast<opus_int64>(self.stream->GetPosition());
+ return SafeCast<opus_int64>(self.stream->GetPosition());
  };
  opusCallback->close = nullptr;
 
@@ -220,7 +220,7 @@ namespace spades {
  void OpusAudioStream::SetPosition(uint64_t pos) {
  pos = std::min(pos, GetLength());
 
- op_pcm_seek(opusFile, static_cast<opus_int64>(pos / (channels * 4)));
+ op_pcm_seek(opusFile, SafeCast<opus_int64>(pos / (channels * 4)));
 
  subsamplePosition = static_cast<int>(pos % (channels * 4));
  if (subsamplePosition) {

Sources/Core/SdlFileStream.cpp

@@ -21,6 +21,7 @@
 #include "SdlFileStream.h"
 #include "Debug.h"
 #include "Exception.h"
+#include "Math.h"
 
 namespace spades {
  SdlFileStream::SdlFileStream(SDL_RWops *f, bool ac) : ops(f), autoClose(ac) {
@@ -76,7 +77,7 @@ namespace spades {
  if (pos == -1) {
  SPRaise("This stream doesn't support seeking.");
  }
- return static_cast<uint64_t>(pos);
+ return SafeCast<uint64_t>(pos);
  }
 
  void SdlFileStream::SetPosition(uint64_t pos) {
@@ -86,7 +87,7 @@ namespace spades {
  SPRaise("Currently SdlFileStream doesn't support 64-bit offset.");
  }
 
- if (SDL_RWseek(ops, static_cast<Sint64>(pos), RW_SEEK_SET) == -1) {
+ if (SDL_RWseek(ops, SafeCast<Sint64>(pos), RW_SEEK_SET) == -1) {
  SPRaise("This stream doesn't support seeking.");
  }
  }

Sources/Draw/SWImageRenderer.cpp

@@ -78,10 +78,10 @@ namespace spades {
  }
  if (numSteps == 0)
  numSteps = 1;
- b.divisor = static_cast<unsigned int>(numSteps);
+ b.divisor = SafeCast<unsigned int>(numSteps);
  b.dividend = 0;
  b.largePos = start;
- b.step = static_cast<unsigned int>(distance);
+ b.step = SafeCast<unsigned int>(distance);
  } else {
  mode = 0;
  if (numSteps == 0) {