Partial progress towards analog waves

Author: pieter3d

src/CMakeLists.txt

@@ -40,6 +40,7 @@ add_executable(simview
   wave_data.cc
   wavedata_tree_item.cc
   wavedata_tree_panel.cc
+  wave_image.cc
   wave_signals_panel.cc
   waves_panel.cc
   workspace.cc

src/radix.cc

@@ -1,25 +1,62 @@
 #include "radix.h"
 #include "absl/strings/str_format.h"
+#include <optional>
 
 namespace sv {
-std::string FormatValue(const std::string &bin, Radix radix,
-                        bool leading_zeroes, bool drop_size) {
+
+namespace {
+
+int64_t SignExtend(uint64_t val, int bits) {
+  if (val & (1ull << (bits - 1))) return val | (static_cast<uint64_t>(-1) << bits);
+  return val;
+}
+
+template <typename T>
+std::optional<T> BinStringCast(std::string_view bin) {
+  std::optional<uint64_t> val_or = BinStringToUnsigned(bin);
+  if (!val_or) return std::nullopt;
+  const uint64_t val = *val_or;
+  T t;
+  memcpy(&t, &val, sizeof(T));
+  return t;
+}
+
+} // namespace
+
+std::optional<uint64_t> BinStringToUnsigned(std::string_view bin) {
+  if (bin.size() > 64) return std::nullopt;
+  uint64_t val = 0;
+  for (char ch : bin) {
+    if (ch != '0' && ch != '1') return std::nullopt;
+    val <<= 1;
+    val |= ch == '1';
+  }
+  return val;
+}
+
+std::optional<float> BinStringToFp32(std::string_view bin) { return BinStringCast<float>(bin); }
+
+std::optional<double> BinStringToFp64(std::string_view bin) { return BinStringCast<double>(bin); }
+
+std::optional<int64_t> BinStringToSigned(std::string_view bin) {
+  std::optional<uint64_t> val_or = BinStringToUnsigned(bin);
+  if (!val_or) return std::nullopt;
+  return SignExtend(*val_or, bin.size());
+}
+
+std::string FormatValue(const std::string &bin, Radix radix, bool leading_zeroes, bool drop_size) {
   if (radix == Radix::kUnsignedDecimal || radix == Radix::kSignedDecimal ||
       radix == Radix::kFloat) {
     // These formats can use a real machine type and therefore take advantage of
     // printf style formatting.
-    uint64_t val = 0;
-    for (int i = 0; i < bin.size(); ++i) {
-      const char ch = std::tolower(bin[bin.size() - 1 - i]);
-      if (ch == 'z' || ch == 'x') return "x";
-      if (bin[bin.size() - 1 - i] == '1') val |= 1ull << i;
-    }
+    std::optional<uint64_t> maybe_val = BinStringToUnsigned(bin);
+    if (!maybe_val) return "x";
+    uint64_t val = *maybe_val;
     if (radix == Radix::kUnsignedDecimal) {
-      return (drop_size ? "" : absl::StrFormat("%d'd", bin.size())) +
-             absl::StrFormat("%lu", val);
+      return (drop_size ? "" : absl::StrFormat("%d'd", bin.size())) + absl::StrFormat("%lu", val);
     } else if (radix == Radix::kSignedDecimal) {
-      return (drop_size ? "" : absl::StrFormat("%d'sd", bin.size())) +
-             absl::StrFormat("%ld", val);
+      int64_t sval = SignExtend(val, bin.size());
+      return (drop_size ? "" : absl::StrFormat("%d'sd", bin.size())) + absl::StrFormat("%ld", sval);
     } else if (bin.size() == 32) {
       float f;
       memcpy(&f, &val, sizeof(float));

src/radix.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <cstdint>
+#include <optional>
 #include <string>
 
 namespace sv {
@@ -12,6 +14,11 @@ enum class Radix {
   kFloat,
 };
 
+std::optional<float> BinStringToFp32(std::string_view bin);
+std::optional<double> BinStringToFp64(std::string_view bin);
+std::optional<int64_t> BinStringToSigned(std::string_view bin);
+std::optional<uint64_t> BinStringToUnsigned(std::string_view bin);
+
 // Format a string of '1' and '0' charachters into the proper representation.
 std::string FormatValue(const std::string &bin, Radix radix,
                         bool leading_zeroes, bool drop_size = false);

src/wave_image.cc

@@ -0,0 +1,84 @@
+#include "wave_image.h"
+#include <cstdlib>
+
+namespace sv {
+
+void WaveImage::SetPixel(int x, int y) {
+  if (x < 0 || x >= width_) return;
+  if (y < 0 || y >= height_) return;
+  buffer_[y * width_ * x] = true;
+}
+
+void WaveImage::DrawLine(int x0, int y0, int x1, int y1) {
+  if (x0 < 0 || x1 < 0 || x0 >= width_ || x1 >= width_) return;
+  if (y0 < 0 || y1 < 0 || y0 >= height_ || y1 >= height_) return;
+  // Bresenham's Line Algorithm
+  const bool steep = std::abs(y1 - y0) > std::abs(x1 - x0);
+  if (steep) {
+    std::swap(x0, y0);
+    std::swap(x1, y1);
+  }
+  if (x0 > x1) {
+    std::swap(x0, x1);
+    std::swap(y0, y1);
+  }
+
+  const int dx = x1 - x0;
+  const int dy = std::abs(y1 - y0);
+  const int ystep = (y0 < y1) ? 1 : -1;
+  int error = dx / 2;
+  int y = y0;
+
+  for (int x = x0; x <= x1; ++x) {
+    if (steep) {
+      SetPixel(y, x);
+    } else {
+      SetPixel(x, y);
+    }
+    error -= dy;
+    if (error < 0) {
+      y += ystep;
+      error += dx;
+    }
+  }
+}
+
+uint16_t WaveImage::GetBrailleChar(int x, int y) {
+  // Bit index as follows:
+  // 0 3
+  // 1 4
+  // 2 5
+  // 6 7
+  // nicode value is 0x28xx, with xx being the 8-bits above.
+  uint16_t braille = 0x2800;
+  if (x >= width_ / 2 || y >= height_ / 4) return braille;
+  braille |= buffer_[(4 * y + 0) * width_ + (2 * x + 0)] << 0;
+  braille |= buffer_[(4 * y + 1) * width_ + (2 * x + 0)] << 1;
+  braille |= buffer_[(4 * y + 2) * width_ + (2 * x + 0)] << 2;
+  braille |= buffer_[(4 * y + 0) * width_ + (2 * x + 1)] << 3;
+  braille |= buffer_[(4 * y + 1) * width_ + (2 * x + 1)] << 4;
+  braille |= buffer_[(4 * y + 2) * width_ + (2 * x + 1)] << 5;
+  braille |= buffer_[(4 * y + 3) * width_ + (2 * x + 0)] << 6;
+  braille |= buffer_[(4 * y + 3) * width_ + (2 * x + 1)] << 7;
+  return braille;
+}
+
+WaveImage RenderWaves(const WaveImageConfig &cfg, const std::vector<WaveData::Sample> &wave) {
+  
+
+
+  // Braille patterns are 2x4 dots, "pixels".
+  WaveImage img(cfg.char_w * 2, cfg.char_h * 4);
+
+  int p0_idx = cfg.left_idx;
+  while (p0_idx > 0 && wave[p0_idx].time > cfg.left_time) {
+    p0_idx--;
+  }
+  // Draw stable signal up to the first point.
+  if (wave[p0_idx].time > cfg.left_time) {
+  }
+
+
+  return img;
+}
+} // namespace sv

src/wave_image.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "radix.h"
+#include "wave_data.h"
+
+#include <cstdint>
+#include <vector>
+
+namespace sv {
+
+class WaveImage {
+ public:
+  WaveImage(int w, int h) : width_(w), height_(h), buffer_(w * h) {}
+  bool GetPixel(int x, int y) const { return buffer_[y * width_ * x]; }
+  void DrawLine(int x0, int y0, int x1, int y1);
+  uint16_t GetBrailleChar(int x, int y);
+
+ private:
+  void SetPixel(int x, int y);
+  const int width_;
+  const int height_;
+  std::vector<bool> buffer_;
+};
+
+struct WaveImageConfig {
+  int char_w;
+  int char_h;
+  // Hint indicator where the sample is that's near the left edge of the image.
+  int left_idx = 0;
+  uint64_t left_time;
+  uint64_t right_time;
+  Radix radix = Radix::kBinary;
+};
+
+WaveImage RenderWaves(const WaveImageConfig &cfg, const std::vector<WaveData::Sample> &wave);
+
+} // namespace sv