netprof privapi + ui (wip histograms)

e740b4e3b2e feat: Implement Tox network profiler

git-subtree-dir: external/toxcore/c-toxcore
git-subtree-split: e740b4e3b2e3aa594ab259e2a80153f5eed8fd16

CMakeLists.txt

@@ -27,19 +27,11 @@ message("II TOMATO_TOX_AV: ${TOMATO_TOX_AV}")
 if (TOMATO_ASAN)
 	if (${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU" OR ${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
 		if (NOT WIN32) # exclude mingw
-			add_compile_options(-fsanitize=address,undefined)
+			#link_libraries(-fsanitize=address)
 			link_libraries(-fsanitize=address,undefined)
 			#link_libraries(-fsanitize=undefined)
 			link_libraries(-static-libasan) # make it "work" on nix
-
-			#add_compile_options(-fsanitize=thread)
-			#link_libraries(-fsanitize=thread)
-
 			message("II enabled ASAN")
-			if (OFF) # TODO: switch for minimal runtime in deployed scenarios
-				add_compile_options(-fsanitize-minimal-runtime)
-				link_libraries(-fsanitize-minimal-runtime)
-			endif()
 		else()
 			message("!! can not enable ASAN on this platform (gcc/clang + win)")
 		endif()

external/CMakeLists.txt

@@ -24,4 +24,3 @@ add_subdirectory(./libwebp)
 add_subdirectory(./qoi)
 add_subdirectory(./sdl_image)
 
-add_subdirectory(./spscqueue)

external/spscqueue/CMakeLists.txt

@@ -1,9 +0,0 @@
-cmake_minimum_required(VERSION 3.9 FATAL_ERROR)
-
-add_library(SPSCQueue INTERFACE
-	./SPSCQueue.h
-)
-
-target_compile_features(SPSCQueue INTERFACE cxx_std_17)
-target_include_directories(SPSCQueue INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}")
-

external/spscqueue/SPSCQueue.h

@@ -1,237 +0,0 @@
-/*
-Copyright (c) 2020 Erik Rigtorp <erik@rigtorp.se>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-#pragma once
-
-#include <atomic>
-#include <cassert>
-#include <cstddef>
-#include <memory> // std::allocator
-#include <new>    // std::hardware_destructive_interference_size
-#include <stdexcept>
-#include <type_traits> // std::enable_if, std::is_*_constructible
-
-#ifdef __has_cpp_attribute
-#if __has_cpp_attribute(nodiscard)
-#define RIGTORP_NODISCARD [[nodiscard]]
-#endif
-#endif
-#ifndef RIGTORP_NODISCARD
-#define RIGTORP_NODISCARD
-#endif
-
-namespace rigtorp {
-
-template <typename T, typename Allocator = std::allocator<T>> class SPSCQueue {
-
-#if defined(__cpp_if_constexpr) && defined(__cpp_lib_void_t)
-  template <typename Alloc2, typename = void>
-  struct has_allocate_at_least : std::false_type {};
-
-  template <typename Alloc2>
-  struct has_allocate_at_least<
-      Alloc2, std::void_t<typename Alloc2::value_type,
-                          decltype(std::declval<Alloc2 &>().allocate_at_least(
-                              size_t{}))>> : std::true_type {};
-#endif
-
-public:
-  explicit SPSCQueue(const size_t capacity,
-                     const Allocator &allocator = Allocator())
-      : capacity_(capacity), allocator_(allocator) {
-    // The queue needs at least one element
-    if (capacity_ < 1) {
-      capacity_ = 1;
-    }
-    capacity_++; // Needs one slack element
-    // Prevent overflowing size_t
-    if (capacity_ > SIZE_MAX - 2 * kPadding) {
-      capacity_ = SIZE_MAX - 2 * kPadding;
-    }
-
-#if defined(__cpp_if_constexpr) && defined(__cpp_lib_void_t)
-    if constexpr (has_allocate_at_least<Allocator>::value) {
-      auto res = allocator_.allocate_at_least(capacity_ + 2 * kPadding);
-      slots_ = res.ptr;
-      capacity_ = res.count - 2 * kPadding;
-    } else {
-      slots_ = std::allocator_traits<Allocator>::allocate(
-          allocator_, capacity_ + 2 * kPadding);
-    }
-#else
-    slots_ = std::allocator_traits<Allocator>::allocate(
-        allocator_, capacity_ + 2 * kPadding);
-#endif
-
-    static_assert(alignof(SPSCQueue<T>) == kCacheLineSize, "");
-    static_assert(sizeof(SPSCQueue<T>) >= 3 * kCacheLineSize, "");
-    assert(reinterpret_cast<char *>(&readIdx_) -
-               reinterpret_cast<char *>(&writeIdx_) >=
-           static_cast<std::ptrdiff_t>(kCacheLineSize));
-  }
-
-  ~SPSCQueue() {
-    while (front()) {
-      pop();
-    }
-    std::allocator_traits<Allocator>::deallocate(allocator_, slots_,
-                                                 capacity_ + 2 * kPadding);
-  }
-
-  // non-copyable and non-movable
-  SPSCQueue(const SPSCQueue &) = delete;
-  SPSCQueue &operator=(const SPSCQueue &) = delete;
-
-  template <typename... Args>
-  void emplace(Args &&...args) noexcept(
-      std::is_nothrow_constructible<T, Args &&...>::value) {
-    static_assert(std::is_constructible<T, Args &&...>::value,
-                  "T must be constructible with Args&&...");
-    auto const writeIdx = writeIdx_.load(std::memory_order_relaxed);
-    auto nextWriteIdx = writeIdx + 1;
-    if (nextWriteIdx == capacity_) {
-      nextWriteIdx = 0;
-    }
-    while (nextWriteIdx == readIdxCache_) {
-      readIdxCache_ = readIdx_.load(std::memory_order_acquire);
-    }
-    new (&slots_[writeIdx + kPadding]) T(std::forward<Args>(args)...);
-    writeIdx_.store(nextWriteIdx, std::memory_order_release);
-  }
-
-  template <typename... Args>
-  RIGTORP_NODISCARD bool try_emplace(Args &&...args) noexcept(
-      std::is_nothrow_constructible<T, Args &&...>::value) {
-    static_assert(std::is_constructible<T, Args &&...>::value,
-                  "T must be constructible with Args&&...");
-    auto const writeIdx = writeIdx_.load(std::memory_order_relaxed);
-    auto nextWriteIdx = writeIdx + 1;
-    if (nextWriteIdx == capacity_) {
-      nextWriteIdx = 0;
-    }
-    if (nextWriteIdx == readIdxCache_) {
-      readIdxCache_ = readIdx_.load(std::memory_order_acquire);
-      if (nextWriteIdx == readIdxCache_) {
-        return false;
-      }
-    }
-    new (&slots_[writeIdx + kPadding]) T(std::forward<Args>(args)...);
-    writeIdx_.store(nextWriteIdx, std::memory_order_release);
-    return true;
-  }
-
-  void push(const T &v) noexcept(std::is_nothrow_copy_constructible<T>::value) {
-    static_assert(std::is_copy_constructible<T>::value,
-                  "T must be copy constructible");
-    emplace(v);
-  }
-
-  template <typename P, typename = typename std::enable_if<
-                            std::is_constructible<T, P &&>::value>::type>
-  void push(P &&v) noexcept(std::is_nothrow_constructible<T, P &&>::value) {
-    emplace(std::forward<P>(v));
-  }
-
-  RIGTORP_NODISCARD bool
-  try_push(const T &v) noexcept(std::is_nothrow_copy_constructible<T>::value) {
-    static_assert(std::is_copy_constructible<T>::value,
-                  "T must be copy constructible");
-    return try_emplace(v);
-  }
-
-  template <typename P, typename = typename std::enable_if<
-                            std::is_constructible<T, P &&>::value>::type>
-  RIGTORP_NODISCARD bool
-  try_push(P &&v) noexcept(std::is_nothrow_constructible<T, P &&>::value) {
-    return try_emplace(std::forward<P>(v));
-  }
-
-  RIGTORP_NODISCARD T *front() noexcept {
-    auto const readIdx = readIdx_.load(std::memory_order_relaxed);
-    if (readIdx == writeIdxCache_) {
-      writeIdxCache_ = writeIdx_.load(std::memory_order_acquire);
-      if (writeIdxCache_ == readIdx) {
-        return nullptr;
-      }
-    }
-    return &slots_[readIdx + kPadding];
-  }
-
-  void pop() noexcept {
-    static_assert(std::is_nothrow_destructible<T>::value,
-                  "T must be nothrow destructible");
-    auto const readIdx = readIdx_.load(std::memory_order_relaxed);
-    assert(writeIdx_.load(std::memory_order_acquire) != readIdx &&
-           "Can only call pop() after front() has returned a non-nullptr");
-    slots_[readIdx + kPadding].~T();
-    auto nextReadIdx = readIdx + 1;
-    if (nextReadIdx == capacity_) {
-      nextReadIdx = 0;
-    }
-    readIdx_.store(nextReadIdx, std::memory_order_release);
-  }
-
-  RIGTORP_NODISCARD size_t size() const noexcept {
-    std::ptrdiff_t diff = writeIdx_.load(std::memory_order_acquire) -
-                          readIdx_.load(std::memory_order_acquire);
-    if (diff < 0) {
-      diff += capacity_;
-    }
-    return static_cast<size_t>(diff);
-  }
-
-  RIGTORP_NODISCARD bool empty() const noexcept {
-    return writeIdx_.load(std::memory_order_acquire) ==
-           readIdx_.load(std::memory_order_acquire);
-  }
-
-  RIGTORP_NODISCARD size_t capacity() const noexcept { return capacity_ - 1; }
-
-private:
-#ifdef __cpp_lib_hardware_interference_size
-  static constexpr size_t kCacheLineSize =
-      std::hardware_destructive_interference_size;
-#else
-  static constexpr size_t kCacheLineSize = 64;
-#endif
-
-  // Padding to avoid false sharing between slots_ and adjacent allocations
-  static constexpr size_t kPadding = (kCacheLineSize - 1) / sizeof(T) + 1;
-
-private:
-  size_t capacity_;
-  T *slots_;
-#if defined(__has_cpp_attribute) && __has_cpp_attribute(no_unique_address)
-  Allocator allocator_ [[no_unique_address]];
-#else
-  Allocator allocator_;
-#endif
-
-  // Align to cache line size in order to avoid false sharing
-  // readIdxCache_ and writeIdxCache_ is used to reduce the amount of cache
-  // coherency traffic
-  alignas(kCacheLineSize) std::atomic<size_t> writeIdx_ = {0};
-  alignas(kCacheLineSize) size_t readIdxCache_ = 0;
-  alignas(kCacheLineSize) std::atomic<size_t> readIdx_ = {0};
-  alignas(kCacheLineSize) size_t writeIdxCache_ = 0;
-};
-} // namespace rigtorp

external/toxcore/c-toxcore/.gitignore

@@ -36,6 +36,7 @@ testing/data
 
 # Vim
 *.swp
+*.nvimlog
 
 # Object files
 *.o

external/toxcore/c-toxcore/CMakeLists.txt

@@ -306,6 +306,8 @@ set(toxcore_SOURCES
   toxcore/mem.h
   toxcore/mono_time.c
   toxcore/mono_time.h
+  toxcore/net_profile.c
+  toxcore/net_profile.h
   toxcore/net_crypto.c
   toxcore/net_crypto.h
   toxcore/network.c

external/toxcore/c-toxcore/auto_tests/CMakeLists.txt

@@ -67,6 +67,7 @@ auto_test(invalid_udp_proxy)
 auto_test(lan_discovery)
 auto_test(lossless_packet)
 auto_test(lossy_packet)
+auto_test(netprof)
 auto_test(network)
 auto_test(onion)
 auto_test(overflow_recvq)

external/toxcore/c-toxcore/auto_tests/TCP_test.c

@@ -111,12 +111,12 @@ static void test_basic(void)
 
     // Sending the handshake
     ck_assert_msg(net_send(ns, logger, sock, handshake, TCP_CLIENT_HANDSHAKE_SIZE - 1,
-                           &localhost) == TCP_CLIENT_HANDSHAKE_SIZE - 1,
+                           &localhost, nullptr) == TCP_CLIENT_HANDSHAKE_SIZE - 1,
                   "An attempt to send the initial handshake minus last byte failed.");
 
     do_tcp_server_delay(tcp_s, mono_time, 50);
 
-    ck_assert_msg(net_send(ns, logger, sock, handshake + (TCP_CLIENT_HANDSHAKE_SIZE - 1), 1, &localhost) == 1,
+    ck_assert_msg(net_send(ns, logger, sock, handshake + (TCP_CLIENT_HANDSHAKE_SIZE - 1), 1, &localhost, nullptr) == 1,
                   "The attempt to send the last byte of handshake failed.");
 
     free(handshake);
@@ -155,7 +155,7 @@ static void test_basic(void)
             msg_length = sizeof(r_req) - i;
         }
 
-        ck_assert_msg(net_send(ns, logger, sock, r_req + i, msg_length, &localhost) == msg_length,
+        ck_assert_msg(net_send(ns, logger, sock, r_req + i, msg_length, &localhost, nullptr) == msg_length,
                       "Failed to send request after completing the handshake.");
         i += msg_length;
 
@@ -234,12 +234,12 @@ static struct sec_TCP_con *new_tcp_con(const Logger *logger, const Memory *mem,
                   "Failed to encrypt the outgoing handshake.");
 
     ck_assert_msg(net_send(ns, logger, sock, handshake, TCP_CLIENT_HANDSHAKE_SIZE - 1,
-                           &localhost) == TCP_CLIENT_HANDSHAKE_SIZE - 1,
+                           &localhost, nullptr) == TCP_CLIENT_HANDSHAKE_SIZE - 1,
                   "Failed to send the first portion of the handshake to the TCP relay server.");
 
     do_tcp_server_delay(tcp_s, mono_time, 50);
 
-    ck_assert_msg(net_send(ns, logger, sock, handshake + (TCP_CLIENT_HANDSHAKE_SIZE - 1), 1, &localhost) == 1,
+    ck_assert_msg(net_send(ns, logger, sock, handshake + (TCP_CLIENT_HANDSHAKE_SIZE - 1), 1, &localhost, nullptr) == 1,
                   "Failed to send last byte of handshake.");
 
     do_tcp_server_delay(tcp_s, mono_time, 50);
@@ -283,7 +283,7 @@ static int write_packet_tcp_test_connection(const Logger *logger, struct sec_TCP
     localhost.ip = get_loopback();
     localhost.port = 0;
 
-    ck_assert_msg(net_send(con->ns, logger, con->sock, packet, packet_size, &localhost) == packet_size,
+    ck_assert_msg(net_send(con->ns, logger, con->sock, packet, packet_size, &localhost, nullptr) == packet_size,
                   "Failed to send a packet.");
     return 0;
 }
@@ -524,7 +524,7 @@ static void test_client(void)
     ip_port_tcp_s.port = net_htons(ports[random_u32(rng) % NUM_PORTS]);
     ip_port_tcp_s.ip = get_loopback();
 
-    TCP_Client_Connection *conn = new_tcp_connection(logger, mem, mono_time, rng, ns, &ip_port_tcp_s, self_public_key, f_public_key, f_secret_key, nullptr);
+    TCP_Client_Connection *conn = new_tcp_connection(logger, mem, mono_time, rng, ns, &ip_port_tcp_s, self_public_key, f_public_key, f_secret_key, nullptr, nullptr);
     // TCP sockets might need a moment before they can be written to.
     c_sleep(50);
     do_tcp_connection(logger, mono_time, conn, nullptr);
@@ -560,7 +560,7 @@ static void test_client(void)
     crypto_new_keypair(rng, f2_public_key, f2_secret_key);
     ip_port_tcp_s.port = net_htons(ports[random_u32(rng) % NUM_PORTS]);
     TCP_Client_Connection *conn2 = new_tcp_connection(logger, mem, mono_time, rng, ns, &ip_port_tcp_s, self_public_key, f2_public_key,
-                                   f2_secret_key, nullptr);
+                                   f2_secret_key, nullptr, nullptr);
     c_sleep(50);
 
     // The client should call this function (defined earlier) during the routing process.
@@ -657,7 +657,7 @@ static void test_client_invalid(void)
     ip_port_tcp_s.port = net_htons(ports[random_u32(rng) % NUM_PORTS]);
     ip_port_tcp_s.ip = get_loopback();
     TCP_Client_Connection *conn = new_tcp_connection(logger, mem, mono_time, rng, ns, &ip_port_tcp_s,
-                                  self_public_key, f_public_key, f_secret_key, nullptr);
+                                  self_public_key, f_public_key, f_secret_key, nullptr, nullptr);
 
     // Run the client's main loop but not the server.
     mono_time_update(mono_time);

external/toxcore/c-toxcore/auto_tests/netprof_test.c

@@ -0,0 +1,120 @@
+/** Auto Tests: basic network profile functionality test (UDP only)
+ * TODO(JFreegman): test TCP packets as well
+ */
+
+#include <stdint.h>
+#include <stdio.h>
+
+#include "../toxcore/tox_private.h"
+#include "../toxcore/util.h"
+
+#include "auto_test_support.h"
+#include "check_compat.h"
+
+#define NUM_TOXES 2
+
+static void test_netprof(AutoTox *autotoxes)
+{
+    // Send some messages to create fake traffic
+    for (size_t i = 0; i < 256; ++i) {
+        for (uint32_t j = 0; j < NUM_TOXES; ++j) {
+            tox_friend_send_message(autotoxes[j].tox, 0, TOX_MESSAGE_TYPE_NORMAL, (const uint8_t *)"test", 4, nullptr);
+        }
+
+        iterate_all_wait(autotoxes, NUM_TOXES, ITERATION_INTERVAL);
+    }
+
+    // idle traffic for a while
+    for (size_t i = 0; i < 100; ++i) {
+        iterate_all_wait(autotoxes, NUM_TOXES, ITERATION_INTERVAL);
+    }
+
+    const Tox *tox1 = autotoxes[0].tox;
+
+    const unsigned long long UDP_count_sent1 = tox_netprof_get_packet_total_count(tox1, TOX_NETPROF_PACKET_TYPE_UDP,
+            TOX_NETPROF_DIRECTION_SENT);
+    const unsigned long long UDP_count_recv1 = tox_netprof_get_packet_total_count(tox1, TOX_NETPROF_PACKET_TYPE_UDP,
+            TOX_NETPROF_DIRECTION_RECV);
+    const unsigned long long TCP_count_sent1 = tox_netprof_get_packet_total_count(tox1, TOX_NETPROF_PACKET_TYPE_TCP,
+            TOX_NETPROF_DIRECTION_SENT);
+    const unsigned long long TCP_count_recv1 = tox_netprof_get_packet_total_count(tox1, TOX_NETPROF_PACKET_TYPE_TCP,
+            TOX_NETPROF_DIRECTION_RECV);
+
+    const unsigned long long UDP_bytes_sent1 = tox_netprof_get_packet_total_bytes(tox1, TOX_NETPROF_PACKET_TYPE_UDP,
+            TOX_NETPROF_DIRECTION_SENT);
+    const unsigned long long UDP_bytes_recv1 = tox_netprof_get_packet_total_bytes(tox1, TOX_NETPROF_PACKET_TYPE_UDP,
+            TOX_NETPROF_DIRECTION_RECV);
+    const unsigned long long TCP_bytes_sent1 = tox_netprof_get_packet_total_bytes(tox1, TOX_NETPROF_PACKET_TYPE_TCP,
+            TOX_NETPROF_DIRECTION_SENT);
+    const unsigned long long TCP_bytes_recv1 = tox_netprof_get_packet_total_bytes(tox1, TOX_NETPROF_PACKET_TYPE_TCP,
+            TOX_NETPROF_DIRECTION_RECV);
+
+    ck_assert(UDP_count_recv1 > 0 && UDP_count_sent1 > 0);
+    ck_assert(UDP_bytes_recv1 > 0 && UDP_bytes_sent1 > 0);
+
+    (void)TCP_count_sent1;
+    (void)TCP_bytes_sent1;
+    (void)TCP_bytes_recv1;
+    (void)TCP_count_recv1;
+
+    unsigned long long total_sent_count = 0;
+    unsigned long long total_recv_count = 0;
+    unsigned long long total_sent_bytes = 0;
+    unsigned long long total_recv_bytes = 0;
+
+    // tox1 makes sure the sum value of all packet ID's is equal to the totals
+    for (size_t i = 0; i < 256; ++i) {
+        // this id isn't valid for UDP packets but we still want to call the
+        // functions and make sure they return some non-zero value
+        if (i == TOX_NETPROF_PACKET_ID_TCP_DATA) {
+            ck_assert(tox_netprof_get_packet_id_count(tox1, TOX_NETPROF_PACKET_TYPE_UDP, i,
+                      TOX_NETPROF_DIRECTION_SENT) > 0);
+            ck_assert(tox_netprof_get_packet_id_bytes(tox1, TOX_NETPROF_PACKET_TYPE_UDP, i,
+                      TOX_NETPROF_DIRECTION_SENT) > 0);
+            ck_assert(tox_netprof_get_packet_id_bytes(tox1, TOX_NETPROF_PACKET_TYPE_UDP, i,
+                      TOX_NETPROF_DIRECTION_SENT) > 0);
+            ck_assert(tox_netprof_get_packet_id_bytes(tox1, TOX_NETPROF_PACKET_TYPE_UDP, i,
+                      TOX_NETPROF_DIRECTION_RECV) > 0);
+            continue;
+        }
+
+        total_sent_count += tox_netprof_get_packet_id_count(tox1, TOX_NETPROF_PACKET_TYPE_UDP, i,
+                            TOX_NETPROF_DIRECTION_SENT);
+        total_recv_count += tox_netprof_get_packet_id_count(tox1, TOX_NETPROF_PACKET_TYPE_UDP, i,
+                            TOX_NETPROF_DIRECTION_RECV);
+
+        total_sent_bytes += tox_netprof_get_packet_id_bytes(tox1, TOX_NETPROF_PACKET_TYPE_UDP, i,
+                            TOX_NETPROF_DIRECTION_SENT);
+        total_recv_bytes += tox_netprof_get_packet_id_bytes(tox1, TOX_NETPROF_PACKET_TYPE_UDP, i,
+                            TOX_NETPROF_DIRECTION_RECV);
+    }
+
+    const unsigned long long total_packets = total_sent_count + total_recv_count;
+    ck_assert_msg(total_packets == UDP_count_sent1 + UDP_count_recv1,
+                  "%llu does not match %llu\n", total_packets, UDP_count_sent1 + UDP_count_recv1);
+
+    ck_assert_msg(total_sent_count == UDP_count_sent1, "%llu does not match %llu\n", total_sent_count, UDP_count_sent1);
+    ck_assert_msg(total_recv_count == UDP_count_recv1, "%llu does not match %llu\n", total_recv_count, UDP_count_recv1);
+
+
+    const unsigned long long total_bytes = total_sent_bytes + total_recv_bytes;
+    ck_assert_msg(total_bytes == UDP_bytes_sent1 + UDP_bytes_recv1,
+                  "%llu does not match %llu\n", total_bytes, UDP_bytes_sent1 + UDP_bytes_recv1);
+
+    ck_assert_msg(total_sent_bytes == UDP_bytes_sent1, "%llu does not match %llu\n", total_sent_bytes, UDP_bytes_sent1);
+    ck_assert_msg(total_recv_bytes == UDP_bytes_recv1, "%llu does not match %llu\n", total_recv_bytes, UDP_bytes_recv1);
+}
+
+int main(void)
+{
+    setvbuf(stdout, nullptr, _IONBF, 0);
+
+    Run_Auto_Options autotox_opts = default_run_auto_options();
+    autotox_opts.graph = GRAPH_COMPLETE;
+
+    run_auto_test(nullptr, NUM_TOXES, test_netprof, 0, &autotox_opts);
+
+    return 0;
+}
+
+#undef NUM_TOXES

external/toxcore/c-toxcore/auto_tests/onion_test.c

@@ -202,7 +202,7 @@ static int handle_test_4(void *object, const IP_Port *source, const uint8_t *pac
  * Use Onion_Path path to send data of length to dest.
  * Maximum length of data is ONION_MAX_DATA_SIZE.
  */
-static void send_onion_packet(const Networking_Core *net, const Random *rng, const Onion_Path *path, const IP_Port *dest, const uint8_t *data, uint16_t length)
+static void send_onion_packet(Networking_Core *net, const Random *rng, const Onion_Path *path, const IP_Port *dest, const uint8_t *data, uint16_t length)
 {
     uint8_t packet[ONION_MAX_PACKET_SIZE];
     const int len = create_onion_packet(rng, packet, sizeof(packet), path, dest, data, length);

external/toxcore/c-toxcore/other/bootstrap_node_packets.c

@@ -30,7 +30,7 @@ static int handle_info_request(void *object, const IP_Port *source, const uint8_
         return 1;
     }
 
-    const Networking_Core *nc = (const Networking_Core *)object;
+    Networking_Core *nc = (Networking_Core *)object;
 
     uint8_t data[1 + sizeof(bootstrap_version) + MAX_MOTD_LENGTH];
     data[0] = BOOTSTRAP_INFO_PACKET_ID;

external/toxcore/c-toxcore/toxcore/BUILD.bazel

@@ -299,6 +299,16 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "net_profile",
+    srcs = ["net_profile.c"],
+    hdrs = ["net_profile.h"],
+    deps = [
+        ":attributes",
+        ":ccompat",
+    ],
+)
+
 cc_library(
     name = "network",
     srcs = ["network.c"],
@@ -318,6 +328,7 @@ cc_library(
         ":logger",
         ":mem",
         ":mono_time",
+        ":net_profile",
         ":util",
         "@libsodium",
         "@psocket",
@@ -570,6 +581,7 @@ cc_library(
         ":crypto_core",
         ":logger",
         ":mem",
+        ":net_profile",
         ":network",
     ],
 )
@@ -597,6 +609,7 @@ cc_library(
         ":logger",
         ":mem",
         ":mono_time",
+        ":net_profile",
         ":network",
         ":onion",
         ":util",
@@ -618,6 +631,7 @@ cc_library(
         ":logger",
         ":mem",
         ":mono_time",
+        ":net_profile",
         ":network",
         ":util",
     ],
@@ -640,6 +654,7 @@ cc_library(
         ":logger",
         ":mem",
         ":mono_time",
+        ":net_profile",
         ":network",
         ":onion",
         ":util",
@@ -674,6 +689,7 @@ cc_library(
         ":logger",
         ":mem",
         ":mono_time",
+        ":net_profile",
         ":network",
         ":util",
         "@pthread",
@@ -993,6 +1009,7 @@ cc_library(
         ":DHT",
         ":Messenger",
         ":TCP_client",
+        ":TCP_server",
         ":attributes",
         ":ccompat",
         ":crypto_core",
@@ -1003,6 +1020,7 @@ cc_library(
         ":mem",
         ":mono_time",
         ":net_crypto",
+        ":net_profile",
         ":network",
         ":onion_client",
         ":state",

external/toxcore/c-toxcore/toxcore/LAN_discovery.c

@@ -210,7 +210,7 @@ static Broadcast_Info *fetch_broadcast_info(const Network *ns)
  * @retval false on failure to find any valid broadcast target.
  */
 non_null()
-static bool send_broadcasts(const Networking_Core *net, const Broadcast_Info *broadcast, uint16_t port,
+static bool send_broadcasts(Networking_Core *net, const Broadcast_Info *broadcast, uint16_t port,
                             const uint8_t *data, uint16_t length)
 {
     if (broadcast->count == 0) {
@@ -339,7 +339,7 @@ bool ip_is_lan(const IP *ip)
     return false;
 }
 
-bool lan_discovery_send(const Networking_Core *net, const Broadcast_Info *broadcast, const uint8_t *dht_pk,
+bool lan_discovery_send(Networking_Core *net, const Broadcast_Info *broadcast, const uint8_t *dht_pk,
                         uint16_t port)
 {
     if (broadcast == nullptr) {

external/toxcore/c-toxcore/toxcore/LAN_discovery.h

@@ -25,7 +25,7 @@ typedef struct Broadcast_Info Broadcast_Info;
  * @return true on success, false on failure.
  */
 non_null()
-bool lan_discovery_send(const Networking_Core *net, const Broadcast_Info *broadcast, const uint8_t *dht_pk,
+bool lan_discovery_send(Networking_Core *net, const Broadcast_Info *broadcast, const uint8_t *dht_pk,
                         uint16_t port);
 
 /**

external/toxcore/c-toxcore/toxcore/Makefile.inc

@@ -74,6 +74,8 @@ libtoxcore_la_SOURCES = ../third_party/cmp/cmp.c \
                         ../toxcore/ping_array.c \
                         ../toxcore/net_crypto.h \
                         ../toxcore/net_crypto.c \
+                        ../toxcore/net_profile.c \
+                        ../toxcore/net_profile.h \
                         ../toxcore/friend_requests.h \
                         ../toxcore/friend_requests.c \
                         ../toxcore/LAN_discovery.h \

external/toxcore/c-toxcore/toxcore/TCP_client.c

@@ -20,6 +20,7 @@
 #include "logger.h"
 #include "mem.h"
 #include "mono_time.h"
+#include "net_profile.h"
 #include "network.h"
 #include "util.h"
 
@@ -582,7 +583,7 @@ void forwarding_handler(TCP_Client_Connection *con, forwarded_response_cb *forwa
 TCP_Client_Connection *new_tcp_connection(
     const Logger *logger, const Memory *mem, const Mono_Time *mono_time, const Random *rng, const Network *ns,
     const IP_Port *ip_port, const uint8_t *public_key, const uint8_t *self_public_key, const uint8_t *self_secret_key,
-    const TCP_Proxy_Info *proxy_info)
+    const TCP_Proxy_Info *proxy_info, Net_Profile *net_profile)
 {
     assert(logger != nullptr);
     assert(mem != nullptr);
@@ -634,6 +635,7 @@ TCP_Client_Connection *new_tcp_connection(
     temp->con.rng = rng;
     temp->con.sock = sock;
     temp->con.ip_port = *ip_port;
+    temp->con.net_profile = net_profile;
     memcpy(temp->public_key, public_key, CRYPTO_PUBLIC_KEY_SIZE);
     memcpy(temp->self_public_key, self_public_key, CRYPTO_PUBLIC_KEY_SIZE);
     encrypt_precompute(temp->public_key, self_secret_key, temp->con.shared_key);
@@ -819,6 +821,8 @@ static int handle_tcp_client_packet(const Logger *logger, TCP_Client_Connection
         return -1;
     }
 
+    netprof_record_packet(conn->con.net_profile, data[0], length, PACKET_DIRECTION_RECV);
+
     switch (data[0]) {
         case TCP_PACKET_ROUTING_RESPONSE:
             return handle_tcp_client_routing_response(conn, data, length);

external/toxcore/c-toxcore/toxcore/TCP_client.h

@@ -15,6 +15,7 @@
 #include "logger.h"
 #include "mem.h"
 #include "mono_time.h"
+#include "net_profile.h"
 #include "network.h"
 
 #define TCP_CONNECTION_TIMEOUT 10
@@ -60,11 +61,11 @@ non_null()
 void tcp_con_set_custom_uint(TCP_Client_Connection *con, uint32_t value);
 
 /** Create new TCP connection to ip_port/public_key */
-non_null(1, 2, 3, 4, 5, 6, 7, 8, 9) nullable(10)
+non_null(1, 2, 3, 4, 5, 6, 7, 8, 9) nullable(10, 11)
 TCP_Client_Connection *new_tcp_connection(
     const Logger *logger, const Memory *mem, const Mono_Time *mono_time, const Random *rng, const Network *ns,
     const IP_Port *ip_port, const uint8_t *public_key, const uint8_t *self_public_key, const uint8_t *self_secret_key,
-    const TCP_Proxy_Info *proxy_info);
+    const TCP_Proxy_Info *proxy_info, Net_Profile *net_profile);
 
 /** Run the TCP connection */
 non_null(1, 2, 3) nullable(4)

external/toxcore/c-toxcore/toxcore/TCP_common.c

@@ -35,7 +35,8 @@ int send_pending_data_nonpriority(const Logger *logger, TCP_Connection *con)
     }
 
     const uint16_t left = con->last_packet_length - con->last_packet_sent;
-    const int len = net_send(con->ns, logger, con->sock, con->last_packet + con->last_packet_sent, left, &con->ip_port);
+    const int len = net_send(con->ns, logger, con->sock, con->last_packet + con->last_packet_sent, left, &con->ip_port,
+                             con->net_profile);
 
     if (len <= 0) {
         return -1;
@@ -66,7 +67,7 @@ int send_pending_data(const Logger *logger, TCP_Connection *con)
 
     while (p != nullptr) {
         const uint16_t left = p->size - p->sent;
-        const int len = net_send(con->ns, logger, con->sock, p->data + p->sent, left, &con->ip_port);
+        const int len = net_send(con->ns, logger, con->sock, p->data + p->sent, left, &con->ip_port, con->net_profile);
 
         if (len != left) {
             if (len > 0) {
@@ -164,7 +165,8 @@ int write_packet_tcp_secure_connection(const Logger *logger, TCP_Connection *con
     }
 
     if (priority) {
-        len = sendpriority ? net_send(con->ns, logger, con->sock, packet, packet_size, &con->ip_port) : 0;
+        len = sendpriority ? net_send(con->ns, logger, con->sock, packet, packet_size, &con->ip_port,
+                                      con->net_profile) : 0;
 
         if (len <= 0) {
             len = 0;
@@ -179,7 +181,7 @@ int write_packet_tcp_secure_connection(const Logger *logger, TCP_Connection *con
         return add_priority(con, packet, packet_size, len) ? 1 : 0;
     }
 
-    len = net_send(con->ns, logger, con->sock, packet, packet_size, &con->ip_port);
+    len = net_send(con->ns, logger, con->sock, packet, packet_size, &con->ip_port, con->net_profile);
 
     if (len <= 0) {
         return 0;

external/toxcore/c-toxcore/toxcore/TCP_common.h

@@ -10,6 +10,7 @@
 #include "crypto_core.h"
 #include "logger.h"
 #include "mem.h"
+#include "net_profile.h"
 #include "network.h"
 
 typedef struct TCP_Priority_List TCP_Priority_List;
@@ -66,6 +67,10 @@ typedef struct TCP_Connection {
 
     TCP_Priority_List *priority_queue_start;
     TCP_Priority_List *priority_queue_end;
+
+    // This is a shared pointer to the parent's respective Net_Profile object
+    // (either TCP_Server for TCP server packets or TCP_Connections for TCP client packets).
+    Net_Profile *net_profile;
 } TCP_Connection;
 
 /**

external/toxcore/c-toxcore/toxcore/TCP_connection.c

@@ -20,6 +20,7 @@
 #include "logger.h"
 #include "mem.h"
 #include "mono_time.h"
+#include "net_profile.h"
 #include "network.h"
 #include "util.h"
 
@@ -56,6 +57,9 @@ struct TCP_Connections {
 
     bool onion_status;
     uint16_t onion_num_conns;
+
+    /* Network profile for all TCP client packets. */
+    Net_Profile net_profile;
 };
 
 static const TCP_Connection_to empty_tcp_connection_to = {0};
@@ -928,7 +932,8 @@ static int reconnect_tcp_relay_connection(TCP_Connections *tcp_c, int tcp_connec
     uint8_t relay_pk[CRYPTO_PUBLIC_KEY_SIZE];
     memcpy(relay_pk, tcp_con_public_key(tcp_con->connection), CRYPTO_PUBLIC_KEY_SIZE);
     kill_tcp_connection(tcp_con->connection);
-    tcp_con->connection = new_tcp_connection(tcp_c->logger, tcp_c->mem, tcp_c->mono_time, tcp_c->rng, tcp_c->ns, &ip_port, relay_pk, tcp_c->self_public_key, tcp_c->self_secret_key, &tcp_c->proxy_info);
+    tcp_con->connection = new_tcp_connection(tcp_c->logger, tcp_c->mem, tcp_c->mono_time, tcp_c->rng, tcp_c->ns, &ip_port, relay_pk, tcp_c->self_public_key, tcp_c->self_secret_key, &tcp_c->proxy_info,
+                          &tcp_c->net_profile);
 
     if (tcp_con->connection == nullptr) {
         kill_tcp_relay_connection(tcp_c, tcp_connections_number);
@@ -1017,7 +1022,7 @@ static int unsleep_tcp_relay_connection(TCP_Connections *tcp_c, int tcp_connecti
 
     tcp_con->connection = new_tcp_connection(
                               tcp_c->logger, tcp_c->mem, tcp_c->mono_time, tcp_c->rng, tcp_c->ns, &tcp_con->ip_port,
-                              tcp_con->relay_pk, tcp_c->self_public_key, tcp_c->self_secret_key, &tcp_c->proxy_info);
+                              tcp_con->relay_pk, tcp_c->self_public_key, tcp_c->self_secret_key, &tcp_c->proxy_info, &tcp_c->net_profile);
 
     if (tcp_con->connection == nullptr) {
         kill_tcp_relay_connection(tcp_c, tcp_connections_number);
@@ -1315,7 +1320,7 @@ static int add_tcp_relay_instance(TCP_Connections *tcp_c, const IP_Port *ip_port
 
     tcp_con->connection = new_tcp_connection(
                               tcp_c->logger, tcp_c->mem, tcp_c->mono_time, tcp_c->rng, tcp_c->ns, &ipp_copy,
-                              relay_pk, tcp_c->self_public_key, tcp_c->self_secret_key, &tcp_c->proxy_info);
+                              relay_pk, tcp_c->self_public_key, tcp_c->self_secret_key, &tcp_c->proxy_info, &tcp_c->net_profile);
 
     if (tcp_con->connection == nullptr) {
         return -1;
@@ -1727,3 +1732,12 @@ void kill_tcp_connections(TCP_Connections *tcp_c)
     mem_delete(tcp_c->mem, tcp_c->connections);
     mem_delete(tcp_c->mem, tcp_c);
 }
+
+const Net_Profile *tcp_connection_get_client_net_profile(const TCP_Connections *tcp_c)
+{
+    if (tcp_c == nullptr) {
+        return nullptr;
+    }
+
+    return &tcp_c->net_profile;
+}

external/toxcore/c-toxcore/toxcore/TCP_connection.h

@@ -21,6 +21,7 @@
 #include "logger.h"
 #include "mem.h"
 #include "mono_time.h"
+#include "net_profile.h"
 #include "network.h"
 
 #define TCP_CONN_NONE 0
@@ -317,4 +318,11 @@ void do_tcp_connections(const Logger *logger, TCP_Connections *tcp_c, void *user
 nullable(1)
 void kill_tcp_connections(TCP_Connections *tcp_c);
 
+/** @brief a pointer to the tcp client net profile associated with tcp_c.
+ *
+ * @retval null if tcp_c is null.
+ */
+non_null()
+const Net_Profile *tcp_connection_get_client_net_profile(const TCP_Connections *tcp_c);
+
 #endif /* C_TOXCORE_TOXCORE_TCP_CONNECTION_H */

external/toxcore/c-toxcore/toxcore/TCP_server.c

@@ -27,6 +27,7 @@
 #include "logger.h"
 #include "mem.h"
 #include "mono_time.h"
+#include "net_profile.h"
 #include "network.h"
 #include "onion.h"
 
@@ -91,6 +92,9 @@ struct TCP_Server {
     uint64_t counter;
 
     BS_List accepted_key_list;
+
+    /* Network profile for all TCP server packets. */
+    Net_Profile net_profile;
 };
 
 static_assert(sizeof(TCP_Server) < 7 * 1024 * 1024,
@@ -236,6 +240,7 @@ static int add_accepted(TCP_Server *tcp_server, const Mono_Time *mono_time, TCP_
     tcp_server->accepted_connection_array[index].identifier = ++tcp_server->counter;
     tcp_server->accepted_connection_array[index].last_pinged = mono_time_get(mono_time);
     tcp_server->accepted_connection_array[index].ping_id = 0;
+    tcp_server->accepted_connection_array[index].con.net_profile = &tcp_server->net_profile;
 
     return index;
 }
@@ -357,7 +362,7 @@ static int handle_tcp_handshake(const Logger *logger, TCP_Secure_Connection *con
 
     const IP_Port ipp = {{{0}}};
 
-    if (TCP_SERVER_HANDSHAKE_SIZE != net_send(con->con.ns, logger, con->con.sock, response, TCP_SERVER_HANDSHAKE_SIZE, &ipp)) {
+    if (TCP_SERVER_HANDSHAKE_SIZE != net_send(con->con.ns, logger, con->con.sock, response, TCP_SERVER_HANDSHAKE_SIZE, &ipp, con->con.net_profile)) {
         crypto_memzero(shared_key, sizeof(shared_key));
         return -1;
     }
@@ -680,6 +685,7 @@ static int handle_tcp_packet(TCP_Server *tcp_server, uint32_t con_id, const uint
     }
 
     TCP_Secure_Connection *const con = &tcp_server->accepted_connection_array[con_id];
+    netprof_record_packet(con->con.net_profile, data[0], length, PACKET_DIRECTION_RECV);
 
     switch (data[0]) {
         case TCP_PACKET_ROUTING_REQUEST: {
@@ -1425,3 +1431,12 @@ void kill_tcp_server(TCP_Server *tcp_server)
     mem_delete(tcp_server->mem, tcp_server->socks_listening);
     mem_delete(tcp_server->mem, tcp_server);
 }
+
+const Net_Profile *tcp_server_get_net_profile(const TCP_Server *tcp_server)
+{
+    if (tcp_server == nullptr) {
+        return nullptr;
+    }
+
+    return &tcp_server->net_profile;
+}

external/toxcore/c-toxcore/toxcore/TCP_server.h

@@ -15,6 +15,7 @@
 #include "logger.h"
 #include "mem.h"
 #include "mono_time.h"
+#include "net_profile.h"
 #include "network.h"
 #include "onion.h"
 
@@ -52,4 +53,11 @@ void do_tcp_server(TCP_Server *tcp_server, const Mono_Time *mono_time);
 nullable(1)
 void kill_tcp_server(TCP_Server *tcp_server);
 
+/** @brief Returns a pointer to the net profile associated with `tcp_server`.
+ *
+ * Returns null if `tcp_server` is null.
+ */
+nullable(1)
+const Net_Profile *tcp_server_get_net_profile(const TCP_Server *tcp_server);
+
 #endif /* C_TOXCORE_TOXCORE_TCP_SERVER_H */

external/toxcore/c-toxcore/toxcore/forwarding.c

@@ -43,7 +43,7 @@ DHT *forwarding_get_dht(const Forwarding *forwarding)
 
 #define SENDBACK_TIMEOUT 3600
 
-bool send_forward_request(const Networking_Core *net, const IP_Port *forwarder,
+bool send_forward_request(Networking_Core *net, const IP_Port *forwarder,
                           const uint8_t *chain_keys, uint16_t chain_length,
                           const uint8_t *data, uint16_t data_length)
 {
@@ -321,7 +321,7 @@ static int handle_forwarding(void *object, const IP_Port *source, const uint8_t
     }
 }
 
-bool forward_reply(const Networking_Core *net, const IP_Port *forwarder,
+bool forward_reply(Networking_Core *net, const IP_Port *forwarder,
                    const uint8_t *sendback, uint16_t sendback_length,
                    const uint8_t *data, uint16_t length)
 {

external/toxcore/c-toxcore/toxcore/forwarding.h

@@ -45,7 +45,7 @@ DHT *forwarding_get_dht(const Forwarding *forwarding);
  * @return true on success, false otherwise.
  */
 non_null()
-bool send_forward_request(const Networking_Core *net, const IP_Port *forwarder,
+bool send_forward_request(Networking_Core *net, const IP_Port *forwarder,
                           const uint8_t *chain_keys, uint16_t chain_length,
                           const uint8_t *data, uint16_t data_length);
 
@@ -79,7 +79,7 @@ bool create_forward_chain_packet(const uint8_t *chain_keys, uint16_t chain_lengt
  * @return true on success, false otherwise.
  */
 non_null()
-bool forward_reply(const Networking_Core *net, const IP_Port *forwarder,
+bool forward_reply(Networking_Core *net, const IP_Port *forwarder,
                    const uint8_t *sendback, uint16_t sendback_length,
                    const uint8_t *data, uint16_t length);
 

external/toxcore/c-toxcore/toxcore/net_crypto.c

@@ -23,6 +23,7 @@
 #include "logger.h"
 #include "mem.h"
 #include "mono_time.h"
+#include "net_profile.h"
 #include "network.h"
 #include "util.h"
 
@@ -3227,3 +3228,18 @@ void kill_net_crypto(Net_Crypto *c)
     crypto_memzero(c, sizeof(Net_Crypto));
     mem_delete(mem, c);
 }
+
+const Net_Profile *nc_get_tcp_client_net_profile(const Net_Crypto *c)
+{
+    if (c == nullptr) {
+        return nullptr;
+    }
+
+    const TCP_Connections *tcp_c = nc_get_tcp_c(c);
+
+    if (tcp_c == nullptr) {
+        return nullptr;
+    }
+
+    return tcp_connection_get_client_net_profile(tcp_c);
+}

external/toxcore/c-toxcore/toxcore/net_crypto.h

@@ -20,6 +20,7 @@
 #include "logger.h"
 #include "mem.h"
 #include "mono_time.h"
+#include "net_profile.h"
 #include "network.h"
 
 /*** Crypto payloads. */
@@ -418,4 +419,11 @@ void do_net_crypto(Net_Crypto *c, void *userdata);
 nullable(1)
 void kill_net_crypto(Net_Crypto *c);
 
+/**
+ * Returns a pointer to the net profile object for the TCP client associated with `c`.
+ * Returns null if `c` is null or the TCP_Connections associated with `c` is null.
+ */
+non_null()
+const Net_Profile *nc_get_tcp_client_net_profile(const Net_Crypto *c);
+
 #endif /* C_TOXCORE_TOXCORE_NET_CRYPTO_H */

external/toxcore/c-toxcore/toxcore/net_profile.c

@@ -0,0 +1,121 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later
+ * Copyright © 2023 The TokTok team.
+ */
+
+/**
+ * Functions for the network profile.
+ */
+
+#include "net_profile.h"
+
+#include <stdint.h>
+
+#include "attributes.h"
+#include "ccompat.h"
+
+#define NETPROF_TCP_DATA_PACKET_ID 0x10
+
+/** Returns the number of sent or received packets for all ID's between `start_id` and `end_id`. */
+nullable(1)
+static uint64_t netprof_get_packet_count_id_range(const Net_Profile *profile, uint8_t start_id, uint8_t end_id,
+        Packet_Direction dir)
+{
+    if (profile == nullptr) {
+        return 0;
+    }
+
+    const uint64_t *arr = dir == PACKET_DIRECTION_SENT ? profile->packets_sent : profile->packets_recv;
+    uint64_t count = 0;
+
+    for (size_t i = start_id; i <= end_id; ++i) {
+        count += arr[i];
+    }
+
+    return count;
+}
+
+/** Returns the number of sent or received bytes for all ID's between `start_id` and `end_id`. */
+nullable(1)
+static uint64_t netprof_get_bytes_id_range(const Net_Profile *profile, uint8_t start_id, uint8_t end_id,
+        Packet_Direction dir)
+{
+    if (profile == nullptr) {
+        return 0;
+    }
+
+    const uint64_t *arr = dir == PACKET_DIRECTION_SENT ? profile->bytes_sent : profile->bytes_recv;
+    uint64_t bytes = 0;
+
+    for (size_t i = start_id; i <= end_id; ++i) {
+        bytes += arr[i];
+    }
+
+    return bytes;
+}
+
+void netprof_record_packet(Net_Profile *profile, uint8_t id, size_t length, Packet_Direction dir)
+{
+    if (profile == nullptr) {
+        return;
+    }
+
+    if (dir == PACKET_DIRECTION_SENT) {
+        ++profile->total_packets_sent;
+        ++profile->packets_sent[id];
+
+        profile->total_bytes_sent += length;
+        profile->bytes_sent[id] += length;
+    } else {
+        ++profile->total_packets_recv;
+        ++profile->packets_recv[id];
+
+        profile->total_bytes_recv += length;
+        profile->bytes_recv[id] += length;
+    }
+}
+
+uint64_t netprof_get_packet_count_id(const Net_Profile *profile, uint8_t id, Packet_Direction dir)
+{
+    if (profile == nullptr) {
+        return 0;
+    }
+
+    // Special case - TCP data packets can have any ID between 0x10 and 0xff
+    if (id == NETPROF_TCP_DATA_PACKET_ID) {
+        return netprof_get_packet_count_id_range(profile, id, UINT8_MAX, dir);
+    }
+
+    return dir == PACKET_DIRECTION_SENT ? profile->packets_sent[id] : profile->packets_recv[id];
+}
+
+uint64_t netprof_get_packet_count_total(const Net_Profile *profile, Packet_Direction dir)
+{
+    if (profile == nullptr) {
+        return 0;
+    }
+
+    return dir == PACKET_DIRECTION_SENT ? profile->total_packets_sent : profile->total_packets_recv;
+}
+
+uint64_t netprof_get_bytes_id(const Net_Profile *profile, uint8_t id, Packet_Direction dir)
+{
+    if (profile == nullptr) {
+        return 0;
+    }
+
+    // Special case - TCP data packets can have any ID between 0x10 and 0xff
+    if (id == NETPROF_TCP_DATA_PACKET_ID) {
+        return netprof_get_bytes_id_range(profile, id, 0xff, dir);
+    }
+
+    return dir == PACKET_DIRECTION_SENT ? profile->bytes_sent[id] : profile->bytes_recv[id];
+}
+
+uint64_t netprof_get_bytes_total(const Net_Profile *profile, Packet_Direction dir)
+{
+    if (profile == nullptr) {
+        return 0;
+    }
+
+    return dir == PACKET_DIRECTION_SENT ? profile->total_bytes_sent : profile->total_bytes_recv;
+}

external/toxcore/c-toxcore/toxcore/net_profile.h

@@ -0,0 +1,69 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later
+ * Copyright © 2023 The TokTok team.
+ */
+
+/**
+ * Functions for the network profile.
+ */
+#ifndef C_TOXCORE_TOXCORE_NET_PROFILE_H
+#define C_TOXCORE_TOXCORE_NET_PROFILE_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "attributes.h"
+
+/* The max number of packet ID's (must fit inside one byte) */
+#define NET_PROF_MAX_PACKET_IDS 256
+
+typedef struct Net_Profile {
+    uint64_t packets_recv[NET_PROF_MAX_PACKET_IDS];
+    uint64_t packets_sent[NET_PROF_MAX_PACKET_IDS];
+
+    uint64_t total_packets_recv;
+    uint64_t total_packets_sent;
+
+    uint64_t bytes_recv[NET_PROF_MAX_PACKET_IDS];
+    uint64_t bytes_sent[NET_PROF_MAX_PACKET_IDS];
+
+    uint64_t total_bytes_recv;
+    uint64_t total_bytes_sent;
+} Net_Profile;
+
+/** Specifies whether the query is for sent or received packets. */
+typedef enum Packet_Direction {
+    PACKET_DIRECTION_SENT,
+    PACKET_DIRECTION_RECV,
+} Packet_Direction;
+
+/**
+ * Records a sent or received packet of type `id` and size `length` to the given profile.
+ */
+nullable(1)
+void netprof_record_packet(Net_Profile *profile, uint8_t id, size_t length, Packet_Direction dir);
+
+/**
+ * Returns the number of sent or received packets of type `id` for the given profile.
+ */
+nullable(1)
+uint64_t netprof_get_packet_count_id(const Net_Profile *profile, uint8_t id, Packet_Direction dir);
+
+/**
+ * Returns the total number of sent or received packets for the given profile.
+ */
+nullable(1)
+uint64_t netprof_get_packet_count_total(const Net_Profile *profile, Packet_Direction dir);
+
+/**
+ * Returns the number of bytes sent or received of packet type `id` for the given profile.
+ */
+nullable(1)
+uint64_t netprof_get_bytes_id(const Net_Profile *profile, uint8_t id, Packet_Direction dir);
+
+/**
+ * Returns the total number of bytes sent or received for the given profile.
+ */
+nullable(1)
+uint64_t netprof_get_bytes_total(const Net_Profile *profile, Packet_Direction dir);
+
+#endif  /* C_TOXCORE_TOXCORE_NET_PROFILE_H */

external/toxcore/c-toxcore/toxcore/network.c

@@ -86,6 +86,7 @@
 #include "ccompat.h"
 #include "logger.h"
 #include "mem.h"
+#include "net_profile.h"
 #include "util.h"
 
 // Disable MSG_NOSIGNAL on systems not supporting it, e.g. Windows, FreeBSD
@@ -812,9 +813,15 @@ static void loglogdata(const Logger *log, const char *message, const uint8_t *bu
 }
 
 int net_send(const Network *ns, const Logger *log,
-             Socket sock, const uint8_t *buf, size_t len, const IP_Port *ip_port)
+             Socket sock, const uint8_t *buf, size_t len, const IP_Port *ip_port, Net_Profile *net_profile)
 {
     const int res = ns->funcs->send(ns->obj, sock, buf, len);
+
+    if (buf != nullptr && res == len) {
+        const uint8_t *data = buf;
+        netprof_record_packet(net_profile, data[0], len, PACKET_DIRECTION_SENT);
+    }
+
     loglogdata(log, "T=>", buf, len, ip_port, res);
     return res;
 }
@@ -914,6 +921,8 @@ struct Networking_Core {
     uint16_t port;
     /* Our UDP socket. */
     Socket sock;
+
+    Net_Profile udp_net_profile;
 };
 
 Family net_family(const Networking_Core *net)
@@ -929,7 +938,7 @@ uint16_t net_port(const Networking_Core *net)
 /* Basic network functions:
  */
 
-int send_packet(const Networking_Core *net, const IP_Port *ip_port, Packet packet)
+int send_packet(Networking_Core *net, const IP_Port *ip_port, Packet packet)
 {
     IP_Port ipp_copy = *ip_port;
 
@@ -999,6 +1008,11 @@ int send_packet(const Networking_Core *net, const IP_Port *ip_port, Packet packe
     loglogdata(net->log, "O=>", packet.data, packet.length, ip_port, res);
 
     assert(res <= INT_MAX);
+
+    if (res == packet.length) {
+        netprof_record_packet(&net->udp_net_profile, packet.data[0], packet.length, PACKET_DIRECTION_SENT);
+    }
+
     return (int)res;
 }
 
@@ -1007,7 +1021,7 @@ int send_packet(const Networking_Core *net, const IP_Port *ip_port, Packet packe
  *
  * @deprecated Use send_packet instead.
  */
-int sendpacket(const Networking_Core *net, const IP_Port *ip_port, const uint8_t *data, uint16_t length)
+int sendpacket(Networking_Core *net, const IP_Port *ip_port, const uint8_t *data, uint16_t length)
 {
     const Packet packet = {data, length};
     return send_packet(net, ip_port, packet);
@@ -1087,7 +1101,7 @@ void networking_registerhandler(Networking_Core *net, uint8_t byte, packet_handl
     net->packethandlers[byte].object = object;
 }
 
-void networking_poll(const Networking_Core *net, void *userdata)
+void networking_poll(Networking_Core *net, void *userdata)
 {
     if (net_family_is_unspec(net->family)) {
         /* Socket not initialized */
@@ -1103,6 +1117,8 @@ void networking_poll(const Networking_Core *net, void *userdata)
             continue;
         }
 
+        netprof_record_packet(&net->udp_net_profile, data[0], length, PACKET_DIRECTION_RECV);
+
         const Packet_Handler *const handler = &net->packethandlers[data[0]];
 
         if (handler->function == nullptr) {
@@ -2296,3 +2312,12 @@ void net_kill_strerror(char *strerror)
     free(strerror);
 #endif /* OS_WIN32 */
 }
+
+const Net_Profile *net_get_net_profile(const Networking_Core *net)
+{
+    if (net == nullptr) {
+        return nullptr;
+    }
+
+    return &net->udp_net_profile;
+}

external/toxcore/c-toxcore/toxcore/network.h

@@ -17,6 +17,7 @@
 #include "bin_pack.h"
 #include "logger.h"
 #include "mem.h"
+#include "net_profile.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -234,8 +235,9 @@ Socket net_invalid_socket(void);
 /**
  * Calls send(sockfd, buf, len, MSG_NOSIGNAL).
  */
-non_null()
-int net_send(const Network *ns, const Logger *log, Socket sock, const uint8_t *buf, size_t len, const IP_Port *ip_port);
+non_null(1, 2, 4, 6) nullable(7)
+int net_send(const Network *ns, const Logger *log, Socket sock, const uint8_t *buf, size_t len, const IP_Port *ip_port,
+             Net_Profile *net_profile);
 /**
  * Calls recv(sockfd, buf, len, MSG_NOSIGNAL).
  */
@@ -477,7 +479,7 @@ typedef struct Packet {
  * Function to send a network packet to a given IP/port.
  */
 non_null()
-int send_packet(const Networking_Core *net, const IP_Port *ip_port, Packet packet);
+int send_packet(Networking_Core *net, const IP_Port *ip_port, Packet packet);
 
 /**
  * Function to send packet(data) of length length to ip_port.
@@ -485,7 +487,7 @@ int send_packet(const Networking_Core *net, const IP_Port *ip_port, Packet packe
  * @deprecated Use send_packet instead.
  */
 non_null()
-int sendpacket(const Networking_Core *net, const IP_Port *ip_port, const uint8_t *data, uint16_t length);
+int sendpacket(Networking_Core *net, const IP_Port *ip_port, const uint8_t *data, uint16_t length);
 
 /** Function to call when packet beginning with byte is received. */
 non_null(1) nullable(3, 4)
@@ -493,7 +495,7 @@ void networking_registerhandler(Networking_Core *net, uint8_t byte, packet_handl
 
 /** Call this several times a second. */
 non_null(1) nullable(2)
-void networking_poll(const Networking_Core *net, void *userdata);
+void networking_poll(Networking_Core *net, void *userdata);
 
 /** @brief Connect a socket to the address specified by the ip_port.
  *
@@ -603,6 +605,13 @@ Networking_Core *new_networking_no_udp(const Logger *log, const Memory *mem, con
 nullable(1)
 void kill_networking(Networking_Core *net);
 
+/** @brief Returns a pointer to the network net_profile object associated with `net`.
+ *
+ * Returns null if `net` is null.
+ */
+non_null()
+const Net_Profile *net_get_net_profile(const Networking_Core *net);
+
 #ifdef __cplusplus
 } /* extern "C" */
 #endif

external/toxcore/c-toxcore/toxcore/onion.c

@@ -292,7 +292,7 @@ int create_onion_packet_tcp(const Random *rng, uint8_t *packet, uint16_t max_pac
  * return -1 on failure.
  * return 0 on success.
  */
-int send_onion_response(const Logger *log, const Networking_Core *net,
+int send_onion_response(const Logger *log, Networking_Core *net,
                         const IP_Port *dest, const uint8_t *data, uint16_t length,
                         const uint8_t *ret)
 {

external/toxcore/c-toxcore/toxcore/onion.h

@@ -130,7 +130,7 @@ int create_onion_packet_tcp(const Random *rng, uint8_t *packet, uint16_t max_pac
  * return 0 on success.
  */
 non_null()
-int send_onion_response(const Logger *log, const Networking_Core *net,
+int send_onion_response(const Logger *log, Networking_Core *net,
                         const IP_Port *dest, const uint8_t *data, uint16_t length,
                         const uint8_t *ret);
 

external/toxcore/c-toxcore/toxcore/onion_announce.c

@@ -193,7 +193,7 @@ int create_data_request(const Random *rng, uint8_t *packet, uint16_t max_packet_
  * return 0 on success.
  */
 int send_announce_request(
-    const Logger *log, const Networking_Core *net, const Random *rng,
+    const Logger *log, Networking_Core *net, const Random *rng,
     const Onion_Path *path, const Node_format *dest,
     const uint8_t *public_key, const uint8_t *secret_key,
     const uint8_t *ping_id, const uint8_t *client_id,
@@ -238,7 +238,7 @@ int send_announce_request(
  * return 0 on success.
  */
 int send_data_request(
-    const Logger *log, const Networking_Core *net, const Random *rng, const Onion_Path *path, const IP_Port *dest,
+    const Logger *log, Networking_Core *net, const Random *rng, const Onion_Path *path, const IP_Port *dest,
     const uint8_t *public_key, const uint8_t *encrypt_public_key, const uint8_t *nonce,
     const uint8_t *data, uint16_t length)
 {

external/toxcore/c-toxcore/toxcore/onion_announce.h

@@ -101,7 +101,7 @@ int create_data_request(const Random *rng, uint8_t *packet, uint16_t max_packet_
  */
 non_null()
 int send_announce_request(
-    const Logger *log, const Networking_Core *net, const Random *rng,
+    const Logger *log, Networking_Core *net, const Random *rng,
     const Onion_Path *path, const Node_format *dest,
     const uint8_t *public_key, const uint8_t *secret_key,
     const uint8_t *ping_id, const uint8_t *client_id,
@@ -125,7 +125,7 @@ int send_announce_request(
  */
 non_null()
 int send_data_request(
-    const Logger *log, const Networking_Core *net, const Random *rng, const Onion_Path *path, const IP_Port *dest,
+    const Logger *log, Networking_Core *net, const Random *rng, const Onion_Path *path, const IP_Port *dest,
     const uint8_t *public_key, const uint8_t *encrypt_public_key, const uint8_t *nonce,
     const uint8_t *data, uint16_t length);
 

external/toxcore/c-toxcore/toxcore/tox.c

@@ -1,5 +1,5 @@
 /* SPDX-License-Identifier: GPL-3.0-or-later
- * Copyright © 2016-2018 The TokTok team.
+ * Copyright © 2016-2024 The TokTok team.
  * Copyright © 2013 Tox project.
  */
 
@@ -18,6 +18,7 @@
 #include "DHT.h"
 #include "Messenger.h"
 #include "TCP_client.h"
+#include "TCP_server.h"
 #include "attributes.h"
 #include "ccompat.h"
 #include "crypto_core.h"

external/toxcore/c-toxcore/toxcore/tox_private.c

@@ -1,5 +1,5 @@
 /* SPDX-License-Identifier: GPL-3.0-or-later
- * Copyright © 2016-2022 The TokTok team.
+ * Copyright © 2016-2024 The TokTok team.
  * Copyright © 2013 Tox project.
  */
 
@@ -11,13 +11,16 @@
 #include <assert.h>
 
 #include "DHT.h"
+#include "TCP_server.h"
 #include "attributes.h"
 #include "ccompat.h"
 #include "crypto_core.h"
 #include "group_chats.h"
 #include "group_common.h"
+#include "logger.h"
 #include "mem.h"
 #include "net_crypto.h"
+#include "net_profile.h"
 #include "network.h"
 #include "tox.h"
 #include "tox_struct.h"
@@ -226,3 +229,199 @@ bool tox_group_peer_get_ip_address(const Tox *tox, uint32_t group_number, uint32
     SET_ERROR_PARAMETER(error, TOX_ERR_GROUP_PEER_QUERY_OK);
     return true;
 }
+
+uint64_t tox_netprof_get_packet_id_count(const Tox *tox, Tox_Netprof_Packet_Type type, uint8_t id,
+        Tox_Netprof_Direction direction)
+{
+    assert(tox != nullptr);
+
+    tox_lock(tox);
+
+    const Net_Profile *tcp_c_profile = nc_get_tcp_client_net_profile(tox->m->net_crypto);
+    const Net_Profile *tcp_s_profile = tcp_server_get_net_profile(tox->m->tcp_server);
+
+    const Packet_Direction dir = (Packet_Direction) direction;
+
+    uint64_t count = 0;
+
+    switch (type) {
+        case TOX_NETPROF_PACKET_TYPE_TCP_CLIENT: {
+            count = netprof_get_packet_count_id(tcp_c_profile, id, dir);
+            break;
+        }
+
+        case TOX_NETPROF_PACKET_TYPE_TCP_SERVER: {
+            count = netprof_get_packet_count_id(tcp_s_profile, id, dir);
+            break;
+        }
+
+        case TOX_NETPROF_PACKET_TYPE_TCP: {
+            const uint64_t tcp_c_count = netprof_get_packet_count_id(tcp_c_profile, id, dir);
+            const uint64_t tcp_s_count = netprof_get_packet_count_id(tcp_s_profile, id, dir);
+            count = tcp_c_count + tcp_s_count;
+            break;
+        }
+
+        case TOX_NETPROF_PACKET_TYPE_UDP: {
+            const Net_Profile *udp_profile = net_get_net_profile(tox->m->net);
+            count = netprof_get_packet_count_id(udp_profile, id, dir);
+            break;
+        }
+
+        default: {
+            LOGGER_ERROR(tox->m->log, "invalid packet type: %d", type);
+            break;
+        }
+    }
+
+    tox_unlock(tox);
+
+    return count;
+}
+
+uint64_t tox_netprof_get_packet_total_count(const Tox *tox, Tox_Netprof_Packet_Type type,
+        Tox_Netprof_Direction direction)
+{
+    assert(tox != nullptr);
+
+    tox_lock(tox);
+
+    const Net_Profile *tcp_c_profile = nc_get_tcp_client_net_profile(tox->m->net_crypto);
+    const Net_Profile *tcp_s_profile = tcp_server_get_net_profile(tox->m->tcp_server);
+
+    const Packet_Direction dir = (Packet_Direction) direction;
+
+    uint64_t count = 0;
+
+    switch (type) {
+        case TOX_NETPROF_PACKET_TYPE_TCP_CLIENT: {
+            count = netprof_get_packet_count_total(tcp_c_profile, dir);
+            break;
+        }
+
+        case TOX_NETPROF_PACKET_TYPE_TCP_SERVER: {
+            count = netprof_get_packet_count_total(tcp_s_profile, dir);
+            break;
+        }
+
+        case TOX_NETPROF_PACKET_TYPE_TCP: {
+            const uint64_t tcp_c_count = netprof_get_packet_count_total(tcp_c_profile, dir);
+            const uint64_t tcp_s_count = netprof_get_packet_count_total(tcp_s_profile, dir);
+            count = tcp_c_count + tcp_s_count;
+            break;
+        }
+
+        case TOX_NETPROF_PACKET_TYPE_UDP: {
+            const Net_Profile *udp_profile = net_get_net_profile(tox->m->net);
+            count = netprof_get_packet_count_total(udp_profile, dir);
+            break;
+        }
+
+        default: {
+            LOGGER_ERROR(tox->m->log, "invalid packet type: %d", type);
+            break;
+        }
+    }
+
+    tox_unlock(tox);
+
+    return count;
+}
+
+uint64_t tox_netprof_get_packet_id_bytes(const Tox *tox, Tox_Netprof_Packet_Type type, uint8_t id,
+        Tox_Netprof_Direction direction)
+{
+    assert(tox != nullptr);
+
+    tox_lock(tox);
+
+    const Net_Profile *tcp_c_profile = nc_get_tcp_client_net_profile(tox->m->net_crypto);
+    const Net_Profile *tcp_s_profile = tcp_server_get_net_profile(tox->m->tcp_server);
+
+    const Packet_Direction dir = (Packet_Direction) direction;
+
+    uint64_t bytes = 0;
+
+    switch (type) {
+        case TOX_NETPROF_PACKET_TYPE_TCP_CLIENT: {
+            bytes = netprof_get_bytes_id(tcp_c_profile, id, dir);
+            break;
+        }
+
+        case TOX_NETPROF_PACKET_TYPE_TCP_SERVER: {
+            bytes = netprof_get_bytes_id(tcp_s_profile, id, dir);
+            break;
+        }
+
+        case TOX_NETPROF_PACKET_TYPE_TCP: {
+            const uint64_t tcp_c_bytes = netprof_get_bytes_id(tcp_c_profile, id, dir);
+            const uint64_t tcp_s_bytes = netprof_get_bytes_id(tcp_s_profile, id, dir);
+            bytes = tcp_c_bytes + tcp_s_bytes;
+            break;
+        }
+
+        case TOX_NETPROF_PACKET_TYPE_UDP: {
+            const Net_Profile *udp_profile = net_get_net_profile(tox->m->net);
+            bytes = netprof_get_bytes_id(udp_profile, id, dir);
+            break;
+        }
+
+        default: {
+            LOGGER_ERROR(tox->m->log, "invalid packet type: %d", type);
+            break;
+        }
+    }
+
+    tox_unlock(tox);
+
+    return bytes;
+}
+
+uint64_t tox_netprof_get_packet_total_bytes(const Tox *tox, Tox_Netprof_Packet_Type type,
+        Tox_Netprof_Direction direction)
+{
+    assert(tox != nullptr);
+
+    tox_lock(tox);
+
+    const Net_Profile *tcp_c_profile = nc_get_tcp_client_net_profile(tox->m->net_crypto);
+    const Net_Profile *tcp_s_profile = tcp_server_get_net_profile(tox->m->tcp_server);
+
+    const Packet_Direction dir = (Packet_Direction) direction;
+
+    uint64_t bytes = 0;
+
+    switch (type) {
+        case TOX_NETPROF_PACKET_TYPE_TCP_CLIENT: {
+            bytes = netprof_get_bytes_total(tcp_c_profile, dir);
+            break;
+        }
+
+        case TOX_NETPROF_PACKET_TYPE_TCP_SERVER: {
+            bytes = netprof_get_bytes_total(tcp_s_profile, dir);
+            break;
+        }
+
+        case TOX_NETPROF_PACKET_TYPE_TCP: {
+            const uint64_t tcp_c_bytes = netprof_get_bytes_total(tcp_c_profile, dir);
+            const uint64_t tcp_s_bytes = netprof_get_bytes_total(tcp_s_profile, dir);
+            bytes = tcp_c_bytes + tcp_s_bytes;
+            break;
+        }
+
+        case TOX_NETPROF_PACKET_TYPE_UDP: {
+            const Net_Profile *udp_profile = net_get_net_profile(tox->m->net);
+            bytes = netprof_get_bytes_total(udp_profile, dir);
+            break;
+        }
+
+        default: {
+            LOGGER_ERROR(tox->m->log, "invalid packet type: %d", type);
+            break;
+        }
+    }
+
+    tox_unlock(tox);
+
+    return bytes;
+}

external/toxcore/c-toxcore/toxcore/tox_private.h

@@ -171,6 +171,254 @@ uint16_t tox_dht_get_num_closelist(const Tox *tox);
  */
 uint16_t tox_dht_get_num_closelist_announce_capable(const Tox *tox);
 
+/*******************************************************************************
+ *
+ * :: Network profiler
+ *
+ ******************************************************************************/
+
+
+/**
+ * Represents all of the network packet identifiers that Toxcore uses.
+ *
+ * Note: Some packet ID's have different purposes depending on the
+ * packet type. These ID's are given numeral names.
+ */
+typedef enum Tox_Netprof_Packet_Id {
+    /**
+     * Ping request packet (UDP).
+     * Routing request (TCP).
+     */
+    TOX_NETPROF_PACKET_ID_ZERO                 = 0x00,
+
+    /**
+     * Ping response packet (UDP).
+     * Routing response (TCP).
+     */
+    TOX_NETPROF_PACKET_ID_ONE                  = 0x01,
+
+    /**
+     * Get nodes request packet (UDP).
+     * Connection notification (TCP).
+     */
+    TOX_NETPROF_PACKET_ID_TWO                  = 0x02,
+
+    /**
+     * TCP disconnect notification.
+     */
+    TOX_NETPROF_PACKET_ID_TCP_DISCONNECT       = 0x03,
+
+    /**
+     * Send nodes response packet (UDP).
+     * Ping packet (TCP).
+     */
+    TOX_NETPROF_PACKET_ID_FOUR                 = 0x04,
+
+    /**
+     * TCP pong packet.
+     */
+    TOX_NETPROF_PACKET_ID_TCP_PONG             = 0x05,
+
+    /**
+     * TCP out-of-band send packet.
+     */
+    TOX_NETPROF_PACKET_ID_TCP_OOB_SEND         = 0x06,
+
+    /**
+     * TCP out-of-band receive packet.
+     */
+    TOX_NETPROF_PACKET_ID_TCP_OOB_RECV         = 0x07,
+
+    /**
+     * TCP onion request packet.
+     */
+    TOX_NETPROF_PACKET_ID_TCP_ONION_REQUEST    = 0x08,
+
+    /**
+     * TCP onion response packet.
+     */
+    TOX_NETPROF_PACKET_ID_TCP_ONION_RESPONSE   = 0x09,
+
+    /**
+     * TCP data packet.
+     */
+    TOX_NETPROF_PACKET_ID_TCP_DATA             = 0x10,
+
+    /**
+     * Cookie request packet.
+     */
+    TOX_NETPROF_PACKET_ID_COOKIE_REQUEST       = 0x18,
+
+    /**
+     * Cookie response packet.
+     */
+    TOX_NETPROF_PACKET_ID_COOKIE_RESPONSE      = 0x19,
+
+    /**
+     * Crypto handshake packet.
+     */
+    TOX_NETPROF_PACKET_ID_CRYPTO_HS            = 0x1a,
+
+    /**
+     * Crypto data packet.
+     */
+    TOX_NETPROF_PACKET_ID_CRYPTO_DATA          = 0x1b,
+
+    /**
+     * Encrypted data packet.
+     */
+    TOX_NETPROF_PACKET_ID_CRYPTO               = 0x20,
+
+    /**
+     * LAN discovery packet.
+     */
+    TOX_NETPROF_PACKET_ID_LAN_DISCOVERY        = 0x21,
+
+    /**
+     * DHT groupchat packets.
+     */
+    TOX_NETPROF_PACKET_ID_GC_HANDSHAKE         = 0x5a,
+    TOX_NETPROF_PACKET_ID_GC_LOSSLESS          = 0x5b,
+    TOX_NETPROF_PACKET_ID_GC_LOSSY             = 0x5c,
+
+    /**
+     * Onion send packets.
+     */
+    TOX_NETPROF_PACKET_ID_ONION_SEND_INITIAL   = 0x80,
+    TOX_NETPROF_PACKET_ID_ONION_SEND_1         = 0x81,
+    TOX_NETPROF_PACKET_ID_ONION_SEND_2         = 0x82,
+
+    /**
+     * DHT announce request packet (deprecated).
+     */
+    TOX_NETPROF_PACKET_ID_ANNOUNCE_REQUEST_OLD = 0x83,
+
+    /**
+     * DHT announce response packet (deprecated).
+     */
+    TOX_NETPROF_PACKET_ID_ANNOUNCE_RESPONSE_OLD = 0x84,
+
+    /**
+     * Onion data request packet.
+     */
+    TOX_NETPROF_PACKET_ID_ONION_DATA_REQUEST   = 0x85,
+
+    /**
+     * Onion data response packet.
+     */
+    TOX_NETPROF_PACKET_ID_ONION_DATA_RESPONSE  = 0x86,
+
+    /**
+     * DHT announce request packet.
+     */
+    TOX_NETPROF_PACKET_ID_ANNOUNCE_REQUEST     = 0x87,
+
+    /**
+     * DHT announce response packet.
+     */
+    TOX_NETPROF_PACKET_ID_ANNOUNCE_RESPONSE    = 0x88,
+
+    /**
+     * Onion receive packets.
+     */
+    TOX_NETPROF_PACKET_ID_ONION_RECV_3         = 0x8c,
+    TOX_NETPROF_PACKET_ID_ONION_RECV_2         = 0x8d,
+    TOX_NETPROF_PACKET_ID_ONION_RECV_1         = 0x8e,
+
+    TOX_NETPROF_PACKET_ID_FORWARD_REQUEST      = 0x90,
+    TOX_NETPROF_PACKET_ID_FORWARDING           = 0x91,
+    TOX_NETPROF_PACKET_ID_FORWARD_REPLY        = 0x92,
+
+    TOX_NETPROF_PACKET_ID_DATA_SEARCH_REQUEST     = 0x93,
+    TOX_NETPROF_PACKET_ID_DATA_SEARCH_RESPONSE    = 0x94,
+    TOX_NETPROF_PACKET_ID_DATA_RETRIEVE_REQUEST   = 0x95,
+    TOX_NETPROF_PACKET_ID_DATA_RETRIEVE_RESPONSE  = 0x96,
+    TOX_NETPROF_PACKET_ID_STORE_ANNOUNCE_REQUEST  = 0x97,
+    TOX_NETPROF_PACKET_ID_STORE_ANNOUNCE_RESPONSE = 0x98,
+
+    /**
+     * Bootstrap info packet.
+     */
+    TOX_NETPROF_PACKET_ID_BOOTSTRAP_INFO       = 0xf0,
+} Tox_Netprof_Packet_Id;
+
+/**
+ * Specifies the packet type for a given query.
+ */
+typedef enum Tox_Netprof_Packet_Type {
+    /**
+     * TCP client packets.
+     */
+    TOX_NETPROF_PACKET_TYPE_TCP_CLIENT,
+
+    /**
+     * TCP server packets.
+     */
+    TOX_NETPROF_PACKET_TYPE_TCP_SERVER,
+
+    /**
+     * Combined TCP server and TCP client packets.
+     */
+    TOX_NETPROF_PACKET_TYPE_TCP,
+
+    /**
+     * UDP packets.
+     */
+    TOX_NETPROF_PACKET_TYPE_UDP,
+} Tox_Netprof_Packet_Type;
+
+/**
+ * Specifies the packet direction for a given query.
+ */
+typedef enum Tox_Netprof_Direction {
+    /**
+     * Outbound packets.
+     */
+    TOX_NETPROF_DIRECTION_SENT,
+
+    /**
+     * Inbound packets.
+     */
+    TOX_NETPROF_DIRECTION_RECV,
+} Tox_Netprof_Direction;
+
+/**
+ * Return the number of packets sent or received for a specific packet ID.
+ *
+ * @param type The types of packets being queried.
+ * @param id The packet ID being queried.
+ * @param direction The packet direction.
+ */
+uint64_t tox_netprof_get_packet_id_count(const Tox *tox, Tox_Netprof_Packet_Type type, uint8_t id,
+        Tox_Netprof_Direction direction);
+
+/**
+ * Return the total number of packets sent or received.
+ *
+ * @param type The types of packets being queried.
+ * @param direction The packet direction.
+ */
+uint64_t tox_netprof_get_packet_total_count(const Tox *tox, Tox_Netprof_Packet_Type type,
+        Tox_Netprof_Direction direction);
+/**
+ * Return the number of bytes sent or received for a specific packet ID.
+ *
+ * @param type The types of packets being queried.
+ * @param id The packet ID being queried.
+ * @param direction The packet direction.
+ */
+uint64_t tox_netprof_get_packet_id_bytes(const Tox *tox, Tox_Netprof_Packet_Type type, uint8_t id,
+        Tox_Netprof_Direction direction);
+/**
+ * Return the total number of bytes sent or received.
+ *
+ * @param type The types of packets being queried.
+ * @param direction The packet direction.
+ */
+uint64_t tox_netprof_get_packet_total_bytes(const Tox *tox, Tox_Netprof_Packet_Type type,
+        Tox_Netprof_Direction direction);
+
+
 /*******************************************************************************
  *
  * :: DHT groupchat queries.

flake.nix

@@ -80,8 +80,6 @@
         ] ++ self.packages.${system}.default.dlopenBuildInputs;
 
         cmakeFlags = [
-          "-DTOMATO_TOX_AV=ON"
-
           "-DTOMATO_ASAN=OFF"
           "-DCMAKE_BUILD_TYPE=RelWithDebInfo"
           #"-DCMAKE_BUILD_TYPE=Debug"

src/CMakeLists.txt

@@ -97,35 +97,20 @@ target_sources(tomato PUBLIC
 	./tox_dht_cap_histo.hpp
 	./tox_dht_cap_histo.cpp
 
+	./tox_netprof_ui.hpp
+	./tox_netprof_ui.cpp
+
 	./tox_friend_faux_offline_messaging.hpp
 	./tox_friend_faux_offline_messaging.cpp
 
 	./chat_gui4.hpp
 	./chat_gui4.cpp
-
-	./stream_manager.hpp
-	./stream_manager_ui.hpp
-	./stream_manager_ui.cpp
-
-	./debug_video_tap.hpp
-	./debug_video_tap.cpp
-
-	./content/content.hpp
-	./content/frame_stream2.hpp
-	./content/sdl_video_frame_stream2.hpp
-	./content/sdl_video_frame_stream2.cpp
-	./content/audio_stream.hpp
-	./content/sdl_audio_frame_stream2.hpp
-	./content/sdl_audio_frame_stream2.cpp
 )
 
 if (TOMATO_TOX_AV)
 	target_sources(tomato PUBLIC
 		./tox_av.hpp
 		./tox_av.cpp
-
-		./debug_tox_call.hpp
-		./debug_tox_call.cpp
 	)
 
 	target_compile_definitions(tomato PUBLIC TOMATO_TOX_AV)
@@ -158,8 +143,6 @@ target_link_libraries(tomato PUBLIC
 	libwebpmux # the f why (needed for anim encode)
 	qoi
 	SDL3_image::SDL3_image
-
-	SPSCQueue
 )
 
 # probably not enough

src/chat_gui4.cpp

@@ -1042,16 +1042,11 @@ void ChatGui4::renderMessageBodyFile(Message3Registry& reg, const Message3 e) {
 
 		float fraction = float(total) / total_size;
 
-		char overlay_buf[64];
+		char overlay_buf[32];
 		if (rate > 0.000001f) {
 			const char* byte_suffix = "???";
 			int64_t byte_divider = sizeToHumanReadable(rate, byte_suffix);
-			int64_t seconds_remaining = (total_size - total) / rate;
-			if (seconds_remaining > 0) {
-				std::snprintf(overlay_buf, sizeof(overlay_buf), "%.1f%% @ %.1f%s/s %lds ", fraction * 100 + 0.01f, rate/byte_divider, byte_suffix, seconds_remaining);
-			} else {
-				std::snprintf(overlay_buf, sizeof(overlay_buf), "%.1f%% @ %.1f%s/s", fraction * 100 + 0.01f, rate/byte_divider, byte_suffix);
-			}
+			std::snprintf(overlay_buf, sizeof(overlay_buf), "%.1f%% @ %.1f%s/s", fraction * 100 + 0.01f, rate/byte_divider, byte_suffix);
 		} else {
 			std::snprintf(overlay_buf, sizeof(overlay_buf), "%.1f%%", fraction * 100 + 0.01f);
 		}

src/content/audio_stream.hpp

@@ -1,72 +0,0 @@
-#pragma once
-
-#include "./frame_stream2.hpp"
-
-#include <solanaceae/util/span.hpp>
-
-#include <cstdint>
-#include <variant>
-#include <vector>
-
-// raw audio
-// channels make samples interleaved,
-// planar channels are not supported
-struct AudioFrame {
-	// sequence number, to detect gaps
-	uint32_t seq {0};
-	// TODO: maybe use ts instead to discard old?
-	// since buffer size is variable, some timestamp would be needed to estimate the lost time
-
-	// samples per second
-	uint32_t sample_rate {48'000};
-
-	size_t channels {0};
-	std::variant<
-		std::vector<int16_t>, // S16, platform endianess
-		Span<int16_t>, // non owning variant, for direct consumption
-
-		std::vector<float>, // f32
-		Span<float> // non owning variant, for direct consumption
-	> buffer;
-
-	// helpers
-
-	bool isS16(void) const {
-		return
-			std::holds_alternative<std::vector<int16_t>>(buffer) ||
-			std::holds_alternative<Span<int16_t>>(buffer)
-		;
-	}
-	bool isF32(void) const {
-		return
-			std::holds_alternative<std::vector<float>>(buffer) ||
-			std::holds_alternative<Span<float>>(buffer)
-		;
-	}
-	template<typename T>
-	Span<T> getSpan(void) const {
-		static_assert(std::is_same_v<int16_t, T> || std::is_same_v<float, T>);
-		if constexpr (std::is_same_v<int16_t, T>) {
-			assert(isS16());
-			if (std::holds_alternative<std::vector<int16_t>>(buffer)) {
-				return Span<int16_t>{std::get<std::vector<int16_t>>(buffer)};
-			} else {
-				return std::get<Span<int16_t>>(buffer);
-			}
-		} else if constexpr (std::is_same_v<float, T>) {
-			assert(isF32());
-			if (std::holds_alternative<std::vector<float>>(buffer)) {
-				return Span<float>{std::get<std::vector<float>>(buffer)};
-			} else {
-				return std::get<Span<float>>(buffer);
-			}
-		}
-		return {};
-	}
-};
-
-using AudioFrameStream2I = FrameStream2I<AudioFrame>;
-
-using AudioFrameStream2MultiSource = FrameStream2MultiSource<AudioFrame>;
-using AudioFrameStream2 = AudioFrameStream2MultiSource::sub_stream_type_t; // just use the default for now
-

src/content/content.hpp

@@ -1,36 +0,0 @@
-#pragma once
-
-#include <entt/container/dense_set.hpp>
-
-#include <solanaceae/object_store/object_store.hpp>
-#include <solanaceae/contact/contact_model3.hpp>
-#include <solanaceae/message3/registry_message_model.hpp>
-
-#include <solanaceae/file/file2.hpp>
-
-namespace Content1::Components {
-
-	// TODO: design it as a tree?
-
-	// or something
-	struct TagFile {};
-	struct TagAudioStream {};
-	struct TagVideoStream {};
-
-	struct TimingTiedTo {
-		entt::dense_set<ObjectHandle> ties;
-	};
-
-	// the associated messages, if any
-	// useful if you want to update progress on the message
-	struct Messages {
-		std::vector<Message3Handle> messages;
-	};
-
-	// ?
-	struct SuspectedParticipants {
-		entt::dense_set<Contact3> participants;
-	};
-
-} // Content::Components
-

src/content/frame_stream2.hpp

@@ -1,153 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <memory>
-#include <optional>
-#include <vector>
-#include <mutex>
-
-#include <SPSCQueue.h>
-
-// Frames ofen consist of:
-// - seq id // incremental sequential id, gaps in ids can be used to detect loss
-// - data // the frame data
-// eg:
-//struct ExampleFrame {
-	//int64_t seq_id {0};
-	//std::vector<uint8_t> data;
-//};
-
-template<typename FrameType>
-struct FrameStream2I {
-	virtual ~FrameStream2I(void) {}
-
-	// get number of available frames
-	[[nodiscard]] virtual int32_t size(void) = 0;
-
-	// get next frame
-	// TODO: optional instead?
-	// data sharing? -> no, data is copied for each fsr, if concurency supported
-	[[nodiscard]] virtual std::optional<FrameType> pop(void) = 0;
-
-	// returns true if there are readers (or we dont know)
-	virtual bool push(const FrameType& value) = 0;
-};
-
-template<typename FrameType>
-struct FrameStream2SourceI {
-	virtual ~FrameStream2SourceI(void) {}
-	[[nodiscard]] virtual std::shared_ptr<FrameStream2I<FrameType>> subscribe(void) = 0;
-	virtual bool unsubscribe(const std::shared_ptr<FrameStream2I<FrameType>>& sub) = 0;
-};
-
-template<typename FrameType>
-struct FrameStream2SinkI {
-	virtual ~FrameStream2SinkI(void) {}
-	[[nodiscard]] virtual std::shared_ptr<FrameStream2I<FrameType>> subscribe(void) = 0;
-	virtual bool unsubscribe(const std::shared_ptr<FrameStream2I<FrameType>>& sub) = 0;
-};
-
-// needs count frames queue size
-// having ~1-2sec buffer size is often sufficent
-template<typename FrameType>
-struct QueuedFrameStream2 : public FrameStream2I<FrameType> {
-	using frame_type = FrameType;
-
-	rigtorp::SPSCQueue<FrameType> _queue;
-
-	// discard values if queue full
-	// will block if not lossy and full on push
-	const bool _lossy {true};
-
-	explicit QueuedFrameStream2(size_t queue_size, bool lossy = true) : _queue(queue_size), _lossy(lossy) {}
-
-	int32_t size(void) override {
-		return _queue.size();
-	}
-
-	std::optional<FrameType> pop(void) override {
-		auto* ret_ptr = _queue.front();
-		if (ret_ptr == nullptr) {
-			return std::nullopt;
-		}
-
-		// move away
-		FrameType ret = std::move(*ret_ptr);
-
-		_queue.pop();
-
-		return ret;
-	}
-
-	bool push(const FrameType& value) override {
-		if (_lossy) {
-			[[maybe_unused]] auto _ = _queue.try_emplace(value);
-			// TODO: maybe return ?
-		} else {
-			_queue.push(value);
-		}
-		return true;
-	}
-};
-
-// implements a stream that pushes to all sub streams
-// release all streams before destructing! // TODO: improve lifetime here, maybe some shared semaphore?
-template<typename FrameType, typename SubStreamType = QueuedFrameStream2<FrameType>>
-struct FrameStream2MultiSource : public FrameStream2SourceI<FrameType>, public FrameStream2I<FrameType> {
-	using sub_stream_type_t = SubStreamType;
-
-	// pointer stability
-	std::vector<std::shared_ptr<SubStreamType>> _sub_streams;
-	std::mutex _sub_stream_lock; // accessing the _sub_streams array needs to be exclusive
-	// a simple lock here is ok, since this tends to be a rare operation,
-	// except for the push, which is always on the same thread
-
-	virtual ~FrameStream2MultiSource(void) {}
-
-	// TODO: forward args instead
-	std::shared_ptr<FrameStream2I<FrameType>> subscribe(void) override {
-		// TODO: args???
-		size_t queue_size = 8;
-		bool lossy = true;
-
-		std::lock_guard lg{_sub_stream_lock};
-		return _sub_streams.emplace_back(std::make_unique<SubStreamType>(queue_size, lossy));
-	}
-
-	bool unsubscribe(const std::shared_ptr<FrameStream2I<FrameType>>& sub) override {
-		std::lock_guard lg{_sub_stream_lock};
-		for (auto it = _sub_streams.begin(); it != _sub_streams.end(); it++) {
-			if (*it == sub) {
-				_sub_streams.erase(it);
-				return true;
-			}
-		}
-		return false; // ?
-	}
-
-	// stream interface
-
-	int32_t size(void) override {
-		// TODO: return something sensible?
-		return -1;
-	}
-
-	std::optional<FrameType> pop(void) override {
-		// nope
-		assert(false && "this logic is very frame type specific, provide an impl");
-		return std::nullopt;
-	}
-
-	// returns true if there are readers
-	bool push(const FrameType& value) override {
-		std::lock_guard lg{_sub_stream_lock};
-		bool have_readers{false};
-		for (auto& it : _sub_streams) {
-			[[maybe_unused]] auto _ = it->push(value);
-			have_readers = true; // even if queue full, we still continue believing in them
-			// maybe consider push return value?
-		}
-		return have_readers;
-	}
-};
-

src/content/sdl_audio_frame_stream2.cpp

@@ -1,289 +0,0 @@
-#include "./sdl_audio_frame_stream2.hpp"
-
-#include <iostream>
-
-// "thin" wrapper around sdl audio streams
-// we dont needs to get fance, as they already provide everything we need
-struct SDLAudioStreamReader : public AudioFrameStream2I {
-	std::unique_ptr<SDL_AudioStream, decltype(&SDL_DestroyAudioStream)> _stream;
-
-	uint32_t _seq_counter {0};
-
-	uint32_t _sample_rate {48'000};
-	size_t _channels {0};
-	SDL_AudioFormat _format {SDL_AUDIO_S16};
-
-	std::vector<int16_t> _buffer;
-
-	SDLAudioStreamReader(void) : _stream(nullptr, nullptr) {}
-	SDLAudioStreamReader(SDLAudioStreamReader&& other) :
-		_stream(std::move(other._stream)),
-		_sample_rate(other._sample_rate),
-		_channels(other._channels),
-		_format(other._format)
-	{
-		static const size_t buffer_size {960*_channels};
-		_buffer.resize(buffer_size);
-	}
-
-	~SDLAudioStreamReader(void) {
-		if (_stream) {
-			SDL_UnbindAudioStream(_stream.get());
-		}
-	}
-
-	int32_t size(void) override {
-		//assert(_stream);
-		// returns bytes
-		//SDL_GetAudioStreamAvailable(_stream.get());
-		return -1;
-	}
-
-	std::optional<AudioFrame> pop(void) override {
-		assert(_stream);
-		assert(_format == SDL_AUDIO_S16);
-
-		static const size_t buffer_size {960*_channels};
-		_buffer.resize(buffer_size); // noop?
-
-		const auto read_bytes = SDL_GetAudioStreamData(
-			_stream.get(),
-			_buffer.data(),
-			_buffer.size()*sizeof(int16_t)
-		);
-
-		// no new frame yet, or error
-		if (read_bytes <= 0) {
-			return std::nullopt;
-		}
-
-		return AudioFrame {
-			_seq_counter++,
-			_sample_rate, _channels,
-			Span<int16_t>(_buffer.data(), read_bytes/sizeof(int16_t)),
-		};
-	}
-
-	bool push(const AudioFrame&) override {
-		// TODO: make universal sdl stream wrapper (combine with SDLAudioOutputDeviceDefaultInstance)
-		assert(false && "read only");
-		return false;
-	}
-};
-
-SDLAudioInputDevice::SDLAudioInputDevice(void) : SDLAudioInputDevice(SDL_AUDIO_DEVICE_DEFAULT_RECORDING) {
-}
-
-SDLAudioInputDevice::SDLAudioInputDevice(SDL_AudioDeviceID conf_device_id) : _configured_device_id(conf_device_id) {
-	if (_configured_device_id == 0) {
-		// TODO: proper error handling
-		throw int(1);
-	}
-}
-
-SDLAudioInputDevice::~SDLAudioInputDevice(void) {
-	_streams.clear();
-
-	if (_virtual_device_id != 0) {
-		SDL_CloseAudioDevice(_virtual_device_id);
-		_virtual_device_id = 0;
-	}
-}
-
-std::shared_ptr<FrameStream2I<AudioFrame>> SDLAudioInputDevice::subscribe(void) {
-	if (_virtual_device_id == 0) {
-		// first stream, open device
-		// this spec is more like a hint to the hardware
-		SDL_AudioSpec spec {
-			SDL_AUDIO_S16,
-			1, // TODO: conf
-			48'000,
-		};
-		_virtual_device_id = SDL_OpenAudioDevice(_configured_device_id, &spec);
-	}
-
-	if (_virtual_device_id == 0) {
-		std::cerr << "SDLAID error: failed opening device " << _configured_device_id << "\n";
-		return nullptr;
-	}
-
-	SDL_AudioSpec spec {
-		SDL_AUDIO_S16,
-		1, // TODO: conf
-		48'000,
-	};
-
-	SDL_AudioSpec device_spec {
-		SDL_AUDIO_S16,
-		1, // TODO: conf
-		48'000,
-	};
-	// TODO: error check
-	SDL_GetAudioDeviceFormat(_virtual_device_id, &device_spec, nullptr);
-
-	// error check
-	auto* sdl_stream = SDL_CreateAudioStream(&device_spec, &spec);
-
-	// error check
-	SDL_BindAudioStream(_virtual_device_id, sdl_stream);
-
-	auto new_stream = std::make_shared<SDLAudioStreamReader>();
-	// TODO: move to ctr
-	new_stream->_stream = {sdl_stream, &SDL_DestroyAudioStream};
-	new_stream->_sample_rate = spec.freq;
-	new_stream->_channels = spec.channels;
-	new_stream->_format = spec.format;
-
-	_streams.emplace_back(new_stream);
-
-	return new_stream;
-}
-
-bool SDLAudioInputDevice::unsubscribe(const std::shared_ptr<FrameStream2I<AudioFrame>>& sub) {
-	for (auto it = _streams.cbegin(); it != _streams.cend(); it++) {
-		if (*it == sub) {
-			_streams.erase(it);
-			if (_streams.empty()) {
-				// last stream, close
-				// TODO: make sure no shared ptr still exists???
-				SDL_CloseAudioDevice(_virtual_device_id);
-				std::cout << "SDLAID: closing device " << _virtual_device_id << " (" << _configured_device_id << ")\n";
-				_virtual_device_id = 0;
-			}
-			return true;
-		}
-	}
-
-	return false;
-}
-
-// does not need to be visible in the header
-struct SDLAudioOutputDeviceDefaultInstance : public AudioFrameStream2I {
-	std::unique_ptr<SDL_AudioStream, decltype(&SDL_DestroyAudioStream)> _stream;
-
-	uint32_t _last_sample_rate {48'000};
-	size_t _last_channels {0};
-	SDL_AudioFormat _last_format {SDL_AUDIO_S16};
-
-	// TODO: audio device
-	SDLAudioOutputDeviceDefaultInstance(void);
-	SDLAudioOutputDeviceDefaultInstance(SDLAudioOutputDeviceDefaultInstance&& other);
-
-	~SDLAudioOutputDeviceDefaultInstance(void);
-
-	int32_t size(void) override;
-	std::optional<AudioFrame> pop(void) override;
-	bool push(const AudioFrame& value) override;
-};
-
-SDLAudioOutputDeviceDefaultInstance::SDLAudioOutputDeviceDefaultInstance(void) : _stream(nullptr, nullptr) {
-}
-
-SDLAudioOutputDeviceDefaultInstance::SDLAudioOutputDeviceDefaultInstance(SDLAudioOutputDeviceDefaultInstance&& other) : _stream(std::move(other._stream)) {
-}
-
-SDLAudioOutputDeviceDefaultInstance::~SDLAudioOutputDeviceDefaultInstance(void) {
-}
-int32_t SDLAudioOutputDeviceDefaultInstance::size(void) {
-	return -1;
-}
-
-std::optional<AudioFrame> SDLAudioOutputDeviceDefaultInstance::pop(void) {
-	assert(false);
-	// this is an output device, there is no data to pop
-	return std::nullopt;
-}
-
-bool SDLAudioOutputDeviceDefaultInstance::push(const AudioFrame& value) {
-	if (!static_cast<bool>(_stream)) {
-		return false;
-	}
-
-	// verify here the fame has the same sample type, channel count and sample freq
-	// if something changed, we need to either use a temporary stream, just for conversion, or reopen _stream with the new params
-	// because of data temporality, the second options looks like a better candidate
-	if (
-		value.sample_rate != _last_sample_rate ||
-		value.channels != _last_channels ||
-		(value.isF32() && _last_format != SDL_AUDIO_F32) ||
-		(value.isS16() && _last_format != SDL_AUDIO_S16)
-	) {
-		const SDL_AudioSpec spec = {
-			static_cast<SDL_AudioFormat>((value.isF32() ? SDL_AUDIO_F32 :  SDL_AUDIO_S16)),
-			static_cast<int>(value.channels),
-			static_cast<int>(value.sample_rate)
-		};
-
-		SDL_SetAudioStreamFormat(_stream.get(), &spec, nullptr);
-
-		std::cerr << "SDLAOD: audio format changed\n";
-	}
-
-	if (value.isS16()) {
-		auto data = value.getSpan<int16_t>();
-
-		if (data.size == 0) {
-			std::cerr << "empty audio frame??\n";
-		}
-
-		if (!SDL_PutAudioStreamData(_stream.get(), data.ptr, data.size * sizeof(int16_t))) {
-			std::cerr << "put data error\n";
-			return false; // return true?
-		}
-	} else if (value.isF32()) {
-		auto data = value.getSpan<float>();
-
-		if (data.size == 0) {
-			std::cerr << "empty audio frame??\n";
-		}
-
-		if (!SDL_PutAudioStreamData(_stream.get(), data.ptr, data.size * sizeof(float))) {
-			std::cerr << "put data error\n";
-			return false; // return true?
-		}
-	}
-
-	_last_sample_rate = value.sample_rate;
-	_last_channels = value.channels;
-	_last_format = value.isF32() ? SDL_AUDIO_F32 :  SDL_AUDIO_S16;
-
-	return true;
-}
-
-
-SDLAudioOutputDeviceDefaultSink::~SDLAudioOutputDeviceDefaultSink(void) {
-	// TODO: pause and close device?
-}
-
-std::shared_ptr<FrameStream2I<AudioFrame>> SDLAudioOutputDeviceDefaultSink::subscribe(void) {
-	auto new_instance = std::make_shared<SDLAudioOutputDeviceDefaultInstance>();
-
-	constexpr SDL_AudioSpec spec = { SDL_AUDIO_S16, 1, 48000 };
-
-	new_instance->_stream = {
-		SDL_OpenAudioDeviceStream(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &spec, nullptr, nullptr),
-		&SDL_DestroyAudioStream
-	};
-	new_instance->_last_sample_rate = spec.freq;
-	new_instance->_last_channels = spec.channels;
-	new_instance->_last_format = spec.format;
-
-	if (!static_cast<bool>(new_instance->_stream)) {
-		std::cerr << "SDL open audio device failed!\n";
-		return nullptr;
-	}
-
-	const auto audio_device_id = SDL_GetAudioStreamDevice(new_instance->_stream.get());
-	SDL_ResumeAudioDevice(audio_device_id);
-
-	return new_instance;
-}
-
-bool SDLAudioOutputDeviceDefaultSink::unsubscribe(const std::shared_ptr<FrameStream2I<AudioFrame>>& sub) {
-	if (!sub) {
-		return false;
-	}
-
-	return true;
-}
-

src/content/sdl_audio_frame_stream2.hpp

@@ -1,43 +0,0 @@
-#pragma once
-
-#include "./frame_stream2.hpp"
-#include "./audio_stream.hpp"
-
-#include <SDL3/SDL.h>
-
-#include <cstdint>
-#include <vector>
-
-// we dont have to multicast ourself, because sdl streams and virtual devices already do this
-
-// source
-// opens device
-// creates a sdl audio stream for each subscribed reader stream
-struct SDLAudioInputDevice : public FrameStream2SourceI<AudioFrame> {
-	// held by instances
-	using sdl_stream_type = std::unique_ptr<SDL_AudioStream, decltype(&SDL_DestroyAudioStream)>;
-
-	SDL_AudioDeviceID _configured_device_id {0};
-	SDL_AudioDeviceID _virtual_device_id {0};
-
-	std::vector<std::shared_ptr<FrameStream2I<AudioFrame>>> _streams;
-
-	SDLAudioInputDevice(void);
-	SDLAudioInputDevice(SDL_AudioDeviceID conf_device_id);
-	~SDLAudioInputDevice(void);
-
-	std::shared_ptr<FrameStream2I<AudioFrame>> subscribe(void) override;
-	bool unsubscribe(const std::shared_ptr<FrameStream2I<AudioFrame>>& sub) override;
-};
-
-// sink
-// constructs entirely new streams, since sdl handles sync and mixing for us (or should)
-struct SDLAudioOutputDeviceDefaultSink : public FrameStream2SinkI<AudioFrame> {
-	// TODO: pause device?
-
-	~SDLAudioOutputDeviceDefaultSink(void);
-
-	std::shared_ptr<FrameStream2I<AudioFrame>> subscribe(void) override;
-	bool unsubscribe(const std::shared_ptr<FrameStream2I<AudioFrame>>& sub) override;
-};
-

src/content/sdl_video_frame_stream2.cpp

@@ -1,167 +0,0 @@
-#include "./sdl_video_frame_stream2.hpp"
-#include "SDL3/SDL_camera.h"
-#include "SDL3/SDL_pixels.h"
-
-#include <chrono>
-#include <cstdint>
-#include <iostream>
-#include <memory>
-#include <thread>
-
-// TODO: move out and create lazy cam for each device
-SDLVideoCameraContent::SDLVideoCameraContent(void) {
-	int devcount {0};
-	//SDL_CameraDeviceID *devices = SDL_GetCameraDevices(&devcount);
-	SDL_CameraID *devices = SDL_GetCameras(&devcount);
-	std::cout << "SDL Camera Driver: " << SDL_GetCurrentCameraDriver() << "\n";
-
-	if (devices == nullptr || devcount < 1) {
-		throw int(1); // TODO: proper exception?
-	}
-
-	std::cout << "### found cameras:\n";
-	for (int i = 0; i < devcount; i++) {
-		const SDL_CameraID device = devices[i];
-
-		const char *name = SDL_GetCameraName(device);
-		std::cout << "  - Camera #" << i << ": " << name << "\n";
-
-		int speccount {0};
-		SDL_CameraSpec** specs = SDL_GetCameraSupportedFormats(device, &speccount);
-		if (specs == nullptr) {
-			std::cout << "    - no supported spec\n";
-		} else {
-			for (int spec_i = 0; spec_i < speccount; spec_i++) {
-				std::cout << "    - " << specs[spec_i]->width << "x" << specs[spec_i]->height << "@" << float(specs[spec_i]->framerate_numerator)/specs[spec_i]->framerate_denominator << "fps " << SDL_GetPixelFormatName(specs[spec_i]->format) << "\n";
-
-			}
-			SDL_free(specs);
-		}
-	}
-
-	{
-		SDL_CameraSpec spec {
-			// FORCE a diffrent pixel format
-			//SDL_PIXELFORMAT_RGBA8888,
-			//SDL_PIXELFORMAT_UNKNOWN,
-			//SDL_PIXELFORMAT_IYUV,
-			SDL_PIXELFORMAT_YUY2,
-
-			//SDL_COLORSPACE_UNKNOWN,
-			//SDL_COLORSPACE_SRGB,
-			//SDL_COLORSPACE_SRGB_LINEAR,
-			SDL_COLORSPACE_YUV_DEFAULT,
-
-			//1280, 720,
-			//640, 360,
-			//640, 480,
-			696, 392,
-
-			//1, 30
-			30, 1
-		};
-		_camera = {
-			//SDL_OpenCamera(devices[devcount-1], &spec),
-			SDL_OpenCamera(devices[0], nullptr),
-			//SDL_OpenCamera(devices[0], &spec),
-			&SDL_CloseCamera
-		};
-		SDL_GetCameraFormat(_camera.get(), &spec);
-	}
-	SDL_free(devices);
-	if (!static_cast<bool>(_camera)) {
-		throw int(2);
-	}
-
-	while (SDL_GetCameraPermissionState(_camera.get()) == 0) {
-		std::cerr << "permission for camera not granted\n";
-		std::this_thread::sleep_for(std::chrono::milliseconds(10));
-	}
-
-	if (SDL_GetCameraPermissionState(_camera.get()) < 0) {
-		std::cerr << "user denied camera permission\n";
-		throw int(3);
-	}
-
-	SDL_CameraSpec spec;
-	float fps {1.f};
-	if (!SDL_GetCameraFormat(_camera.get(), &spec)) {
-		// meh
-		throw int(5);
-	} else {
-		fps = float(spec.framerate_numerator)/float(spec.framerate_denominator);
-		std::cout << "camera fps: " << fps << "fps (" << spec.framerate_numerator << "/" << spec.framerate_denominator << ")\n";
-		auto* format_name = SDL_GetPixelFormatName(spec.format);
-		std::cout << "camera format: " << format_name << "\n";
-	}
-
-	_thread = std::thread([this, fps](void) {
-		while (!_thread_should_quit) {
-			Uint64 timestampNS = 0;
-			SDL_Surface* sdl_frame_next = SDL_AcquireCameraFrame(_camera.get(), &timestampNS);
-
-			// no new frame yet, or error
-			if (sdl_frame_next == nullptr) {
-				// only sleep 1/10, we expected a frame
-				std::this_thread::sleep_for(std::chrono::milliseconds(int64_t((1000/fps) / 10)));
-				continue;
-			}
-
-#if 0
-			{ // test copy to trigger bug
-				SDL_Surface* test_surf = SDL_CreateSurface(
-					sdl_frame_next->w,
-					sdl_frame_next->h,
-					SDL_PIXELFORMAT_RGBA8888
-				);
-
-				assert(test_surf != nullptr);
-
-				SDL_BlitSurface(sdl_frame_next, nullptr, test_surf, nullptr);
-
-				SDL_DestroySurface(test_surf);
-			}
-#endif
-
-			bool someone_listening {false};
-			{
-				SDLVideoFrame new_frame_non_owning {
-					timestampNS/1000,
-					sdl_frame_next
-				};
-
-				// creates surface copies
-				someone_listening = push(new_frame_non_owning);
-			}
-			SDL_ReleaseCameraFrame(_camera.get(), sdl_frame_next);
-
-			if (someone_listening) {
-				// double the interval on acquire
-				std::this_thread::sleep_for(std::chrono::milliseconds(int64_t((1000/fps)*0.5)));
-			} else {
-				std::cerr << "i guess no one is listening\n";
-				// we just sleep 4x as long, bc no one is listening
-				std::this_thread::sleep_for(std::chrono::milliseconds(int64_t((1000/fps)*4)));
-			}
-		}
-	});
-}
-
-SDLVideoCameraContent::~SDLVideoCameraContent(void) {
-	_thread_should_quit = true;
-	_thread.join();
-	// TODO: what to do if readers are still present?
-
-	// HACK: sdl is buggy and freezes otherwise. it is likely still possible, but rare to freeze here
-	// flush unused frames
-#if 1
-	while (true) {
-		SDL_Surface* sdl_frame_next = SDL_AcquireCameraFrame(_camera.get(), nullptr);
-		if (sdl_frame_next != nullptr) {
-			SDL_ReleaseCameraFrame(_camera.get(), sdl_frame_next);
-		} else {
-			break;
-		}
-	}
-#endif
-}

src/content/sdl_video_frame_stream2.hpp

@@ -1,71 +0,0 @@
-#pragma once
-
-#include "./frame_stream2.hpp"
-
-#include <SDL3/SDL.h>
-
-#include <cstdint>
-#include <thread>
-
-inline void nopSurfaceDestructor(SDL_Surface*) {}
-
-// this is very sdl specific
-struct SDLVideoFrame {
-	// TODO: sequence numbering?
-	// micro seconds (nano is way too much)
-	uint64_t timestampUS {0};
-
-	std::unique_ptr<SDL_Surface, decltype(&SDL_DestroySurface)> surface {nullptr, &SDL_DestroySurface};
-
-	// special non-owning constructor?
-	SDLVideoFrame(
-		uint64_t ts,
-		SDL_Surface* surf
-	) {
-		timestampUS = ts;
-		surface = {surf, &nopSurfaceDestructor};
-	}
-	SDLVideoFrame(SDLVideoFrame&& other) = default;
-	// copy
-	SDLVideoFrame(const SDLVideoFrame& other) {
-		timestampUS = other.timestampUS;
-		if (static_cast<bool>(other.surface)) {
-			//surface = {
-			//    SDL_CreateSurface(
-			//        other.surface->w,
-			//        other.surface->h,
-			//        other.surface->format
-			//    ),
-			//    &SDL_DestroySurface
-			//};
-			//SDL_BlitSurface(other.surface.get(), nullptr, surface.get(), nullptr);
-			surface = {
-				SDL_DuplicateSurface(other.surface.get()),
-				&SDL_DestroySurface
-			};
-		}
-	}
-	SDLVideoFrame& operator=(const SDLVideoFrame& other) = delete;
-};
-
-using SDLVideoFrameStream2MultiSource = FrameStream2MultiSource<SDLVideoFrame>;
-using SDLVideoFrameStream2 = SDLVideoFrameStream2MultiSource::sub_stream_type_t; // just use the default for now
-
-struct SDLVideoCameraContent : public SDLVideoFrameStream2MultiSource {
-	// meh, empty default
-	std::unique_ptr<SDL_Camera, decltype(&SDL_CloseCamera)> _camera {nullptr, &SDL_CloseCamera};
-	std::atomic<bool> _thread_should_quit {false};
-	std::thread _thread;
-
-	// construct source and start thread
-	// TODO: optimize so the thread is not always running
-	SDLVideoCameraContent(void);
-
-	// stops the thread and closes the camera
-	~SDLVideoCameraContent(void);
-
-	// make only some of writer public
-	using SDLVideoFrameStream2MultiSource::subscribe;
-	using SDLVideoFrameStream2MultiSource::unsubscribe;
-};
-

src/content/stream_reader.hpp

@@ -1,15 +0,0 @@
-#pragma once
-
-#include <solanaceae/util/span.hpp>
-
-// most media that can be counted as "stream" comes in packets/frames/messages
-// so this class provides an interface for ideal async fetching of frames
-struct RawFrameStreamReaderI {
-	// return the number of ready frames in cache
-	// returns -1 if unknown
-	virtual int64_t have(void) = 0;
-
-	// get next frame, empty if none
-	virtual ByteSpan getNext(void) = 0;
-};
-

src/content/stream_reader_sdl_audio.cpp

@@ -1,39 +0,0 @@
-#include "./stream_reader_sdl_audio.hpp"
-
-SDLAudioFrameStreamReader::SDLAudioFrameStreamReader(int32_t buffer_size) : _buffer_size(buffer_size),  _stream{nullptr, &SDL_DestroyAudioStream} {
-	_buffer.resize(_buffer_size);
-
-	const SDL_AudioSpec spec = { SDL_AUDIO_S16, 1, 48000 };
-
-	_stream = {
-		SDL_OpenAudioDeviceStream(SDL_AUDIO_DEVICE_DEFAULT_CAPTURE, &spec, nullptr, nullptr),
-		&SDL_DestroyAudioStream
-	};
-}
-
-Span<int16_t> SDLAudioFrameStreamReader::getNextAudioFrame(void) {
-	const int32_t needed_bytes = (_buffer.size() - _remaining_size) * sizeof(int16_t);
-	const auto read_bytes = SDL_GetAudioStreamData(_stream.get(), _buffer.data()+_remaining_size, needed_bytes);
-	if (read_bytes < 0) {
-		// error
-		return {};
-	}
-	if (read_bytes < needed_bytes) {
-		// HACK: we are just assuming here that sdl never gives us half a sample!
-		_remaining_size += read_bytes / sizeof(int16_t);
-		return {};
-	}
-
-	_remaining_size = 0;
-	return Span<int16_t>{_buffer};
-}
-
-int64_t SDLAudioFrameStreamReader::have(void) {
-	return -1;
-}
-
-ByteSpan SDLAudioFrameStreamReader::getNext(void) {
-	auto next_frame_span = getNextAudioFrame();
-	return ByteSpan{reinterpret_cast<const uint8_t*>(next_frame_span.ptr), next_frame_span.size};
-}
-

src/content/stream_reader_sdl_audio.hpp

@@ -1,31 +0,0 @@
-#pragma once
-
-#include "./stream_reader.hpp"
-
-#include <SDL3/SDL.h>
-
-#include <cstdint>
-#include <cstdio>
-#include <memory>
-
-struct SDLAudioFrameStreamReader : public RawFrameStreamReaderI {
-	// count samples per buffer
-	const int32_t _buffer_size {1024};
-	std::vector<int16_t> _buffer;
-	size_t _remaining_size {0}; // data still in buffer, that was remaining from last call and not enough to fill a full frame
-
-	// meh, empty default
-	std::unique_ptr<SDL_AudioStream, decltype(&SDL_DestroyAudioStream)> _stream;
-
-	// buffer_size in number of samples
-	SDLAudioFrameStreamReader(int32_t buffer_size = 1024);
-
-	// data owned by StreamReader, overwritten by next call to getNext*()
-	Span<int16_t> getNextAudioFrame(void);
-
-	public: // interface
-		int64_t have(void) override;
-
-		ByteSpan getNext(void) override;
-};
-

src/content/stream_reader_sdl_video.cpp

@@ -1,84 +0,0 @@
-#include "./stream_reader_sdl_video.hpp"
-
-#include <iostream>
-
-SDLVideoFrameStreamReader::SDLVideoFrameStreamReader() : _camera{nullptr, &SDL_CloseCamera}, _surface{nullptr, &SDL_DestroySurface} {
-	// enumerate
-	int devcount = 0;
-	SDL_CameraDeviceID *devices = SDL_GetCameraDevices(&devcount);
-
-	if (devices == nullptr || devcount < 1) {
-		throw int(1); // TODO: proper exception?
-	}
-
-	std::cout << "### found cameras:\n";
-	for (int i = 0; i < devcount; i++) {
-		const SDL_CameraDeviceID device = devices[i];
-		char *name = SDL_GetCameraDeviceName(device);
-
-		std::cout << "  - Camera #" << i << ": " << name << "\n";
-
-		SDL_free(name);
-	}
-
-	_camera = {
-		SDL_OpenCameraDevice(devices[0], nullptr),
-		&SDL_CloseCamera
-	};
-	if (!static_cast<bool>(_camera)) {
-		throw int(2);
-	}
-
-	SDL_CameraSpec spec;
-	if (SDL_GetCameraFormat(_camera.get(), &spec) < 0) {
-		// meh
-	} else {
-		// interval
-		float interval = float(spec.interval_numerator)/float(spec.interval_denominator);
-		std::cout << "camera interval: " << interval*1000 << "ms\n";
-	}
-}
-
-SDLVideoFrameStreamReader::VideoFrame SDLVideoFrameStreamReader::getNextVideoFrameRGBA(void) {
-	if (!static_cast<bool>(_camera)) {
-		return {};
-	}
-
-	Uint64 timestampNS = 0;
-	SDL_Surface* frame_next = SDL_AcquireCameraFrame(_camera.get(), &timestampNS);
-
-	// no new frame yet, or error
-	if (frame_next == nullptr) {
-		//std::cout << "failed acquiring frame\n";
-		return {};
-	}
-
-	// TODO: investigate zero copy
-	_surface = {
-		SDL_ConvertSurfaceFormat(frame_next, SDL_PIXELFORMAT_RGBA8888),
-		&SDL_DestroySurface
-	};
-
-	SDL_ReleaseCameraFrame(_camera.get(), frame_next);
-
-	SDL_LockSurface(_surface.get());
-
-	return {
-		_surface->w,
-		_surface->h,
-		timestampNS,
-		{
-			reinterpret_cast<const uint8_t*>(_surface->pixels),
-			uint64_t(_surface->w*_surface->h*4) // rgba
-		}
-	};
-}
-
-int64_t SDLVideoFrameStreamReader::have(void) {
-	return -1;
-}
-
-ByteSpan SDLVideoFrameStreamReader::getNext(void) {
-	return {};
-}
-

src/content/stream_reader_sdl_video.hpp

@@ -1,34 +0,0 @@
-#pragma once
-
-#include "./stream_reader.hpp"
-
-#include <SDL3/SDL.h>
-
-#include <cstdint>
-#include <cstdio>
-#include <memory>
-
-struct SDLVideoFrameStreamReader : public RawFrameStreamReaderI {
-	// meh, empty default
-	std::unique_ptr<SDL_Camera, decltype(&SDL_CloseCamera)> _camera;
-	std::unique_ptr<SDL_Surface, decltype(&SDL_DestroySurface)> _surface;
-
-	SDLVideoFrameStreamReader(void);
-
-	struct VideoFrame {
-		int32_t width {0};
-		int32_t height {0};
-
-		uint64_t timestampNS {0};
-
-		ByteSpan data;
-	};
-
-	// data owned by StreamReader, overwritten by next call to getNext*()
-	VideoFrame getNextVideoFrameRGBA(void);
-
-	public: // interface
-		int64_t have(void) override;
-		ByteSpan getNext(void) override;
-};
-

src/debug_tox_call.cpp

@@ -1,718 +0,0 @@
-#include "./debug_tox_call.hpp"
-
-#include "./stream_manager.hpp"
-#include "./content/audio_stream.hpp"
-#include "./content/sdl_video_frame_stream2.hpp"
-
-#include <SDL3/SDL.h>
-
-#include <imgui/imgui.h>
-
-#include <cstring>
-#include <cstdint>
-
-#include <iostream>
-#include <memory>
-#include <optional>
-
-// fwd
-namespace Message {
-	uint64_t getTimeMS();
-}
-
-static bool isFormatPlanar(SDL_PixelFormat f) {
-	return
-		f == SDL_PIXELFORMAT_YV12 ||
-		f == SDL_PIXELFORMAT_IYUV ||
-		f == SDL_PIXELFORMAT_YUY2 ||
-		f == SDL_PIXELFORMAT_UYVY ||
-		f == SDL_PIXELFORMAT_YVYU ||
-		f == SDL_PIXELFORMAT_NV12 ||
-		f == SDL_PIXELFORMAT_NV21 ||
-		f == SDL_PIXELFORMAT_P010
-	;
-}
-
-static SDL_Surface* convertYUY2_IYUV(SDL_Surface* surf) {
-	if (surf->format != SDL_PIXELFORMAT_YUY2) {
-		return nullptr;
-	}
-	if ((surf->w % 2) != 0) {
-		SDL_SetError("YUY2->IYUV does not support odd widths");
-		// hmmm, we dont handle odd widths
-		return nullptr;
-	}
-
-	SDL_LockSurface(surf);
-
-	SDL_Surface* conv_surf = SDL_CreateSurface(surf->w, surf->h, SDL_PIXELFORMAT_IYUV);
-	SDL_LockSurface(conv_surf);
-
-	// YUY2 is 4:2:2 packed
-	// Y is simple, we just copy it over
-	// U V are double the resolution (vertically), so we avg both
-	// Packed mode: Y0+U0+Y1+V0 (1 plane)
-
-	uint8_t* y_plane = static_cast<uint8_t*>(conv_surf->pixels);
-	uint8_t* u_plane = static_cast<uint8_t*>(conv_surf->pixels) + conv_surf->w*conv_surf->h;
-	uint8_t* v_plane = static_cast<uint8_t*>(conv_surf->pixels) + conv_surf->w*conv_surf->h + (conv_surf->w/2)*(conv_surf->h/2);
-
-	const uint8_t* yuy2_data = static_cast<const uint8_t*>(surf->pixels);
-
-	for (int y = 0; y < surf->h; y++) {
-		for (int x = 0; x < surf->w; x += 2) {
-			// every pixel uses 2 bytes
-			const uint8_t* yuy2_curser = yuy2_data + y*surf->w*2 + x*2;
-			uint8_t src_y0 = yuy2_curser[0];
-			uint8_t src_u = yuy2_curser[1];
-			uint8_t src_y1 = yuy2_curser[2];
-			uint8_t src_v = yuy2_curser[3];
-
-			y_plane[y*conv_surf->w + x] = src_y0;
-			y_plane[y*conv_surf->w + x+1] = src_y1;
-
-			size_t uv_index = (y/2) * (conv_surf->w/2) + x/2;
-			if (y % 2 == 0) {
-				// first write
-				u_plane[uv_index] = src_u;
-				v_plane[uv_index] = src_v;
-			} else {
-				// second write, mix with existing value
-				u_plane[uv_index] = (int(u_plane[uv_index]) + int(src_u)) / 2;
-				v_plane[uv_index] = (int(v_plane[uv_index]) + int(src_v)) / 2;
-			}
-		}
-	}
-
-	SDL_UnlockSurface(conv_surf);
-	SDL_UnlockSurface(surf);
-	return conv_surf;
-}
-
-struct PushConversionQueuedVideoStream : public QueuedFrameStream2<SDLVideoFrame> {
-	SDL_PixelFormat _forced_format {SDL_PIXELFORMAT_IYUV};
-
-	PushConversionQueuedVideoStream(size_t queue_size, bool lossy = true) : QueuedFrameStream2<SDLVideoFrame>(queue_size, lossy) {}
-	~PushConversionQueuedVideoStream(void) {}
-
-	bool push(const SDLVideoFrame& value) override {
-		SDL_Surface* converted_surf = value.surface.get();
-		if (converted_surf->format != _forced_format) {
-			//std::cerr << "DTC: need to convert from " << SDL_GetPixelFormatName(converted_surf->format) << " to SDL_PIXELFORMAT_IYUV\n";
-			if (converted_surf->format == SDL_PIXELFORMAT_YUY2 && _forced_format == SDL_PIXELFORMAT_IYUV) {
-				// optimized custom impl
-
-				//auto start = Message::getTimeMS();
-				converted_surf = convertYUY2_IYUV(converted_surf);
-				//auto end = Message::getTimeMS();
-				// 3ms
-				//std::cerr << "DTC: timing " << SDL_GetPixelFormatName(converted_surf->format) << "->SDL_PIXELFORMAT_IYUV: " << end-start << "ms\n";
-			} else if (isFormatPlanar(converted_surf->format)) {
-				// meh, need to convert to rgb as a stopgap
-
-				//auto start = Message::getTimeMS();
-				//SDL_Surface* tmp_conv_surf = SDL_ConvertSurfaceAndColorspace(converted_surf, SDL_PIXELFORMAT_RGBA32, nullptr, SDL_COLORSPACE_RGB_DEFAULT, 0);
-				SDL_Surface* tmp_conv_surf = SDL_ConvertSurfaceAndColorspace(converted_surf, SDL_PIXELFORMAT_RGB24, nullptr, SDL_COLORSPACE_RGB_DEFAULT, 0);
-				//auto end = Message::getTimeMS();
-				// 1ms
-				//std::cerr << "DTC: timing " << SDL_GetPixelFormatName(converted_surf->format) << "->SDL_PIXELFORMAT_RGB24: " << end-start << "ms\n";
-
-				// TODO: fix sdl rgb->yuv conversion resulting in too dark (colorspace) issues
-				//start = Message::getTimeMS();
-				converted_surf = SDL_ConvertSurfaceAndColorspace(tmp_conv_surf, SDL_PIXELFORMAT_IYUV, nullptr, SDL_COLORSPACE_YUV_DEFAULT, 0);
-				//end = Message::getTimeMS();
-				// 60ms
-				//std::cerr << "DTC: timing SDL_PIXELFORMAT_RGB24->SDL_PIXELFORMAT_IYUV: " << end-start << "ms\n";
-
-				SDL_DestroySurface(tmp_conv_surf);
-			} else {
-				converted_surf = SDL_ConvertSurface(converted_surf, SDL_PIXELFORMAT_IYUV);
-			}
-
-			if (converted_surf == nullptr) {
-				// oh god
-				std::cerr << "DTC error: failed to convert surface to IYUV: " << SDL_GetError() << "\n";
-				return false;
-			}
-		}
-		assert(converted_surf != nullptr);
-		if (converted_surf != value.surface.get()) {
-			// TODO: add ctr with uptr
-			SDLVideoFrame new_value{value.timestampUS, nullptr};
-			new_value.surface = {
-				converted_surf,
-				&SDL_DestroySurface
-			};
-
-			return QueuedFrameStream2<SDLVideoFrame>::push(std::move(new_value));
-		} else {
-			return QueuedFrameStream2<SDLVideoFrame>::push(value);
-		}
-	}
-};
-
-// exlusive
-// TODO: replace with something better than a queue
-struct ToxAVCallVideoSink : public FrameStream2SinkI<SDLVideoFrame> {
-	ToxAV& _toxav;
-
-	// bitrate for enabled state
-	uint32_t _video_bitrate {2};
-
-	uint32_t _fid;
-	std::shared_ptr<PushConversionQueuedVideoStream> _writer;
-
-	ToxAVCallVideoSink(ToxAV& toxav, uint32_t fid) : _toxav(toxav), _fid(fid) {}
-	~ToxAVCallVideoSink(void) {
-		if (_writer) {
-			_writer = nullptr;
-			_toxav.toxavVideoSetBitRate(_fid, 0);
-		}
-	}
-
-	// sink
-	std::shared_ptr<FrameStream2I<SDLVideoFrame>> subscribe(void) override {
-		if (_writer) {
-			// max 1 (exclusive, composite video somewhere else)
-			return nullptr;
-		}
-
-		auto err = _toxav.toxavVideoSetBitRate(_fid, _video_bitrate);
-		if (err != TOXAV_ERR_BIT_RATE_SET_OK) {
-			return nullptr;
-		}
-
-		_writer = std::make_shared<PushConversionQueuedVideoStream>(10, true);
-
-		return _writer;
-	}
-
-	bool unsubscribe(const std::shared_ptr<FrameStream2I<SDLVideoFrame>>& sub) override {
-		if (!sub || !_writer) {
-			// nah
-			return false;
-		}
-
-		if (sub == _writer) {
-			_writer = nullptr;
-
-			/*auto err = */_toxav.toxavVideoSetBitRate(_fid, 0);
-			// print warning? on error?
-
-			return true;
-		}
-
-		// what
-		return false;
-	}
-};
-
-// TODO: make proper adapter
-struct AudioStreamReFramer {
-	FrameStream2I<AudioFrame>* _stream {nullptr};
-	uint32_t frame_length_ms {10};
-
-	uint32_t own_seq_counter {0};
-
-	std::vector<int16_t> buffer;
-	size_t samples_in_buffer {0}; // absolute, so divide by ch for actual length
-
-	uint32_t seq {0};
-	uint32_t sample_rate {48'000};
-	size_t channels {0};
-
-
-	std::optional<AudioFrame> pop(void) {
-		assert(_stream != nullptr);
-
-		auto new_in = _stream->pop();
-		if (new_in.has_value()) {
-			auto& new_value = new_in.value();
-			assert(new_value.isS16());
-			if (!new_value.isS16()) {
-				return std::nullopt;
-			}
-
-			if (
-				(buffer.empty()) || // buffer not yet inited
-				(sample_rate != new_value.sample_rate || channels != new_value.channels) // not the same
-			) {
-				seq = 0;
-				sample_rate = new_value.sample_rate;
-				channels = new_value.channels;
-
-				// buffer does not exist or config changed and we discard
-				// preallocate to 2x desired buffer size
-				buffer = std::vector<int16_t>(2 * (channels*sample_rate*frame_length_ms)/1000);
-				samples_in_buffer = 0;
-			}
-
-			// TODO: this will be very important in the future
-			// replace seq with timestapsUS like video??
-#if 0
-			// some time / seq comparison shit
-			if (seq != 0 && new_value.seq != 0) {
-				if (seq+1 != new_value.seq) {
-					// we skipped shit
-					// TODO: insert silence to pad?
-
-					// drop existing
-					samples_in_buffer = 0;
-				}
-			}
-#endif
-
-			// update to latest
-			seq = new_value.seq;
-
-
-			auto new_span = new_value.getSpan<int16_t>();
-
-			//std::cout << "new incoming frame is " << new_value.getSpan<int16_t>().size/new_value.channels*1000/new_value.sample_rate << "ms\n";
-
-			// now append
-			// buffer too small
-			if (buffer.size() - samples_in_buffer < new_value.getSpan<int16_t>().size) {
-				buffer.resize(buffer.size() + new_value.getSpan<int16_t>().size - (buffer.size() - samples_in_buffer));
-			}
-
-			// TODO: memcpy
-			for (size_t i = 0; i < new_span.size; i++) {
-				buffer.at(samples_in_buffer+i) = new_span[i];
-			}
-			samples_in_buffer += new_span.size;
-		} else if (buffer.empty() || samples_in_buffer == 0) {
-			// first pop might result in invalid state
-			return std::nullopt;
-		}
-
-		const size_t desired_size {frame_length_ms * sample_rate * channels / 1000};
-
-		// > threshold?
-		if (samples_in_buffer < desired_size) {
-			return std::nullopt;
-		}
-
-		std::vector<int16_t> return_buffer(desired_size);
-		// copy data
-		for (size_t i = 0; i < return_buffer.size(); i++) {
-			return_buffer.at(i) = buffer.at(i);
-		}
-
-		// now crop buffer (meh)
-		// move data from back to front
-		for (size_t i = 0; i < samples_in_buffer-return_buffer.size(); i++) {
-			buffer.at(i) = buffer.at(desired_size + i);
-		}
-		samples_in_buffer -= return_buffer.size();
-
-		return AudioFrame{
-			own_seq_counter++,
-			sample_rate,
-			channels,
-			std::move(return_buffer),
-		};
-	}
-};
-
-struct ToxAVCallAudioSink : public FrameStream2SinkI<AudioFrame> {
-	ToxAV& _toxav;
-
-	// bitrate for enabled state
-	uint32_t _audio_bitrate {32};
-
-	uint32_t _fid;
-	std::shared_ptr<QueuedFrameStream2<AudioFrame>> _writer;
-
-	ToxAVCallAudioSink(ToxAV& toxav, uint32_t fid) : _toxav(toxav), _fid(fid) {}
-	~ToxAVCallAudioSink(void) {
-		if (_writer) {
-			_writer = nullptr;
-			_toxav.toxavAudioSetBitRate(_fid, 0);
-		}
-	}
-
-	// sink
-	std::shared_ptr<FrameStream2I<AudioFrame>> subscribe(void) override {
-		if (_writer) {
-			// max 1 (exclusive for now)
-			return nullptr;
-		}
-
-		auto err = _toxav.toxavAudioSetBitRate(_fid, _audio_bitrate);
-		if (err != TOXAV_ERR_BIT_RATE_SET_OK) {
-			return nullptr;
-		}
-
-		_writer = std::make_shared<QueuedFrameStream2<AudioFrame>>(16, false);
-
-		return _writer;
-	}
-
-	bool unsubscribe(const std::shared_ptr<FrameStream2I<AudioFrame>>& sub) override {
-		if (!sub || !_writer) {
-			// nah
-			return false;
-		}
-
-		if (sub == _writer) {
-			_writer = nullptr;
-
-			/*auto err = */_toxav.toxavAudioSetBitRate(_fid, 0);
-			// print warning? on error?
-
-			return true;
-		}
-
-		// what
-		return false;
-	}
-};
-
-DebugToxCall::DebugToxCall(ObjectStore2& os, ToxAV& toxav, TextureUploaderI& tu) : _os(os), _toxav(toxav), _tu(tu) {
-	_toxav.subscribe(this, ToxAV_Event::friend_call);
-	_toxav.subscribe(this, ToxAV_Event::friend_call_state);
-	_toxav.subscribe(this, ToxAV_Event::friend_audio_bitrate);
-	_toxav.subscribe(this, ToxAV_Event::friend_video_bitrate);
-	_toxav.subscribe(this, ToxAV_Event::friend_audio_frame);
-	_toxav.subscribe(this, ToxAV_Event::friend_video_frame);
-}
-
-DebugToxCall::~DebugToxCall(void) {
-	// destroy all calls/connections/sources/sinks here
-
-	for (auto& [fid, call] : _calls) {
-		if (static_cast<bool>(call.incoming_vsrc)) {
-			_os.throwEventDestroy(call.incoming_vsrc);
-			call.incoming_vsrc.destroy();
-		}
-		if (static_cast<bool>(call.incoming_asrc)) {
-			_os.throwEventDestroy(call.incoming_asrc);
-			call.incoming_asrc.destroy();
-		}
-		if (static_cast<bool>(call.outgoing_vsink)) {
-			_os.throwEventDestroy(call.outgoing_vsink);
-			call.outgoing_vsink.destroy();
-		}
-		if (static_cast<bool>(call.outgoing_asink)) {
-			_os.throwEventDestroy(call.outgoing_asink);
-			call.outgoing_asink.destroy();
-		}
-	}
-}
-
-void DebugToxCall::tick(float) {
-	// pump sinks to tox
-	// TODO: own thread or direct on push (requires thread save toxcore)
-	// TODO: pump at double the frame rate
-	for (const auto& [oc, vsink] : _os.registry().view<ToxAVCallVideoSink*>().each()) {
-		if (!vsink->_writer) {
-			continue;
-		}
-
-		for (size_t i = 0; i < 10; i++) {
-			auto new_frame_opt = vsink->_writer->pop();
-			if (!new_frame_opt.has_value()) {
-				break;
-			}
-
-			if (!new_frame_opt.value().surface) {
-				// wtf?
-				continue;
-			}
-
-			// conversion is done in the sinks stream
-			SDL_Surface* surf = new_frame_opt.value().surface.get();
-			assert(surf != nullptr);
-
-			SDL_LockSurface(surf);
-			_toxav.toxavVideoSendFrame(
-				vsink->_fid,
-				surf->w, surf->h,
-				static_cast<const uint8_t*>(surf->pixels),
-				static_cast<const uint8_t*>(surf->pixels) + surf->w * surf->h,
-				static_cast<const uint8_t*>(surf->pixels) + surf->w * surf->h + (surf->w/2) * (surf->h/2)
-			);
-			SDL_UnlockSurface(surf);
-		}
-	}
-
-	for (const auto& [oc, asink, asrf] : _os.registry().view<ToxAVCallAudioSink*, AudioStreamReFramer>().each()) {
-		if (!asink->_writer) {
-			continue;
-		}
-
-		asrf._stream = asink->_writer.get();
-
-		for (size_t i = 0; i < 10; i++) {
-			//auto new_frame_opt = asink->_writer->pop();
-			auto new_frame_opt = asrf.pop();
-			if (!new_frame_opt.has_value()) {
-				break;
-			}
-			const auto& new_frame = new_frame_opt.value();
-			assert(new_frame.isS16());
-
-//* @param sample_count Number of samples in this frame. Valid numbers here are
-//*   `((sample rate) * (audio length) / 1000)`, where audio length can be
-//*   2.5, 5, 10, 20, 40 or 60 milliseconds.
-
-			// we likely needs to subdivide/repackage
-			// frame size should be an option exposed to the user
-			// with 10ms as a default ?
-			// the larger the frame size, the less overhead but the more delay
-
-			auto err = _toxav.toxavAudioSendFrame(
-				asink->_fid,
-				new_frame.getSpan<int16_t>().ptr,
-				new_frame.getSpan<int16_t>().size / new_frame.channels,
-				new_frame.channels,
-				new_frame.sample_rate
-			);
-			if (err != TOXAV_ERR_SEND_FRAME_OK) {
-				std::cerr << "DTC: failed to send audio frame " << err << "\n";
-			}
-		}
-	}
-}
-
-float DebugToxCall::render(void) {
-	float next_frame {2.f};
-	if (ImGui::Begin("toxav debug")) {
-		ImGui::Text("Calls:");
-		ImGui::Indent();
-		for (auto& [fid, call] : _calls) {
-			ImGui::PushID(fid);
-
-			ImGui::Text("fid:%d state:%d", fid, call.state);
-			if (call.incoming) {
-				ImGui::SameLine();
-				if (ImGui::SmallButton("answer")) {
-					const auto ret = _toxav.toxavAnswer(fid, 0, 0);
-					//const auto ret = _toxav.toxavAnswer(fid, 0, 1); // 1mbit/s
-					//const auto ret = _toxav.toxavAnswer(fid, 0, 2); // 2mbit/s
-					//const auto ret = _toxav.toxavAnswer(fid, 0, 100); // 100mbit/s
-					//const auto ret = _toxav.toxavAnswer(fid, 0, 2500); // 2500mbit/s
-					if (ret == TOXAV_ERR_ANSWER_OK) {
-						call.incoming = false;
-
-						// create sinks
-						call.outgoing_vsink = {_os.registry(), _os.registry().create()};
-						{
-							auto new_vsink = std::make_unique<ToxAVCallVideoSink>(_toxav, fid);
-							call.outgoing_vsink.emplace<ToxAVCallVideoSink*>(new_vsink.get());
-							call.outgoing_vsink.emplace<Components::FrameStream2Sink<SDLVideoFrame>>(std::move(new_vsink));
-							call.outgoing_vsink.emplace<Components::StreamSink>(Components::StreamSink::create<SDLVideoFrame>("ToxAV Friend Call Outgoing Video"));
-							_os.throwEventConstruct(call.outgoing_vsink);
-						}
-						call.outgoing_asink = {_os.registry(), _os.registry().create()};
-						{
-							auto new_asink = std::make_unique<ToxAVCallAudioSink>(_toxav, fid);
-							call.outgoing_asink.emplace<ToxAVCallAudioSink*>(new_asink.get());
-							call.outgoing_asink.emplace<AudioStreamReFramer>().frame_length_ms = 10;
-							call.outgoing_asink.emplace<Components::FrameStream2Sink<AudioFrame>>(std::move(new_asink));
-							call.outgoing_asink.emplace<Components::StreamSink>(Components::StreamSink::create<AudioFrame>("ToxAV Friend Call Outgoing Audio"));
-							_os.throwEventConstruct(call.outgoing_asink);
-						}
-
-						// create sources
-						if (call.incoming_v) {
-							call.incoming_vsrc = {_os.registry(), _os.registry().create()};
-							{
-								auto new_vsrc = std::make_unique<SDLVideoFrameStream2MultiSource>();
-								call.incoming_vsrc.emplace<SDLVideoFrameStream2MultiSource*>(new_vsrc.get());
-								call.incoming_vsrc.emplace<Components::FrameStream2Source<SDLVideoFrame>>(std::move(new_vsrc));
-								call.incoming_vsrc.emplace<Components::StreamSource>(Components::StreamSource::create<SDLVideoFrame>("ToxAV Friend Call Incoming Video"));
-								_os.throwEventConstruct(call.incoming_vsrc);
-							}
-						}
-						if (call.incoming_a) {
-							call.incoming_asrc = {_os.registry(), _os.registry().create()};
-							{
-								auto new_asrc = std::make_unique<AudioFrameStream2MultiSource>();
-								call.incoming_asrc.emplace<AudioFrameStream2MultiSource*>(new_asrc.get());
-								call.incoming_asrc.emplace<Components::FrameStream2Source<AudioFrame>>(std::move(new_asrc));
-								call.incoming_asrc.emplace<Components::StreamSource>(Components::StreamSource::create<AudioFrame>("ToxAV Friend Call Incoming Audio"));
-								_os.throwEventConstruct(call.incoming_asrc);
-							}
-						}
-					}
-				}
-			} else if (call.state != TOXAV_FRIEND_CALL_STATE_FINISHED) {
-				next_frame = std::min(next_frame, 0.1f);
-				ImGui::SameLine();
-				if (ImGui::SmallButton("hang up")) {
-					const auto ret = _toxav.toxavCallControl(fid, TOXAV_CALL_CONTROL_CANCEL);
-					if (ret == TOXAV_ERR_CALL_CONTROL_OK) {
-						// we hung up
-						// not sure if its possible for toxcore to tell this us too when the other side does this at the same time?
-						call.state = TOXAV_FRIEND_CALL_STATE_FINISHED;
-
-						// TODO: stream manager disconnectAll()
-						if (static_cast<bool>(call.incoming_vsrc)) {
-							_os.throwEventDestroy(call.incoming_vsrc);
-							call.incoming_vsrc.destroy();
-						}
-						if (static_cast<bool>(call.incoming_asrc)) {
-							_os.throwEventDestroy(call.incoming_asrc);
-							call.incoming_asrc.destroy();
-						}
-						if (static_cast<bool>(call.outgoing_vsink)) {
-							_os.throwEventDestroy(call.outgoing_vsink);
-							call.outgoing_vsink.destroy();
-						}
-						if (static_cast<bool>(call.outgoing_asink)) {
-							_os.throwEventDestroy(call.outgoing_asink);
-							call.outgoing_asink.destroy();
-						}
-					}
-				}
-
-				//if (ImGui::BeginCombo("audio src", "---")) {
-				//    ImGui::EndCombo();
-				//}
-				//if (ImGui::BeginCombo("video src", "---")) {
-				//    ImGui::EndCombo();
-				//}
-			}
-
-			ImGui::PopID();
-		}
-		ImGui::Unindent();
-	}
-	ImGui::End();
-
-	return next_frame;
-}
-
-bool DebugToxCall::onEvent(const Events::FriendCall& e)  {
-	auto& call = _calls[e.friend_number];
-	call.incoming = true;
-	call.incoming_a = e.audio_enabled;
-	call.incoming_v = e.video_enabled;
-	call.state = TOXAV_FRIEND_CALL_STATE_NONE;
-
-	return true;
-}
-
-bool DebugToxCall::onEvent(const Events::FriendCallState& e)  {
-	auto& call = _calls[e.friend_number];
-	call.state = e.state;
-
-	if (
-		(call.state & TOXAV_FRIEND_CALL_STATE_FINISHED) != 0 ||
-		(call.state & TOXAV_FRIEND_CALL_STATE_ERROR) != 0
-	) {
-		if (static_cast<bool>(call.incoming_vsrc)) {
-			_os.throwEventDestroy(call.incoming_vsrc);
-			call.incoming_vsrc.destroy();
-		}
-		if (static_cast<bool>(call.incoming_asrc)) {
-			_os.throwEventDestroy(call.incoming_asrc);
-			call.incoming_asrc.destroy();
-		}
-		if (static_cast<bool>(call.outgoing_vsink)) {
-			_os.throwEventDestroy(call.outgoing_vsink);
-			call.outgoing_vsink.destroy();
-		}
-		if (static_cast<bool>(call.outgoing_asink)) {
-			_os.throwEventDestroy(call.outgoing_asink);
-			call.outgoing_asink.destroy();
-		}
-	}
-
-	return true;
-}
-
-bool DebugToxCall::onEvent(const Events::FriendAudioBitrate&)  {
-	return false;
-}
-
-bool DebugToxCall::onEvent(const Events::FriendVideoBitrate&)  {
-	return false;
-}
-
-bool DebugToxCall::onEvent(const Events::FriendAudioFrame& e)  {
-	auto& call = _calls[e.friend_number];
-
-	if (!static_cast<bool>(call.incoming_asrc)) {
-		// missing src to put frame into ??
-		return false;
-	}
-
-	assert(call.incoming_asrc.all_of<AudioFrameStream2MultiSource*>());
-	assert(call.incoming_asrc.all_of<Components::FrameStream2Source<AudioFrame>>());
-
-	call.num_a_frames++;
-
-	call.incoming_asrc.get<AudioFrameStream2MultiSource*>()->push(AudioFrame{
-		0, //seq
-		e.sampling_rate,
-		e.channels,
-		std::vector<int16_t>(e.pcm.begin(), e.pcm.end()) // copy
-	});
-
-	return true;
-}
-
-bool DebugToxCall::onEvent(const Events::FriendVideoFrame& e)  {
-	// TODO: skip if we dont know about this call
-	auto& call = _calls[e.friend_number];
-
-	if (!static_cast<bool>(call.incoming_vsrc)) {
-		// missing src to put frame into ??
-		return false;
-	}
-
-	assert(call.incoming_vsrc.all_of<SDLVideoFrameStream2MultiSource*>());
-	assert(call.incoming_vsrc.all_of<Components::FrameStream2Source<SDLVideoFrame>>());
-
-	call.num_v_frames++;
-
-	auto* new_surf = SDL_CreateSurface(e.width, e.height, SDL_PIXELFORMAT_IYUV);
-	assert(new_surf);
-	if (SDL_LockSurface(new_surf)) {
-		// copy the data
-		// we know how the implementation works, its y u v consecutivlely
-		// y
-		for (size_t y = 0; y < e.height; y++) {
-			std::memcpy(
-				//static_cast<uint8_t*>(new_surf->pixels) + new_surf->pitch*y,
-				static_cast<uint8_t*>(new_surf->pixels) + e.width*y,
-				e.y.ptr + e.ystride*y,
-				e.width
-			);
-		}
-
-		// u
-		for (size_t y = 0; y < e.height/2; y++) {
-			std::memcpy(
-				static_cast<uint8_t*>(new_surf->pixels) + (e.width*e.height) + (e.width/2)*y,
-				e.u.ptr + e.ustride*y,
-				e.width/2
-			);
-		}
-
-		// v
-		for (size_t y = 0; y < e.height/2; y++) {
-			std::memcpy(
-				static_cast<uint8_t*>(new_surf->pixels) + (e.width*e.height) + ((e.width/2)*(e.height/2)) + (e.width/2)*y,
-				e.v.ptr + e.vstride*y,
-				e.width/2
-			);
-		}
-
-		SDL_UnlockSurface(new_surf);
-	}
-
-	call.incoming_vsrc.get<SDLVideoFrameStream2MultiSource*>()->push({
-		// ms -> us
-		Message::getTimeMS() * 1000, // TODO: make more precise
-		new_surf
-	});
-
-	SDL_DestroySurface(new_surf);
-
-	return true;
-}
-

src/debug_tox_call.hpp

@@ -1,52 +0,0 @@
-#pragma once
-
-//#include <solanaceae/object_store/fwd.hpp>
-#include <solanaceae/object_store/object_store.hpp>
-#include "./tox_av.hpp"
-#include "./texture_uploader.hpp"
-
-#include <map>
-#include <cstdint>
-
-class DebugToxCall : public ToxAVEventI {
-	ObjectStore2& _os;
-	ToxAV& _toxav;
-	TextureUploaderI& _tu;
-
-	struct Call {
-		bool incoming {false};
-		bool incoming_a {false};
-		bool incoming_v {false};
-
-		uint32_t state {0}; // ? just last state ?
-
-		uint32_t incomming_abr {0};
-		uint32_t incomming_vbr {0};
-
-		size_t num_a_frames {0};
-		size_t num_v_frames {0};
-
-		ObjectHandle incoming_vsrc;
-		ObjectHandle incoming_asrc;
-
-		ObjectHandle outgoing_vsink;
-		ObjectHandle outgoing_asink;
-	};
-	// tox friend id -> call
-	std::map<uint32_t, Call> _calls;
-
-	public:
-		DebugToxCall(ObjectStore2& os, ToxAV& toxav, TextureUploaderI& tu);
-		~DebugToxCall(void);
-
-		void tick(float time_delta);
-		float render(void);
-
-	protected: // toxav events
-		bool onEvent(const Events::FriendCall&) override;
-		bool onEvent(const Events::FriendCallState&) override;
-		bool onEvent(const Events::FriendAudioBitrate&) override;
-		bool onEvent(const Events::FriendVideoBitrate&) override;
-		bool onEvent(const Events::FriendAudioFrame&) override;
-		bool onEvent(const Events::FriendVideoFrame&) override;
-};

src/debug_video_tap.cpp

@@ -1,210 +0,0 @@
-#include "./debug_video_tap.hpp"
-
-#include <solanaceae/object_store/object_store.hpp>
-
-#include <entt/entity/entity.hpp>
-
-#include <SDL3/SDL.h>
-
-#include <imgui/imgui.h>
-
-#include "./content/sdl_video_frame_stream2.hpp"
-
-#include <string>
-#include <memory>
-#include <iostream>
-
-struct DebugVideoTapSink : public FrameStream2SinkI<SDLVideoFrame> {
-	std::shared_ptr<QueuedFrameStream2<SDLVideoFrame>> _writer;
-
-	DebugVideoTapSink(void) {}
-	~DebugVideoTapSink(void) {}
-
-	// sink
-	std::shared_ptr<FrameStream2I<SDLVideoFrame>> subscribe(void) override {
-		if (_writer) {
-			// max 1 (exclusive)
-			return nullptr;
-		}
-
-		_writer = std::make_shared<QueuedFrameStream2<SDLVideoFrame>>(1, true);
-
-		return _writer;
-	}
-
-	bool unsubscribe(const std::shared_ptr<FrameStream2I<SDLVideoFrame>>& sub) override {
-		if (!sub || !_writer) {
-			// nah
-			return false;
-		}
-
-		if (sub == _writer) {
-			_writer =  nullptr;
-			return true;
-		}
-
-		// what
-		return false;
-	}
-};
-
-DebugVideoTap::DebugVideoTap(ObjectStore2& os, StreamManager& sm, TextureUploaderI& tu) : _os(os), _sm(sm), _tu(tu) {
-	// post self as video sink
-	_tap = {_os.registry(), _os.registry().create()};
-	try {
-		auto dvts = std::make_unique<DebugVideoTapSink>();
-		_tap.emplace<DebugVideoTapSink*>(dvts.get()); // to get our data back
-		_tap.emplace<Components::FrameStream2Sink<SDLVideoFrame>>(
-			std::move(dvts)
-		);
-
-		_tap.emplace<Components::StreamSink>(Components::StreamSink::create<SDLVideoFrame>("DebugVideoTap"));
-	} catch (...) {
-		_os.registry().destroy(_tap);
-	}
-}
-
-DebugVideoTap::~DebugVideoTap(void) {
-	if (static_cast<bool>(_tap)) {
-		_os.registry().destroy(_tap);
-	}
-}
-
-float DebugVideoTap::render(void) {
-	if (ImGui::Begin("DebugVideoTap")) {
-		{ // first pull the latest img from sink and update the texture
-			assert(static_cast<bool>(_tap));
-
-			auto& dvtsw = _tap.get<DebugVideoTapSink*>()->_writer;
-			if (dvtsw) {
-				while (true) {
-					auto new_frame_opt = dvtsw->pop();
-					if (new_frame_opt.has_value()) {
-						// timing
-						if (_v_last_ts == 0) {
-							_v_last_ts = new_frame_opt.value().timestampUS;
-						} else {
-							auto delta = int64_t(new_frame_opt.value().timestampUS) - int64_t(_v_last_ts);
-							_v_last_ts = new_frame_opt.value().timestampUS;
-
-							//delta = std::min<int64_t>(delta, 10*1000*1000);
-
-							if (_v_interval_avg == 0) {
-								_v_interval_avg = delta/1'000'000.f;
-							} else {
-								const float r = 0.2f;
-								_v_interval_avg = _v_interval_avg * (1.f-r) + (delta/1'000'000.f) * r;
-							}
-						}
-
-						SDL_Surface* new_frame_surf = new_frame_opt.value().surface.get();
-
-						SDL_Surface* converted_surf = new_frame_surf;
-						if (new_frame_surf->format != SDL_PIXELFORMAT_RGBA32) {
-							// we need to convert
-							//std::cerr << "DVT: need to convert\n";
-							converted_surf = SDL_ConvertSurfaceAndColorspace(new_frame_surf, SDL_PIXELFORMAT_RGBA32, nullptr, SDL_COLORSPACE_RGB_DEFAULT, 0);
-							assert(converted_surf->format == SDL_PIXELFORMAT_RGBA32);
-						}
-
-						SDL_LockSurface(converted_surf);
-						if (_tex == 0 || (int)_tex_w != converted_surf->w || (int)_tex_h != converted_surf->h) {
-							_tu.destroy(_tex);
-							_tex = _tu.uploadRGBA(
-								static_cast<const uint8_t*>(converted_surf->pixels),
-								converted_surf->w,
-								converted_surf->h,
-								TextureUploaderI::LINEAR,
-								TextureUploaderI::STREAMING
-							);
-
-							_tex_w = converted_surf->w;
-							_tex_h = converted_surf->h;
-						} else {
-							_tu.updateRGBA(_tex, static_cast<const uint8_t*>(converted_surf->pixels), converted_surf->w * converted_surf->h * 4);
-						}
-						SDL_UnlockSurface(converted_surf);
-
-						if (new_frame_surf != converted_surf) {
-							// clean up temp
-							SDL_DestroySurface(converted_surf);
-						}
-					} else {
-						break;
-					}
-				}
-			}
-		}
-
-		// list sources dropdown to connect too
-		std::string preview_label {"none"};
-		if (static_cast<bool>(_selected_src)) {
-			preview_label = std::to_string(entt::to_integral(entt::to_entity(_selected_src.entity()))) + " (" + _selected_src.get<Components::StreamSource>().name + ")";
-		}
-
-		if (ImGui::BeginCombo("selected source", preview_label.c_str())) {
-			if (ImGui::Selectable("none")) {
-				switchTo({});
-			}
-
-			for (const auto& [oc, ss] : _os.registry().view<Components::StreamSource>().each()) {
-				if (ss.frame_type_name != entt::type_name<SDLVideoFrame>::value()) {
-					continue;
-				}
-				std::string label = std::to_string(entt::to_integral(entt::to_entity(oc))) + " (" + ss.name + ")";
-				if (ImGui::Selectable(label.c_str())) {
-					switchTo({_os.registry(), oc});
-				}
-			}
-
-			ImGui::EndCombo();
-		}
-
-		//ImGui::SetNextItemWidth(0);
-		ImGui::Checkbox("mirror", &_mirror);
-
-		// img here
-		if (_tex != 0) {
-			ImGui::SameLine();
-			ImGui::Text("moving avg interval: %f", _v_interval_avg);
-			const float img_w = ImGui::GetContentRegionAvail().x;
-			ImGui::Image(
-				reinterpret_cast<ImTextureID>(_tex),
-				ImVec2{img_w, img_w * float(_tex_h)/_tex_w},
-				ImVec2{_mirror?1.f:0.f, 0},
-				ImVec2{_mirror?0.f:1.f, 1}
-			);
-		}
-	}
-	ImGui::End();
-
-	if (_v_interval_avg != 0) {
-		return _v_interval_avg;
-	} else {
-		return 2.f;
-	}
-}
-
-void DebugVideoTap::switchTo(ObjectHandle o) {
-	if (o == _selected_src) {
-		std::cerr << "DVT: switch to same ...\n";
-		return;
-	}
-
-	_tu.destroy(_tex);
-	_tex = 0;
-	_v_last_ts = 0;
-	_v_interval_avg = 0;
-
-	if (static_cast<bool>(_selected_src)) {
-		_sm.disconnect<SDLVideoFrame>(_selected_src, _tap);
-	}
-
-	if (static_cast<bool>(o) && _sm.connect<SDLVideoFrame>(o, _tap)) {
-		_selected_src = o;
-	} else {
-		std::cerr << "DVT: cleared video source\n";
-		_selected_src = {};
-	}
-}
-

src/debug_video_tap.hpp

@@ -1,34 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <solanaceae/object_store/fwd.hpp>
-#include "./stream_manager.hpp"
-#include "./texture_uploader.hpp"
-
-// provides a sink and a small window displaying a SDLVideoFrame
-class DebugVideoTap {
-	ObjectStore2& _os;
-	StreamManager& _sm;
-	TextureUploaderI& _tu;
-
-	ObjectHandle _selected_src;
-	ObjectHandle _tap;
-
-	uint64_t _tex {0};
-	uint32_t _tex_w {0};
-	uint32_t _tex_h {0};
-
-	bool _mirror {false}; // flip horizontally
-
-	uint64_t _v_last_ts {0}; // us
-	float _v_interval_avg {0.f}; // s
-
-	public:
-		DebugVideoTap(ObjectStore2& os, StreamManager& sm, TextureUploaderI& tu);
-		~DebugVideoTap(void);
-
-		float render(void);
-
-		void switchTo(ObjectHandle o);
-};
-

src/main.cpp

@@ -12,9 +12,6 @@
 
 #include "./start_screen.hpp"
 
-#include "./content/sdl_video_frame_stream2.hpp"
-#include "./content/sdl_audio_frame_stream2.hpp"
-
 #include <filesystem>
 #include <memory>
 #include <iostream>
@@ -38,7 +35,7 @@ int main(int argc, char** argv) {
 
 	// setup hints
 #ifndef __ANDROID__
-	if (!SDL_SetHint(SDL_HINT_VIDEO_ALLOW_SCREENSAVER, "1")) {
+	if (SDL_SetHint(SDL_HINT_VIDEO_ALLOW_SCREENSAVER, "1") != SDL_TRUE) {
 		std::cerr << "Failed to set '" << SDL_HINT_VIDEO_ALLOW_SCREENSAVER << "' to 1\n";
 	}
 #endif
@@ -75,51 +72,10 @@ int main(int argc, char** argv) {
 
 	std::cout << "SDL Renderer: " << SDL_GetRendererName(renderer.get()) << "\n";
 
-	// optionally init audio and camera
-	if (!SDL_Init(SDL_INIT_AUDIO)) {
-		std::cerr << "SDL_Init AUDIO failed (" << SDL_GetError() << ")\n";
-	} else if (false) {
-		SDLAudioInputDevice aid;
-		auto reader = aid.subscribe();
-
-		auto writer = SDLAudioOutputDeviceDefaultSink{}.subscribe();
-
-		for (size_t i = 0; i < 200; i++) {
-			std::this_thread::sleep_for(std::chrono::milliseconds(10));
-			auto new_frame_opt = reader->pop();
-			if (new_frame_opt.has_value()) {
-				std::cout << "audio frame was seq:" << new_frame_opt.value().seq << " sr:" << new_frame_opt.value().sample_rate << " " << (new_frame_opt.value().isS16()?"S16":"F32") << " l:" << (new_frame_opt.value().isS16()?new_frame_opt.value().getSpan<int16_t>().size:new_frame_opt.value().getSpan<float>().size) << "\n";
-				writer->push(new_frame_opt.value());
-			} else {
-				std::cout << "no audio frame\n";
-			}
-		}
-
-		aid.unsubscribe(reader);
-	}
-
-	if (!SDL_Init(SDL_INIT_CAMERA)) {
-		std::cerr << "SDL_Init CAMERA failed (" << SDL_GetError() << ")\n";
-	} else if (false) { // HACK
-		std::cerr << "CAMERA initialized\n";
-		SDLVideoCameraContent vcc;
-		auto reader = vcc.subscribe();
-		for (size_t i = 0; i < 20; i++) {
-			std::this_thread::sleep_for(std::chrono::milliseconds(50));
-			auto new_frame_opt = reader->pop();
-			if (new_frame_opt.has_value()) {
-				std::cout << "video frame was " << new_frame_opt.value().surface->w << "x" << new_frame_opt.value().surface->h << " " << new_frame_opt.value().timestampUS << "us " << new_frame_opt.value().surface->format << "sf\n";
-			}
-		}
-		vcc.unsubscribe(reader);
-	}
-	std::cout << "after sdl video stuffery\n";
-
 	IMGUI_CHECKVERSION();
 	ImGui::CreateContext();
 
 	// TODO: test android behaviour
-	// -> its too big, dpi does not take eye-screen-distance into account
 	float display_scale = SDL_GetWindowDisplayScale(window.get());
 	if (display_scale < 0.001f) {
 		// error?

src/main_screen.cpp

@@ -9,11 +9,6 @@
 
 #include <SDL3/SDL.h>
 
-#include "./content/sdl_video_frame_stream2.hpp"
-#include "content/audio_stream.hpp"
-#include "content/sdl_audio_frame_stream2.hpp"
-#include "stream_manager.hpp"
-
 #include <memory>
 #include <cmath>
 #include <string_view>
@@ -24,13 +19,11 @@ MainScreen::MainScreen(SimpleConfigModel&& conf_, SDL_Renderer* renderer_, Theme
 	rmm(cr),
 	msnj{cr, {}, {}},
 	mts(rmm),
-	sm(os),
 	tc(save_path, save_password),
 	tpi(tc.getTox()),
 	ad(tc),
 #if TOMATO_TOX_AV
 	tav(tc.getTox()),
-	dtc(os, tav, sdlrtu),
 #endif
 	tcm(cr, tc, tc),
 	tmm(rmm, cr, tcm, tc, tc),
@@ -47,10 +40,9 @@ MainScreen::MainScreen(SimpleConfigModel&& conf_, SDL_Renderer* renderer_, Theme
 	cg(conf, os, rmm, cr, sdlrtu, contact_tc, msg_tc, theme),
 	sw(conf),
 	osui(os),
-	smui(os, sm),
-	dvt(os, sm, sdlrtu),
 	tuiu(tc, conf),
-	tdch(tpi)
+	tdch(tpi),
+	tnui(tpi)
 {
 	tel.subscribeAll(tc);
 
@@ -145,53 +137,6 @@ MainScreen::MainScreen(SimpleConfigModel&& conf_, SDL_Renderer* renderer_, Theme
 	}
 
 	conf.dump();
-
-	{ // add system av devices
-		if (false) {
-			ObjectHandle vsrc {os.registry(), os.registry().create()};
-			try {
-				vsrc.emplace<Components::FrameStream2Source<SDLVideoFrame>>(
-					std::make_unique<SDLVideoCameraContent>()
-				);
-
-				vsrc.emplace<Components::StreamSource>(Components::StreamSource::create<SDLVideoFrame>("WebCam"));
-
-				os.throwEventConstruct(vsrc);
-			} catch (...) {
-				os.registry().destroy(vsrc);
-			}
-		}
-
-		if (true) { // audio in
-			ObjectHandle asrc {os.registry(), os.registry().create()};
-			try {
-				asrc.emplace<Components::FrameStream2Source<AudioFrame>>(
-					std::make_unique<SDLAudioInputDevice>()
-				);
-
-				asrc.emplace<Components::StreamSource>(Components::StreamSource::create<AudioFrame>("SDL Audio Default Recording Device"));
-
-				os.throwEventConstruct(asrc);
-			} catch (...) {
-				os.registry().destroy(asrc);
-			}
-		}
-
-		{ // audio out
-			ObjectHandle asink {os.registry(), os.registry().create()};
-			try {
-				asink.emplace<Components::FrameStream2Sink<AudioFrame>>(
-					std::make_unique<SDLAudioOutputDeviceDefaultSink>()
-				);
-
-				asink.emplace<Components::StreamSink>(Components::StreamSink::create<AudioFrame>("SDL Audio Default Playback Device"));
-
-				os.throwEventConstruct(asink);
-			} catch (...) {
-				os.registry().destroy(asink);
-			}
-		}
-	}
 }
 
 MainScreen::~MainScreen(void) {
@@ -308,19 +253,15 @@ Screen* MainScreen::render(float time_delta, bool&) {
 	}
 	// ACTUALLY NOT IF RENDERED, MOVED LOGIC TO ABOVE
 	// it might unload textures, so it needs to be done before rendering
-	float animation_interval = contact_tc.update();
-	animation_interval = std::min<float>(animation_interval, msg_tc.update());
+	const float ctc_interval = contact_tc.update();
+	const float msgtc_interval = msg_tc.update();
 
 	const float cg_interval = cg.render(time_delta); // render
 	sw.render(); // render
 	osui.render();
-	smui.render();
-	animation_interval = std::min<float>(animation_interval, dvt.render());
 	tuiu.render(); // render
 	tdch.render(); // render
-#if TOMATO_TOX_AV
-	animation_interval = std::min<float>(animation_interval, dtc.render());
-#endif
+	const float tnui_interval = tnui.render(time_delta);
 
 	{ // main window menubar injection
 		if (ImGui::Begin("tomato")) {
@@ -501,7 +442,9 @@ Screen* MainScreen::render(float time_delta, bool&) {
 
 	// low delay time window
 	if (!_window_hidden && _time_since_event < curr_profile.low_delay_window) {
-		_render_interval = std::min<float>(_render_interval, animation_interval);
+		_render_interval = std::min<float>(_render_interval, ctc_interval);
+		_render_interval = std::min<float>(_render_interval, msgtc_interval);
+		_render_interval = std::min<float>(_render_interval, tnui_interval);
 
 		_render_interval = std::clamp(
 			_render_interval,
@@ -510,7 +453,9 @@ Screen* MainScreen::render(float time_delta, bool&) {
 		);
 	// mid delay time window
 	} else if (!_window_hidden && _time_since_event < curr_profile.mid_delay_window) {
-		_render_interval = std::min<float>(_render_interval, animation_interval);
+		_render_interval = std::min<float>(_render_interval, ctc_interval);
+		_render_interval = std::min<float>(_render_interval, msgtc_interval);
+		_render_interval = std::min<float>(_render_interval, tnui_interval);
 
 		_render_interval = std::clamp(
 			_render_interval,
@@ -535,16 +480,8 @@ Screen* MainScreen::render(float time_delta, bool&) {
 Screen* MainScreen::tick(float time_delta, bool& quit) {
 	quit = !tc.iterate(time_delta); // compute
 
-#if TOMATO_TOX_AV
-	tav.toxavIterate();
-	const float av_interval = tav.toxavIterationInterval()/1000.f;
-	dtc.tick(time_delta);
-#endif
-
 	tcm.iterate(time_delta); // compute
 
-	const float sm_interval = sm.tick(time_delta);
-
 	const float fo_interval = tffom.tick(time_delta);
 
 	tam.iterate(); // compute
@@ -552,6 +489,7 @@ Screen* MainScreen::tick(float time_delta, bool& quit) {
 	const float pm_interval = pm.tick(time_delta); // compute
 
 	tdch.tick(time_delta); // compute
+	tnui.tick(time_delta); // compute
 
 	mts.iterate(); // compute (after mfs)
 
@@ -577,18 +515,6 @@ Screen* MainScreen::tick(float time_delta, bool& quit) {
 		fo_interval
 	);
 
-#if TOMATO_TOX_AV
-	_min_tick_interval = std::min<float>(
-		_min_tick_interval,
-		av_interval
-	);
-#endif
-
-	_min_tick_interval = std::min<float>(
-		_min_tick_interval,
-		sm_interval
-	);
-
 	//std::cout << "MS: min tick interval: " << _min_tick_interval << "\n";
 
 	switch (_compute_perf_mode) {

src/main_screen.hpp

@@ -16,8 +16,6 @@
 #include <solanaceae/tox_messages/tox_message_manager.hpp>
 #include <solanaceae/tox_messages/tox_transfer_manager.hpp>
 
-#include "./stream_manager.hpp"
-
 #include "./tox_client.hpp"
 #include "./auto_dirty.hpp"
 
@@ -32,15 +30,13 @@
 #include "./chat_gui4.hpp"
 #include "./chat_gui/settings_window.hpp"
 #include "./object_store_ui.hpp"
-#include "./stream_manager_ui.hpp"
-#include "./debug_video_tap.hpp"
 #include "./tox_ui_utils.hpp"
 #include "./tox_dht_cap_histo.hpp"
+#include "./tox_netprof_ui.hpp"
 #include "./tox_friend_faux_offline_messaging.hpp"
 
 #if TOMATO_TOX_AV
 #include "./tox_av.hpp"
-#include "./debug_tox_call.hpp"
 #endif
 
 #include <string>
@@ -63,15 +59,12 @@ struct MainScreen final : public Screen {
 	MessageSerializerNJ msnj;
 	MessageTimeSort mts;
 
-	StreamManager sm;
-
 	ToxEventLogger tel{std::cout};
 	ToxClient tc;
 	ToxPrivateImpl tpi;
 	AutoDirty ad;
 #if TOMATO_TOX_AV
 	ToxAV tav;
-	DebugToxCall dtc;
 #endif
 	ToxContactModel2 tcm;
 	ToxMessageManager tmm;
@@ -94,10 +87,9 @@ struct MainScreen final : public Screen {
 	ChatGui4 cg;
 	SettingsWindow sw;
 	ObjectStoreUI osui;
-	StreamManagerUI smui;
-	DebugVideoTap dvt;
 	ToxUIUtils tuiu;
 	ToxDHTCapHisto tdch;
+	ToxNetprofUI tnui;
 
 	PluginManager pm; // last, so it gets destroyed first
 

src/sdlrenderer_texture_uploader.cpp

@@ -32,7 +32,7 @@ uint64_t SDLRendererTextureUploader::uploadRGBA(const uint8_t* data, uint32_t wi
 	SDL_UpdateTexture(tex, nullptr, surf->pixels, surf->pitch);
 
 	SDL_BlendMode surf_blend_mode = SDL_BLENDMODE_NONE;
-	if (SDL_GetSurfaceBlendMode(surf, &surf_blend_mode)) {
+	if (SDL_GetSurfaceBlendMode(surf, &surf_blend_mode) == 0) {
 		SDL_SetTextureBlendMode(tex, surf_blend_mode);
 	}
 

src/stream_manager.hpp

@@ -1,320 +0,0 @@
-#pragma once
-
-#include <solanaceae/object_store/fwd.hpp>
-#include <solanaceae/object_store/object_store.hpp>
-
-#include <entt/core/type_info.hpp>
-
-#include "./content/frame_stream2.hpp"
-
-#include <vector>
-#include <memory>
-#include <algorithm>
-#include <thread>
-#include <chrono>
-
-// fwd
-class StreamManager;
-
-namespace Components {
-	struct StreamSource {
-		std::string name;
-		std::string frame_type_name;
-
-		std::function<bool(StreamManager&, Object, Object, bool)> connect_fn;
-
-		template<typename FrameType>
-		static StreamSource create(const std::string& name);
-	};
-
-	struct StreamSink {
-		std::string name;
-		std::string frame_type_name;
-
-		template<typename FrameType>
-		static StreamSink create(const std::string& name);
-	};
-
-	template<typename FrameType>
-	using FrameStream2Source = std::unique_ptr<FrameStream2SourceI<FrameType>>;
-
-	template<typename FrameType>
-	using FrameStream2Sink = std::unique_ptr<FrameStream2SinkI<FrameType>>;
-
-} // Components
-
-
-class StreamManager {
-	friend class StreamManagerUI; // TODO: make this go away
-	ObjectStore2& _os;
-
-	struct Connection {
-		ObjectHandle src;
-		ObjectHandle sink;
-
-		struct Data {
-			virtual ~Data(void) {}
-		};
-		std::unique_ptr<Data> data; // stores reader writer type erased
-		std::function<void(Connection&)> pump_fn;
-		std::function<void(Connection&)> unsubscribe_fn;
-
-		bool on_main_thread {true};
-		std::atomic_bool stop {false}; // disconnect
-		std::atomic_bool finished {false}; // disconnect
-
-		// pump thread
-		std::thread pump_thread;
-
-		// frame interval counters and estimates
-
-		Connection(void) = default;
-		Connection(
-			ObjectHandle src_,
-			ObjectHandle sink_,
-			std::unique_ptr<Data>&& data_,
-			std::function<void(Connection&)>&& pump_fn_,
-			std::function<void(Connection&)>&& unsubscribe_fn_,
-			bool on_main_thread_ = true
-		) :
-			src(src_),
-			sink(sink_),
-			data(std::move(data_)),
-			pump_fn(std::move(pump_fn_)),
-			unsubscribe_fn(std::move(unsubscribe_fn_)),
-			on_main_thread(on_main_thread_)
-		{
-			if (!on_main_thread) {
-				// start thread
-				pump_thread = std::thread([this](void) {
-					while (!stop) {
-						pump_fn(*this);
-						std::this_thread::sleep_for(std::chrono::milliseconds(5));
-					}
-					finished = true;
-				});
-			}
-		}
-	};
-	std::vector<std::unique_ptr<Connection>> _connections;
-
-	public:
-		StreamManager(ObjectStore2& os) : _os(os) {}
-		virtual ~StreamManager(void) {
-			// stop all connetions
-			for (const auto& con : _connections) {
-				con->stop = true;
-				if (!con->on_main_thread) {
-					con->pump_thread.join(); // we skip the finished check and wait
-				}
-				con->unsubscribe_fn(*con);
-			}
-		}
-
-		// stream type is FrameStream2I<FrameType>
-		// TODO: improve this design
-		// src and sink need to be a FrameStream2MultiStream<FrameType>
-		template<typename FrameType>
-		bool connect(Object src, Object sink, bool threaded = true) {
-			auto res = std::find_if(
-				_connections.cbegin(), _connections.cend(),
-				[&](const auto& a) { return a->src == src && a->sink == sink; }
-			);
-			if (res != _connections.cend()) {
-				// already exists
-				return false;
-			}
-
-			auto h_src = _os.objectHandle(src);
-			auto h_sink = _os.objectHandle(sink);
-			if (!static_cast<bool>(h_src) || !static_cast<bool>(h_sink)) {
-				// an object does not exist
-				return false;
-			}
-
-			if (!h_src.all_of<Components::FrameStream2Source<FrameType>>()) {
-				// src not stream source
-				return false;
-			}
-
-			if (!h_sink.all_of<Components::FrameStream2Sink<FrameType>>()) {
-				// sink not stream sink
-				return false;
-			}
-
-			auto& src_stream = h_src.get<Components::FrameStream2Source<FrameType>>();
-			auto& sink_stream = h_sink.get<Components::FrameStream2Sink<FrameType>>();
-
-			struct inlineData : public Connection::Data {
-				virtual ~inlineData(void) {}
-				std::shared_ptr<FrameStream2I<FrameType>> reader;
-				std::shared_ptr<FrameStream2I<FrameType>> writer;
-			};
-
-			auto our_data = std::make_unique<inlineData>();
-
-			our_data->reader = src_stream->subscribe();
-			if (!our_data->reader) {
-				return false;
-			}
-			our_data->writer = sink_stream->subscribe();
-			if (!our_data->writer) {
-				return false;
-			}
-
-			_connections.push_back(std::make_unique<Connection>(
-				h_src,
-				h_sink,
-				std::move(our_data),
-				[](Connection& con) -> void {
-					// there might be more stored
-					for (size_t i = 0; i < 10; i++) {
-						auto new_frame_opt = static_cast<inlineData*>(con.data.get())->reader->pop();
-						// TODO: frame interval estimates
-						if (new_frame_opt.has_value()) {
-							static_cast<inlineData*>(con.data.get())->writer->push(new_frame_opt.value());
-						} else {
-							break;
-						}
-					}
-				},
-				[](Connection& con) -> void {
-					auto* src_stream_ptr = con.src.try_get<Components::FrameStream2Source<FrameType>>();
-					if (src_stream_ptr != nullptr) {
-						(*src_stream_ptr)->unsubscribe(static_cast<inlineData*>(con.data.get())->reader);
-					}
-					auto* sink_stream_ptr = con.sink.try_get<Components::FrameStream2Sink<FrameType>>();
-					if (sink_stream_ptr != nullptr) {
-						(*sink_stream_ptr)->unsubscribe(static_cast<inlineData*>(con.data.get())->writer);
-					}
-				},
-				!threaded
-			));
-
-			return true;
-		}
-
-		bool connect(Object src, Object sink, bool threaded = true) {
-			auto h_src = _os.objectHandle(src);
-			auto h_sink = _os.objectHandle(sink);
-			if (!static_cast<bool>(h_src) || !static_cast<bool>(h_sink)) {
-				// an object does not exist
-				return false;
-			}
-
-			// get src and sink comps
-			if (!h_src.all_of<Components::StreamSource>()) {
-				// src not stream source
-				return false;
-			}
-
-			if (!h_sink.all_of<Components::StreamSink>()) {
-				// sink not stream sink
-				return false;
-			}
-
-			const auto& ssrc = h_src.get<Components::StreamSource>();
-			const auto& ssink = h_sink.get<Components::StreamSink>();
-
-			// compare type
-			if (ssrc.frame_type_name != ssink.frame_type_name) {
-				return false;
-			}
-
-			// always fail in debug mode
-			assert(static_cast<bool>(ssrc.connect_fn));
-			if (!static_cast<bool>(ssrc.connect_fn)) {
-				return false;
-			}
-
-			// use connect fn from src
-			return ssrc.connect_fn(*this, src, sink, threaded);
-		}
-
-		template<typename StreamType>
-		bool disconnect(Object src, Object sink) {
-			auto res = std::find_if(
-				_connections.cbegin(), _connections.cend(),
-				[&](const auto& a) { return a->src == src && a->sink == sink; }
-			);
-			if (res == _connections.cend()) {
-				// not found
-				return false;
-			}
-
-			// do disconnect
-			(*res)->stop = true;
-
-			return true;
-		}
-
-		template<typename StreamType>
-		bool disconnectAll(Object o) {
-			bool succ {false};
-			for (const auto& con : _connections) {
-				if (con->src == o || con->sink == o) {
-					con->stop = true;
-					succ = true;
-				}
-			}
-
-			return succ;
-		}
-
-		// do we need the time delta?
-		float tick(float) {
-			// pump all mainthread connections
-			for (auto it = _connections.begin(); it != _connections.end();) {
-				auto& con = **it;
-
-				if (!static_cast<bool>(con.src) || !static_cast<bool>(con.sink)) {
-					// either side disappeard without disconnectAll
-					// TODO: warn/error log
-					con.stop = true;
-				}
-
-				if (con.on_main_thread) {
-					con.pump_fn(con);
-				}
-
-				if (con.stop && (con.finished || con.on_main_thread)) {
-					if (!con.on_main_thread) {
-						assert(con.pump_thread.joinable());
-						con.pump_thread.join();
-					}
-					con.unsubscribe_fn(con);
-					it = _connections.erase(it);
-				} else {
-					it++;
-				}
-			}
-
-			// return min over intervals instead
-			return 0.01f;
-		}
-};
-
-namespace Components {
-
-	// we require the complete sm type here
-	template<typename FrameType>
-	StreamSource StreamSource::create(const std::string& name) {
-		return StreamSource{
-			name,
-			std::string{entt::type_name<FrameType>::value()},
-			+[](StreamManager& sm, Object src, Object sink, bool threaded) {
-				return sm.connect<FrameType>(src, sink, threaded);
-			},
-		};
-	}
-
-	template<typename FrameType>
-	StreamSink StreamSink::create(const std::string& name) {
-		return StreamSink{
-			name,
-			std::string{entt::type_name<FrameType>::value()},
-		};
-	}
-
-} // Components
-

src/stream_manager_ui.cpp

@@ -1,222 +0,0 @@
-#include "./stream_manager_ui.hpp"
-
-#include <solanaceae/object_store/object_store.hpp>
-
-#include <imgui/imgui.h>
-
-#include <string>
-
-StreamManagerUI::StreamManagerUI(ObjectStore2& os, StreamManager& sm) : _os(os), _sm(sm) {
-}
-
-void StreamManagerUI::render(void) {
-	{ // main window menubar injection
-		// assumes the window "tomato" was rendered already by cg
-		if (ImGui::Begin("tomato")) {
-			if (ImGui::BeginMenuBar()) {
-				// TODO: drop all menu sep?
-				//ImGui::Separator(); // os already exists (very hacky)
-				if (ImGui::BeginMenu("ObjectStore")) {
-					if (ImGui::MenuItem("Stream Manger", nullptr, _show_window)) {
-						_show_window = !_show_window;
-					}
-					ImGui::EndMenu();
-				}
-				ImGui::EndMenuBar();
-			}
-
-		}
-		ImGui::End();
-	}
-
-
-	if (!_show_window) {
-		return;
-	}
-
-	if (ImGui::Begin("StreamManagerUI", &_show_window)) {
-		// TODO: node canvas
-
-		// by fametype ??
-
-		if (ImGui::CollapsingHeader("Sources", ImGuiTreeNodeFlags_DefaultOpen)) {
-			// list sources
-			if (ImGui::BeginTable("sources_and_sinks", 4, ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_BordersInnerV)) {
-				ImGui::TableSetupColumn("id");
-				ImGui::TableSetupColumn("name");
-				ImGui::TableSetupColumn("##conn");
-				ImGui::TableSetupColumn("type");
-
-				ImGui::TableHeadersRow();
-
-				for (const auto& [oc, ss] : _os.registry().view<Components::StreamSource>().each()) {
-					//ImGui::Text("src  %d (%s)[%s]", entt::to_integral(entt::to_entity(oc)), ss.name.c_str(), ss.frame_type_name.c_str());
-					ImGui::PushID(entt::to_integral(oc));
-
-					ImGui::TableNextColumn();
-					ImGui::Text("%d", entt::to_integral(entt::to_entity(oc)));
-
-					const auto *ssrc = _os.registry().try_get<Components::StreamSource>(oc);
-					ImGui::TableNextColumn();
-					ImGui::TextUnformatted(ssrc!=nullptr?ssrc->name.c_str():"none");
-
-					ImGui::TableNextColumn();
-					if (ImGui::SmallButton("->")) {
-						ImGui::OpenPopup("src_connect");
-					}
-					if (ImGui::BeginPopup("src_connect")) {
-						if (ImGui::BeginMenu("connect to")) {
-							for (const auto& [oc_sink, s_sink] : _os.registry().view<Components::StreamSink>().each()) {
-								if (s_sink.frame_type_name != ss.frame_type_name) {
-									continue;
-								}
-
-								ImGui::PushID(entt::to_integral(oc_sink));
-
-								std::string sink_label {"src "};
-								sink_label += std::to_string(entt::to_integral(entt::to_entity(oc_sink)));
-								sink_label += " (";
-								sink_label += s_sink.name;
-								sink_label += ")[";
-								sink_label += s_sink.frame_type_name;
-								sink_label += "]";
-								if (ImGui::MenuItem(sink_label.c_str())) {
-									_sm.connect(oc, oc_sink);
-								}
-
-								ImGui::PopID();
-							}
-
-							ImGui::EndMenu();
-						}
-						ImGui::EndPopup();
-					}
-
-					ImGui::TableNextColumn();
-					ImGui::TextUnformatted(ssrc!=nullptr?ssrc->frame_type_name.c_str():"???");
-
-					ImGui::PopID();
-				}
-
-				ImGui::EndTable();
-			}
-		} // sources header
-
-		if (ImGui::CollapsingHeader("Sinks", ImGuiTreeNodeFlags_DefaultOpen)) {
-			// list sinks
-			if (ImGui::BeginTable("sources_and_sinks", 4, ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_BordersInnerV)) {
-				ImGui::TableSetupColumn("id");
-				ImGui::TableSetupColumn("name");
-				ImGui::TableSetupColumn("##conn");
-				ImGui::TableSetupColumn("type");
-
-				ImGui::TableHeadersRow();
-
-				for (const auto& [oc, ss] : _os.registry().view<Components::StreamSink>().each()) {
-					ImGui::PushID(entt::to_integral(oc));
-
-					ImGui::TableNextColumn();
-					ImGui::Text("%d", entt::to_integral(entt::to_entity(oc)));
-
-					const auto *ssink = _os.registry().try_get<Components::StreamSink>(oc);
-					ImGui::TableNextColumn();
-					ImGui::TextUnformatted(ssink!=nullptr?ssink->name.c_str():"none");
-
-					ImGui::TableNextColumn();
-					if (ImGui::SmallButton("->")) {
-						ImGui::OpenPopup("sink_connect");
-					}
-					// ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings
-					if (ImGui::BeginPopup("sink_connect")) {
-						if (ImGui::BeginMenu("connect to")) {
-							for (const auto& [oc_src, s_src] : _os.registry().view<Components::StreamSource>().each()) {
-								if (s_src.frame_type_name != ss.frame_type_name) {
-									continue;
-								}
-
-								ImGui::PushID(entt::to_integral(oc_src));
-
-								std::string source_label {"src "};
-								source_label += std::to_string(entt::to_integral(entt::to_entity(oc_src)));
-								source_label += " (";
-								source_label += s_src.name;
-								source_label += ")[";
-								source_label += s_src.frame_type_name;
-								source_label += "]";
-								if (ImGui::MenuItem(source_label.c_str())) {
-									_sm.connect(oc_src, oc);
-								}
-
-								ImGui::PopID();
-							}
-
-							ImGui::EndMenu();
-						}
-						ImGui::EndPopup();
-					}
-
-					ImGui::TableNextColumn();
-					ImGui::TextUnformatted(ssink!=nullptr?ssink->frame_type_name.c_str():"???");
-
-					ImGui::PopID();
-				}
-
-				ImGui::EndTable();
-			}
-		} // sink header
-
-		if (ImGui::CollapsingHeader("Connections", ImGuiTreeNodeFlags_DefaultOpen)) {
-			// list connections
-			if (ImGui::BeginTable("connections", 6, ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_BordersInnerV)) {
-				ImGui::TableSetupColumn("##id"); // TODO: remove?
-				ImGui::TableSetupColumn("##disco");
-				ImGui::TableSetupColumn("##qdesc");
-				ImGui::TableSetupColumn("from");
-				ImGui::TableSetupColumn("to");
-				ImGui::TableSetupColumn("type");
-
-				ImGui::TableHeadersRow();
-
-				for (size_t i = 0; i < _sm._connections.size(); i++) {
-					const auto& con = _sm._connections[i];
-					//ImGui::Text("con %d->%d", entt::to_integral(entt::to_entity(con->src.entity())), entt::to_integral(entt::to_entity(con->sink.entity())));
-
-					ImGui::PushID(i);
-
-					ImGui::TableNextColumn();
-					ImGui::Text("%zu", i); // do connections have ids?
-
-					ImGui::TableNextColumn();
-					if (ImGui::SmallButton("X")) {
-						con->stop = true;
-					}
-
-					ImGui::TableNextColumn();
-					ImGui::Text("%d->%d", entt::to_integral(entt::to_entity(con->src.entity())), entt::to_integral(entt::to_entity(con->sink.entity())));
-
-					const auto *ssrc = con->src.try_get<Components::StreamSource>();
-					ImGui::TableNextColumn();
-					ImGui::TextUnformatted(ssrc!=nullptr?ssrc->name.c_str():"none");
-
-					const auto *ssink = con->sink.try_get<Components::StreamSink>();
-					ImGui::TableNextColumn();
-					ImGui::TextUnformatted(ssink!=nullptr?ssink->name.c_str():"none");
-
-					ImGui::TableNextColumn();
-					ImGui::TextUnformatted(
-						(ssrc!=nullptr)?
-							ssrc->frame_type_name.c_str():
-							(ssink!=nullptr)?
-								ssink->frame_type_name.c_str()
-								:"???"
-					);
-
-					ImGui::PopID();
-				}
-				ImGui::EndTable();
-			}
-		} // con header
-	}
-	ImGui::End();
-}
-

src/stream_manager_ui.hpp

@@ -1,17 +0,0 @@
-#pragma once
-
-#include <solanaceae/object_store/fwd.hpp>
-#include "./stream_manager.hpp"
-
-class StreamManagerUI {
-	ObjectStore2& _os;
-	StreamManager& _sm;
-
-	bool _show_window {true};
-
-	public:
-		StreamManagerUI(ObjectStore2& os, StreamManager& sm);
-
-		void render(void);
-};
-

src/tox_av.cpp

@@ -2,85 +2,14 @@
 
 #include <cassert>
 
-#include <cstdint>
-#include <iostream>
-
 // https://almogfx.bandcamp.com/track/crushed-w-cassade
 
-struct ToxAVFriendCallState final {
-	const uint32_t state {TOXAV_FRIEND_CALL_STATE_NONE};
-
-	[[nodiscard]] bool is_error(void) const { return state & TOXAV_FRIEND_CALL_STATE_ERROR; }
-	[[nodiscard]] bool is_finished(void) const { return state & TOXAV_FRIEND_CALL_STATE_FINISHED; }
-	[[nodiscard]] bool is_sending_a(void) const { return state & TOXAV_FRIEND_CALL_STATE_SENDING_A; }
-	[[nodiscard]] bool is_sending_v(void) const { return state & TOXAV_FRIEND_CALL_STATE_SENDING_V; }
-	[[nodiscard]] bool is_accepting_a(void) const { return state & TOXAV_FRIEND_CALL_STATE_ACCEPTING_A; }
-	[[nodiscard]] bool is_accepting_v(void) const { return state & TOXAV_FRIEND_CALL_STATE_ACCEPTING_V; }
-};
-
 ToxAV::ToxAV(Tox* tox) : _tox(tox) {
 	Toxav_Err_New err_new {TOXAV_ERR_NEW_OK};
 	_tox_av = toxav_new(_tox, &err_new);
 	// TODO: throw
 	assert(err_new == TOXAV_ERR_NEW_OK);
-
-	toxav_callback_call(
-		_tox_av,
-		+[](ToxAV*, uint32_t friend_number, bool audio_enabled, bool video_enabled, void *user_data) {
-			assert(user_data != nullptr);
-			static_cast<ToxAV*>(user_data)->cb_call(friend_number, audio_enabled, video_enabled);
-		},
-		this
-	);
-	toxav_callback_call_state(
-		_tox_av,
-		+[](ToxAV*, uint32_t friend_number, uint32_t state, void *user_data) {
-			assert(user_data != nullptr);
-			static_cast<ToxAV*>(user_data)->cb_call_state(friend_number, state);
-		},
-		this
-	);
-	toxav_callback_audio_bit_rate(
-		_tox_av,
-		+[](ToxAV*, uint32_t friend_number, uint32_t audio_bit_rate, void *user_data) {
-			assert(user_data != nullptr);
-			static_cast<ToxAV*>(user_data)->cb_audio_bit_rate(friend_number, audio_bit_rate);
-		},
-		this
-	);
-	toxav_callback_video_bit_rate(
-		_tox_av,
-		+[](ToxAV*, uint32_t friend_number, uint32_t video_bit_rate, void *user_data) {
-			assert(user_data != nullptr);
-			static_cast<ToxAV*>(user_data)->cb_video_bit_rate(friend_number, video_bit_rate);
-		},
-		this
-	);
-	toxav_callback_audio_receive_frame(
-		_tox_av,
-		+[](ToxAV*, uint32_t friend_number, const int16_t pcm[], size_t sample_count, uint8_t channels, uint32_t sampling_rate, void *user_data) {
-			assert(user_data != nullptr);
-			static_cast<ToxAV*>(user_data)->cb_audio_receive_frame(friend_number, pcm, sample_count, channels, sampling_rate);
-		},
-		this
-	);
-	toxav_callback_video_receive_frame(
-		_tox_av,
-		+[](ToxAV*, uint32_t friend_number,
-			uint16_t width, uint16_t height,
-			const uint8_t y[/*! max(width, abs(ystride)) * height */],
-			const uint8_t u[/*! max(width/2, abs(ustride)) * (height/2) */],
-			const uint8_t v[/*! max(width/2, abs(vstride)) * (height/2) */],
-			int32_t ystride, int32_t ustride, int32_t vstride,
-			void *user_data
-		) {
-			assert(user_data != nullptr);
-			static_cast<ToxAV*>(user_data)->cb_video_receive_frame(friend_number, width, height, y, u, v, ystride, ustride, vstride);
-		},
-		this
-	);
 }
-
 ToxAV::~ToxAV(void) {
 	toxav_kill(_tox_av);
 }
@@ -151,101 +80,3 @@ Toxav_Err_Bit_Rate_Set ToxAV::toxavVideoSetBitRate(uint32_t friend_number, uint3
 	return err;
 }
 
-void ToxAV::cb_call(uint32_t friend_number, bool audio_enabled, bool video_enabled) {
-	std::cerr << "TOXAV: receiving call f:" << friend_number << " a:" << audio_enabled << " v:" << video_enabled << "\n";
-	//Toxav_Err_Answer err_answer { TOXAV_ERR_ANSWER_OK };
-	//toxav_answer(_tox_av, friend_number, 0, 0, &err_answer);
-	//if (err_answer != TOXAV_ERR_ANSWER_OK) {
-	//    std::cerr << "!!!!!!!! answer failed " << err_answer << "\n";
-	//}
-
-	dispatch(
-		ToxAV_Event::friend_call,
-		Events::FriendCall{
-			friend_number,
-			audio_enabled,
-			video_enabled,
-		}
-	);
-}
-
-void ToxAV::cb_call_state(uint32_t friend_number, uint32_t state) {
-	//ToxAVFriendCallState w_state{state};
-
-	//w_state.is_error();
-
-	std::cerr << "TOXAV: call state f:" << friend_number << " s:" << state << "\n";
-
-	dispatch(
-		ToxAV_Event::friend_call_state,
-		Events::FriendCallState{
-			friend_number,
-			state,
-		}
-	);
-}
-
-void ToxAV::cb_audio_bit_rate(uint32_t friend_number, uint32_t audio_bit_rate) {
-	std::cerr << "TOXAV: audio bitrate f:" << friend_number << " abr:" << audio_bit_rate << "\n";
-
-	dispatch(
-		ToxAV_Event::friend_audio_bitrate,
-		Events::FriendAudioBitrate{
-			friend_number,
-			audio_bit_rate,
-		}
-	);
-}
-
-void ToxAV::cb_video_bit_rate(uint32_t friend_number, uint32_t video_bit_rate) {
-	std::cerr << "TOXAV: video bitrate f:" << friend_number << " vbr:" << video_bit_rate << "\n";
-
-	dispatch(
-		ToxAV_Event::friend_video_bitrate,
-		Events::FriendVideoBitrate{
-			friend_number,
-			video_bit_rate,
-		}
-	);
-}
-
-void ToxAV::cb_audio_receive_frame(uint32_t friend_number, const int16_t pcm[], size_t sample_count, uint8_t channels, uint32_t sampling_rate) {
-	//std::cerr << "TOXAV: audio frame f:" <<  friend_number << " sc:" << sample_count << " ch:" << (int)channels << " sr:" << sampling_rate << "\n";
-
-	dispatch(
-		ToxAV_Event::friend_audio_frame,
-		Events::FriendAudioFrame{
-			friend_number,
-			Span<int16_t>(pcm, sample_count*channels), // TODO: is sample count *ch or /ch?
-			channels,
-			sampling_rate,
-		}
-	);
-}
-
-void ToxAV::cb_video_receive_frame(
-	uint32_t friend_number,
-	uint16_t width, uint16_t height,
-	const uint8_t y[/*! max(width, abs(ystride)) * height */],
-	const uint8_t u[/*! max(width/2, abs(ustride)) * (height/2) */],
-	const uint8_t v[/*! max(width/2, abs(vstride)) * (height/2) */],
-	int32_t ystride, int32_t ustride, int32_t vstride
-) {
-	//std::cerr << "TOXAV: video frame f:" <<  friend_number << " w:" << width << " h:" << height << "\n";
-
-	dispatch(
-		ToxAV_Event::friend_video_frame,
-		Events::FriendVideoFrame{
-			friend_number,
-			width,
-			height,
-			Span<uint8_t>(y, std::max<int64_t>(width, std::abs(ystride)) * height),
-			Span<uint8_t>(u, std::max<int64_t>(width/2, std::abs(ustride)) * (height/2)),
-			Span<uint8_t>(v, std::max<int64_t>(width/2, std::abs(vstride)) * (height/2)),
-			ystride,
-			ustride,
-			vstride,
-		}
-	);
-}
-

src/tox_av.hpp

@@ -1,98 +1,15 @@
 #pragma once
 
-#include <solanaceae/util/span.hpp>
-#include <solanaceae/util/event_provider.hpp>
-
 #include <tox/toxav.h>
 
-namespace /*toxav*/ Events {
-
-	struct FriendCall {
-		uint32_t friend_number;
-		bool audio_enabled;
-		bool video_enabled;
-	};
-
-	struct FriendCallState {
-		uint32_t friend_number;
-		uint32_t state;
-	};
-
-	struct FriendAudioBitrate {
-		uint32_t friend_number;
-		uint32_t audio_bit_rate;
-	};
-
-	struct FriendVideoBitrate {
-		uint32_t friend_number;
-		uint32_t video_bit_rate;
-	};
-
-	struct FriendAudioFrame {
-		uint32_t friend_number;
-
-		Span<int16_t> pcm;
-		//size_t sample_count;
-		uint8_t channels;
-		uint32_t sampling_rate;
-	};
-
-	struct FriendVideoFrame {
-		uint32_t friend_number;
-
-		uint16_t width;
-		uint16_t height;
-		//const uint8_t y[[>! max(width, abs(ystride)) * height <]];
-		//const uint8_t u[[>! max(width/2, abs(ustride)) * (height/2) <]];
-		//const uint8_t v[[>! max(width/2, abs(vstride)) * (height/2) <]];
-		// mdspan would be nice here
-		// bc of the stride, span might be larger than the actual data it contains
-		Span<uint8_t> y;
-		Span<uint8_t> u;
-		Span<uint8_t> v;
-		int32_t ystride;
-		int32_t ustride;
-		int32_t vstride;
-	};
-
-} // Event
-
-enum class ToxAV_Event : uint32_t {
-	friend_call,
-	friend_call_state,
-	friend_audio_bitrate,
-	friend_video_bitrate,
-	friend_audio_frame,
-	friend_video_frame,
-
-	MAX
-};
-
-struct ToxAVEventI {
-	using enumType = ToxAV_Event;
-
-	virtual ~ToxAVEventI(void) {}
-
-	virtual bool onEvent(const Events::FriendCall&) { return false; }
-	virtual bool onEvent(const Events::FriendCallState&) { return false; }
-	virtual bool onEvent(const Events::FriendAudioBitrate&) { return false; }
-	virtual bool onEvent(const Events::FriendVideoBitrate&) { return false; }
-	virtual bool onEvent(const Events::FriendAudioFrame&) { return false; }
-	virtual bool onEvent(const Events::FriendVideoFrame&) { return false; }
-};
-using ToxAVEventProviderI = EventProviderI<ToxAVEventI>;
-
-struct ToxAV : public ToxAVEventProviderI{
+struct ToxAV {
 	Tox* _tox = nullptr;
 	ToxAV* _tox_av = nullptr;
 
-	static constexpr const char* version {"0"};
-
 	ToxAV(Tox* tox);
 	virtual ~ToxAV(void);
 
 	// interface
-	// if iterate is called on a different thread, it will fire events there
 	uint32_t toxavIterationInterval(void) const;
 	void toxavIterate(void);
 
@@ -116,21 +33,5 @@ struct ToxAV : public ToxAVEventProviderI{
 //int32_t toxav_groupchat_disable_av(Tox *tox, uint32_t groupnumber);
 //bool toxav_groupchat_av_enabled(Tox *tox, uint32_t groupnumber);
 
-
-
-	// toxav callbacks
-	void cb_call(uint32_t friend_number, bool audio_enabled, bool video_enabled);
-	void cb_call_state(uint32_t friend_number, uint32_t state);
-	void cb_audio_bit_rate(uint32_t friend_number, uint32_t audio_bit_rate);
-	void cb_video_bit_rate(uint32_t friend_number, uint32_t video_bit_rate);
-	void cb_audio_receive_frame(uint32_t friend_number, const int16_t pcm[], size_t sample_count, uint8_t channels, uint32_t sampling_rate);
-	void cb_video_receive_frame(
-		uint32_t friend_number,
-		uint16_t width, uint16_t height,
-		const uint8_t y[/*! max(width, abs(ystride)) * height */],
-		const uint8_t u[/*! max(width/2, abs(ustride)) * (height/2) */],
-		const uint8_t v[/*! max(width/2, abs(vstride)) * (height/2) */],
-		int32_t ystride, int32_t ustride, int32_t vstride
-	);
 };
 

src/tox_netprof_ui.cpp

@@ -0,0 +1,310 @@
+#include "./tox_netprof_ui.hpp"
+
+#include <imgui/imgui.h>
+
+static const char* typedPkgIDToString(Tox_Netprof_Packet_Type type, uint8_t id) {
+	// pain
+	if (type == TOX_NETPROF_PACKET_TYPE_UDP) {
+		switch (id) {
+			case TOX_NETPROF_PACKET_ID_ZERO: return "Ping request";
+			case TOX_NETPROF_PACKET_ID_ONE: return "Ping response";
+			case TOX_NETPROF_PACKET_ID_TWO: return "Get nodes request";
+			case TOX_NETPROF_PACKET_ID_FOUR: return "Send nodes response";
+			case TOX_NETPROF_PACKET_ID_COOKIE_REQUEST: return "Cookie request";
+			case TOX_NETPROF_PACKET_ID_COOKIE_RESPONSE: return "Cookie response";
+			case TOX_NETPROF_PACKET_ID_CRYPTO_HS: return "Crypto handshake";
+			case TOX_NETPROF_PACKET_ID_CRYPTO_DATA: return "Crypto data";
+			case TOX_NETPROF_PACKET_ID_CRYPTO: return "Encrypted data";
+			case TOX_NETPROF_PACKET_ID_LAN_DISCOVERY: return "LAN discovery";
+			case TOX_NETPROF_PACKET_ID_GC_HANDSHAKE: return "DHT groupchat handshake";
+			case TOX_NETPROF_PACKET_ID_GC_LOSSLESS: return "DHT groupchat lossless";
+			case TOX_NETPROF_PACKET_ID_GC_LOSSY: return "DHT groupchat lossy";
+			case TOX_NETPROF_PACKET_ID_ONION_SEND_INITIAL: return "Onion send init";
+			case TOX_NETPROF_PACKET_ID_ONION_SEND_1: return "Onion send 1";
+			case TOX_NETPROF_PACKET_ID_ONION_SEND_2: return "Onion send 2";
+			case TOX_NETPROF_PACKET_ID_ANNOUNCE_REQUEST_OLD: return "DHT announce request (old)";
+			case TOX_NETPROF_PACKET_ID_ANNOUNCE_RESPONSE_OLD: return "DHT announce response (old)";
+			case TOX_NETPROF_PACKET_ID_ONION_DATA_REQUEST: return "Onion data request";
+			case TOX_NETPROF_PACKET_ID_ONION_DATA_RESPONSE: return "Onion data response";
+			case TOX_NETPROF_PACKET_ID_ANNOUNCE_REQUEST: return "DHT announce request";
+			case TOX_NETPROF_PACKET_ID_ANNOUNCE_RESPONSE: return "DHT announce response";
+			case TOX_NETPROF_PACKET_ID_ONION_RECV_3: return "Onion receive 3";
+			case TOX_NETPROF_PACKET_ID_ONION_RECV_2: return "Onion receive 2";
+			case TOX_NETPROF_PACKET_ID_ONION_RECV_1: return "Onion receive 1";
+			case TOX_NETPROF_PACKET_ID_FORWARD_REQUEST: return "DHT forwarding request";
+			case TOX_NETPROF_PACKET_ID_FORWARDING: return "DHT forwarding";
+			case TOX_NETPROF_PACKET_ID_FORWARD_REPLY: return "DHT forward reply";
+			case TOX_NETPROF_PACKET_ID_DATA_SEARCH_REQUEST: return "DHT data search request";
+			case TOX_NETPROF_PACKET_ID_DATA_SEARCH_RESPONSE: return "DHT data search response";
+			case TOX_NETPROF_PACKET_ID_DATA_RETRIEVE_REQUEST: return "DHT data retrieve request";
+			case TOX_NETPROF_PACKET_ID_DATA_RETRIEVE_RESPONSE: return "DHT data retrieve response";
+			case TOX_NETPROF_PACKET_ID_STORE_ANNOUNCE_REQUEST: return "DHT store announce request";
+			case TOX_NETPROF_PACKET_ID_STORE_ANNOUNCE_RESPONSE: return "DHT store announce response";
+			case TOX_NETPROF_PACKET_ID_BOOTSTRAP_INFO: return "Bootstrap info";
+		}
+	} else if (type == TOX_NETPROF_PACKET_TYPE_TCP) { // TODO: or client/server
+		switch (id) {
+			case TOX_NETPROF_PACKET_ID_ZERO: return "Routing request";
+			case TOX_NETPROF_PACKET_ID_ONE: return "Routing response";
+			case TOX_NETPROF_PACKET_ID_TWO: return "Connection notification";
+			case TOX_NETPROF_PACKET_ID_TCP_DISCONNECT: return "disconnect notification";
+			case TOX_NETPROF_PACKET_ID_FOUR: return "Ping packet";
+			case TOX_NETPROF_PACKET_ID_TCP_PONG: return "pong packet";
+			case TOX_NETPROF_PACKET_ID_TCP_OOB_SEND: return "out-of-band send";
+			case TOX_NETPROF_PACKET_ID_TCP_OOB_RECV: return "out-of-band receive";
+			case TOX_NETPROF_PACKET_ID_TCP_ONION_REQUEST: return "onion request";
+			case TOX_NETPROF_PACKET_ID_TCP_ONION_RESPONSE: return "onion response";
+			case TOX_NETPROF_PACKET_ID_TCP_DATA: return "data";
+			//case TOX_NETPROF_PACKET_ID_BOOTSTRAP_INFO: return "Bootstrap info";
+		}
+	}
+
+	return "UNK";
+}
+
+void ToxNetprofUI::tick(float time_delta) {
+	if (!_enabled) {
+		return;
+	}
+
+	_time_since_last_add += time_delta;
+	if (_time_since_last_add >= _value_add_interval) {
+		_time_since_last_add = 0.f; // very loose
+
+		if (_udp_tctx.empty()) {
+			_udp_tctx.push_back(0.f);
+			_udp_tctx_prev = _tpi.toxNetprofGetPacketTotalCount(TOX_NETPROF_PACKET_TYPE_UDP, TOX_NETPROF_DIRECTION_SENT);
+		} else {
+			const auto new_value = _tpi.toxNetprofGetPacketTotalCount(TOX_NETPROF_PACKET_TYPE_UDP, TOX_NETPROF_DIRECTION_SENT);
+			_udp_tctx.push_back(new_value - _udp_tctx_prev);
+			_udp_tctx_prev = new_value;
+		}
+
+		if (_udp_tcrx.empty()) {
+			_udp_tcrx.push_back(0.f);
+			_udp_tcrx_prev = _tpi.toxNetprofGetPacketTotalCount(TOX_NETPROF_PACKET_TYPE_UDP, TOX_NETPROF_DIRECTION_RECV);
+		} else {
+			const auto new_value = _tpi.toxNetprofGetPacketTotalCount(TOX_NETPROF_PACKET_TYPE_UDP, TOX_NETPROF_DIRECTION_RECV);
+			_udp_tcrx.push_back(new_value - _udp_tcrx_prev);
+			_udp_tcrx_prev = new_value;
+		}
+
+		if (_udp_tbtx.empty()) {
+			_udp_tbtx.push_back(0.f);
+			_udp_tbtx_prev = _tpi.toxNetprofGetPacketTotalBytes(TOX_NETPROF_PACKET_TYPE_UDP, TOX_NETPROF_DIRECTION_SENT);
+		} else {
+			const auto new_value = _tpi.toxNetprofGetPacketTotalBytes(TOX_NETPROF_PACKET_TYPE_UDP, TOX_NETPROF_DIRECTION_SENT);
+			_udp_tbtx.push_back(new_value - _udp_tbtx_prev);
+			_udp_tbtx_prev = new_value;
+		}
+
+		if (_udp_tbrx.empty()) {
+			_udp_tbrx.push_back(0.f);
+			_udp_tbrx_prev = _tpi.toxNetprofGetPacketTotalBytes(TOX_NETPROF_PACKET_TYPE_UDP, TOX_NETPROF_DIRECTION_RECV);
+		} else {
+			const auto new_value = _tpi.toxNetprofGetPacketTotalBytes(TOX_NETPROF_PACKET_TYPE_UDP, TOX_NETPROF_DIRECTION_RECV);
+			_udp_tbrx.push_back(new_value - _udp_tbrx_prev);
+			_udp_tbrx_prev = new_value;
+		}
+
+		if (_udp_tbrx.empty()) {
+		}
+
+		// TODO: limit
+		while (_udp_tctx.size() > 5*60) {
+			_udp_tctx.erase(_udp_tctx.begin());
+		}
+
+		while (_udp_tcrx.size() > 5*60) {
+			_udp_tcrx.erase(_udp_tcrx.begin());
+		}
+
+		while (_udp_tbtx.size() > 5*60) {
+			_udp_tbtx.erase(_udp_tbtx.begin());
+		}
+
+		while (_udp_tbrx.size() > 5*60) {
+			_udp_tbrx.erase(_udp_tbrx.begin());
+		}
+	}
+}
+
+float ToxNetprofUI::render(float time_delta) {
+	{ // main window menubar injection
+		// assumes the window "tomato" was rendered already by cg
+		if (ImGui::Begin("tomato")) {
+			if (ImGui::BeginMenuBar()) {
+				if (ImGui::BeginMenu("Tox")) {
+					ImGui::SeparatorText("Net diagnostics");
+
+					if (ImGui::MenuItem("Breakdown table", nullptr, _show_window_table)) {
+						_show_window_table = !_show_window_table;
+					}
+
+					ImGui::Checkbox("histogram logging", &_enabled);
+
+					if (ImGui::MenuItem("Netprof histograms", nullptr, _show_window_histo)) {
+						_show_window_histo = !_show_window_histo;
+					}
+
+					ImGui::EndMenu();
+				}
+				ImGui::EndMenuBar();
+			}
+		}
+		ImGui::End();
+	}
+
+	if (_show_window_table) {
+		if (ImGui::Begin("Tox Netprof table", &_show_window_table)) {
+			ImGui::Text("UDP total Count tx/rx: %zu/%zu",
+				_tpi.toxNetprofGetPacketTotalCount(TOX_NETPROF_PACKET_TYPE_UDP, TOX_NETPROF_DIRECTION_SENT),
+				_tpi.toxNetprofGetPacketTotalCount(TOX_NETPROF_PACKET_TYPE_UDP, TOX_NETPROF_DIRECTION_RECV)
+			);
+			ImGui::Text("UDP total Bytes tx/rx: %zu/%zu",
+				_tpi.toxNetprofGetPacketTotalBytes(TOX_NETPROF_PACKET_TYPE_UDP, TOX_NETPROF_DIRECTION_SENT),
+				_tpi.toxNetprofGetPacketTotalBytes(TOX_NETPROF_PACKET_TYPE_UDP, TOX_NETPROF_DIRECTION_RECV)
+			);
+			ImGui::Text("TCP total Count tx/rx: %zu/%zu (client: %zu/%zu; server: %zu/%zu)",
+				_tpi.toxNetprofGetPacketTotalCount(TOX_NETPROF_PACKET_TYPE_TCP, TOX_NETPROF_DIRECTION_SENT),
+				_tpi.toxNetprofGetPacketTotalCount(TOX_NETPROF_PACKET_TYPE_TCP, TOX_NETPROF_DIRECTION_RECV),
+				_tpi.toxNetprofGetPacketTotalCount(TOX_NETPROF_PACKET_TYPE_TCP_CLIENT, TOX_NETPROF_DIRECTION_SENT),
+				_tpi.toxNetprofGetPacketTotalCount(TOX_NETPROF_PACKET_TYPE_TCP_CLIENT, TOX_NETPROF_DIRECTION_RECV),
+				_tpi.toxNetprofGetPacketTotalCount(TOX_NETPROF_PACKET_TYPE_TCP_SERVER, TOX_NETPROF_DIRECTION_SENT),
+				_tpi.toxNetprofGetPacketTotalCount(TOX_NETPROF_PACKET_TYPE_TCP_SERVER, TOX_NETPROF_DIRECTION_RECV)
+			);
+			ImGui::Text("TCP total Bytes tx/rx: %zu/%zu (client: %zu/%zu; server: %zu/%zu)",
+				_tpi.toxNetprofGetPacketTotalBytes(TOX_NETPROF_PACKET_TYPE_TCP, TOX_NETPROF_DIRECTION_SENT),
+				_tpi.toxNetprofGetPacketTotalBytes(TOX_NETPROF_PACKET_TYPE_TCP, TOX_NETPROF_DIRECTION_RECV),
+				_tpi.toxNetprofGetPacketTotalBytes(TOX_NETPROF_PACKET_TYPE_TCP_CLIENT, TOX_NETPROF_DIRECTION_SENT),
+				_tpi.toxNetprofGetPacketTotalBytes(TOX_NETPROF_PACKET_TYPE_TCP_CLIENT, TOX_NETPROF_DIRECTION_RECV),
+				_tpi.toxNetprofGetPacketTotalBytes(TOX_NETPROF_PACKET_TYPE_TCP_SERVER, TOX_NETPROF_DIRECTION_SENT),
+				_tpi.toxNetprofGetPacketTotalBytes(TOX_NETPROF_PACKET_TYPE_TCP_SERVER, TOX_NETPROF_DIRECTION_RECV)
+			);
+
+			// TODO: color types (tcp/udp and maybe dht)
+
+			static float decay_rate = 3.f;
+			ImGui::SliderFloat("heat decay (/s)", &decay_rate, 0.f, 50.0f);
+
+			// type (udp/tcp), id/name, count tx, count rx, bytes tx, bytes rx
+			if (ImGui::BeginTable("per packet", 6, ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY)) {
+
+				ImGui::TableSetupScrollFreeze(0, 1); // Make top row always visible
+				ImGui::TableSetupColumn("type");
+				ImGui::TableSetupColumn("pkt type");
+				ImGui::TableSetupColumn("count tx");
+				ImGui::TableSetupColumn("count rx");
+				ImGui::TableSetupColumn("bytes tx");
+				ImGui::TableSetupColumn("bytes rx");
+
+				ImGui::TableHeadersRow();
+
+				auto value_fn = [time_delta](size_t i, uint64_t value, auto& prev_map, auto& heat_map, const float scale = 0.2f) {
+					ImGui::TableNextColumn();
+					ImGui::Text("%zu", value);
+					if (prev_map.count(i)) {
+						const auto delta = value - prev_map[i];
+						float& heat = heat_map[i];
+						heat += delta * scale; // count 0.1, bytes 0.02?
+
+						// TODO: actual color function
+						float green = 0.7f;
+						if (heat > 1.f) {
+							green -= (heat - 1.f) * 0.1f;
+						}
+
+						ImGui::TableSetBgColor(ImGuiTableBgTarget_CellBg, ImGui::GetColorU32(ImVec4(0.9f, green, 0.0f, heat)));
+
+						//ImGui::SameLine();
+						//ImGui::Text("%.2f", heat);
+
+						//heat *= 0.94f;
+						float decay = decay_rate * time_delta;
+						if (decay > 0.999f) {
+							decay = 0.999f;
+						}
+						heat *= (1.f - decay);
+					}
+					prev_map[i] = value;
+				};
+
+				for (size_t i = 0; i < 0xff; i++) {
+					if (i == 0x10) {
+						continue;
+					}
+					const auto count_sent = _tpi.toxNetprofGetPacketIdCount(TOX_NETPROF_PACKET_TYPE_UDP, i, TOX_NETPROF_DIRECTION_SENT);
+					const auto count_received = _tpi.toxNetprofGetPacketIdCount(TOX_NETPROF_PACKET_TYPE_UDP, i, TOX_NETPROF_DIRECTION_RECV);
+
+					if (count_sent == 0 && count_received == 0) {
+						continue; // skip empty
+					}
+
+					ImGui::TableNextColumn();
+					ImGui::TextUnformatted("UDP");
+
+					ImGui::TableNextColumn();
+					ImGui::Text("%02zx(%s)", i, typedPkgIDToString(TOX_NETPROF_PACKET_TYPE_UDP, i));
+
+					value_fn(i, count_sent, _udp_ctx_prev, _udp_ctx_heat);
+
+					value_fn(i, count_received, _udp_crx_prev, _udp_crx_heat);
+
+					value_fn(i, _tpi.toxNetprofGetPacketIdBytes(TOX_NETPROF_PACKET_TYPE_UDP, i, TOX_NETPROF_DIRECTION_SENT), _udp_btx_prev, _udp_btx_heat, 0.005f);
+
+					value_fn(i, _tpi.toxNetprofGetPacketIdBytes(TOX_NETPROF_PACKET_TYPE_UDP, i, TOX_NETPROF_DIRECTION_RECV), _udp_brx_prev, _udp_brx_heat, 0.005f);
+				}
+
+				for (size_t i = 0; i <= 0x10; i++) {
+					const auto count_sent = _tpi.toxNetprofGetPacketIdCount(TOX_NETPROF_PACKET_TYPE_TCP, i, TOX_NETPROF_DIRECTION_SENT);
+					const auto count_received = _tpi.toxNetprofGetPacketIdCount(TOX_NETPROF_PACKET_TYPE_TCP, i, TOX_NETPROF_DIRECTION_RECV);
+
+					if (count_sent == 0 && count_received == 0) {
+						continue; // skip empty
+					}
+
+					ImGui::TableNextColumn();
+					ImGui::TextUnformatted("TCP");
+
+					ImGui::TableNextColumn();
+					ImGui::Text("%02zx(%s)", i, typedPkgIDToString(TOX_NETPROF_PACKET_TYPE_TCP, i));
+
+					value_fn(i, count_sent, _tcp_ctx_prev, _tcp_ctx_heat);
+
+					value_fn(i, count_received, _tcp_crx_prev, _tcp_crx_heat);
+
+					value_fn(i, _tpi.toxNetprofGetPacketIdBytes(TOX_NETPROF_PACKET_TYPE_TCP, i, TOX_NETPROF_DIRECTION_SENT), _tcp_btx_prev, _tcp_btx_heat, 0.005f);
+
+					value_fn(i, _tpi.toxNetprofGetPacketIdBytes(TOX_NETPROF_PACKET_TYPE_TCP, i, TOX_NETPROF_DIRECTION_RECV), _tcp_brx_prev, _tcp_brx_heat, 0.005f);
+				}
+
+				ImGui::EndTable();
+			}
+		}
+		ImGui::End();
+	}
+
+	if (_show_window_histo) {
+		if (ImGui::Begin("Tox Netprof histograms", &_show_window_histo)) {
+			if (_enabled) {
+				const float line_height = ImGui::GetTextLineHeight();
+				ImGui::PlotHistogram("udp total count sent##histograms", _udp_tctx.data(), _udp_tctx.size(), 0, nullptr, 0.f, FLT_MAX, {0, 3*line_height});
+				ImGui::PlotHistogram("udp total count received##histograms", _udp_tcrx.data(), _udp_tcrx.size(), 0, nullptr, 0.f, FLT_MAX, {0, 3*line_height});
+				ImGui::PlotHistogram("udp total bytes sent##histograms", _udp_tbtx.data(), _udp_tbtx.size(), 0, nullptr, 0.f, FLT_MAX, {0, 3*line_height});
+				ImGui::PlotHistogram("udp total bytes received##histograms", _udp_tbrx.data(), _udp_tbrx.size(), 0, nullptr, 0.f, FLT_MAX, {0, 3*line_height});
+			} else {
+				ImGui::TextUnformatted("logging disabled!");
+				if (ImGui::Button("enable")) {
+					_enabled = true;
+				}
+			}
+		}
+		ImGui::End();
+	}
+
+	if (_show_window_table) {
+		return 0.1f; // min 10fps
+	}
+	return 2.f;
+}
+

src/tox_netprof_ui.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "./tox_private_impl.hpp"
+
+#include <cstdint>
+#include <vector>
+#include <map>
+
+class ToxNetprofUI {
+	ToxPrivateImpl& _tpi;
+
+	bool _enabled {true};
+	bool _show_window_table {false};
+	bool _show_window_histo {false};
+
+	// table delta
+	std::map<uint8_t, uint64_t> _udp_ctx_prev;
+	std::map<uint8_t, uint64_t> _udp_crx_prev;
+	std::map<uint8_t, uint64_t> _udp_btx_prev;
+	std::map<uint8_t, uint64_t> _udp_brx_prev;
+	std::map<uint8_t, uint64_t> _tcp_ctx_prev;
+	std::map<uint8_t, uint64_t> _tcp_crx_prev;
+	std::map<uint8_t, uint64_t> _tcp_btx_prev;
+	std::map<uint8_t, uint64_t> _tcp_brx_prev;
+
+	// table heat
+	std::map<uint8_t, float> _udp_ctx_heat;
+	std::map<uint8_t, float> _udp_crx_heat;
+	std::map<uint8_t, float> _udp_btx_heat;
+	std::map<uint8_t, float> _udp_brx_heat;
+	std::map<uint8_t, float> _tcp_ctx_heat;
+	std::map<uint8_t, float> _tcp_crx_heat;
+	std::map<uint8_t, float> _tcp_btx_heat;
+	std::map<uint8_t, float> _tcp_brx_heat;
+
+	// histogram totals
+	uint64_t _udp_tctx_prev;
+	uint64_t _udp_tcrx_prev;
+	uint64_t _udp_tbtx_prev;
+	uint64_t _udp_tbrx_prev;
+	std::vector<float> _udp_tctx;
+	std::vector<float> _udp_tcrx;
+	std::vector<float> _udp_tbtx;
+	std::vector<float> _udp_tbrx;
+
+	const float _value_add_interval {1.f}; // every second
+	float _time_since_last_add {0.f};
+
+	public:
+		ToxNetprofUI(ToxPrivateImpl& tpi) : _tpi(tpi) {}
+
+		void tick(float time_delta);
+		float render(float time_delta);
+};

src/tox_private_impl.hpp

@@ -32,4 +32,22 @@ struct ToxPrivateImpl : public ToxPrivateI {
 			return {std::nullopt, err};
 		}
 	}
+
+	// TODO: add to interface
+	uint64_t toxNetprofGetPacketIdCount(Tox_Netprof_Packet_Type type, uint8_t id, Tox_Netprof_Direction direction) {
+		return tox_netprof_get_packet_id_count(_tox, type, id, direction);
+	}
+
+	uint64_t toxNetprofGetPacketTotalCount(Tox_Netprof_Packet_Type type, Tox_Netprof_Direction direction) {
+		return tox_netprof_get_packet_total_count(_tox, type, direction);
+	}
+
+	uint64_t toxNetprofGetPacketIdBytes(Tox_Netprof_Packet_Type type, uint8_t id, Tox_Netprof_Direction direction) {
+		return tox_netprof_get_packet_id_bytes(_tox, type, id, direction);
+	}
+
+	uint64_t toxNetprofGetPacketTotalBytes(Tox_Netprof_Packet_Type type, Tox_Netprof_Direction direction) {
+		return tox_netprof_get_packet_total_bytes(_tox, type, direction);
+	}
+
 };