netprof privapi + ui (wip histograms)

e740b4e3b2e feat: Implement Tox network profiler

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

.github/workflows/cd.yml

@@ -22,10 +22,10 @@ jobs:
         submodules: recursive
 
     - name: Install Dependencies
-      run: sudo apt update && sudo apt -y install libsodium-dev cmake libvpx-dev libopus-dev
+      run: sudo apt update && sudo apt -y install libsodium-dev cmake
 
     - name: Configure CMake
-      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DTOMATO_TOX_AV=ON
+      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
 
     - name: Build
       run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -j 4 -t tomato
@@ -101,7 +101,7 @@ jobs:
     - name: Configure CMake
       env:
         ANDROID_NDK_HOME: ${{steps.setup_ndk.outputs.ndk-path}}
-      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_TOOLCHAIN_FILE=/usr/local/share/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=${{matrix.platform.vcpkg_toolkit}} -DANDROID=1 -DANDROID_PLATFORM=23 -DANDROID_ABI=${{matrix.platform.ndk_abi}} -DVCPKG_CHAINLOAD_TOOLCHAIN_FILE=${{steps.setup_ndk.outputs.ndk-path}}/build/cmake/android.toolchain.cmake -DSDLIMAGE_JPG_SHARED=OFF -DSDLIMAGE_PNG_SHARED=OFF -DTOMATO_MAIN_SO=ON -DTOMATO_TOX_AV=ON
+      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_TOOLCHAIN_FILE=/usr/local/share/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=${{matrix.platform.vcpkg_toolkit}} -DANDROID=1 -DANDROID_PLATFORM=23 -DANDROID_ABI=${{matrix.platform.ndk_abi}} -DVCPKG_CHAINLOAD_TOOLCHAIN_FILE=${{steps.setup_ndk.outputs.ndk-path}}/build/cmake/android.toolchain.cmake -DSDLIMAGE_JPG_SHARED=OFF -DSDLIMAGE_PNG_SHARED=OFF -DTOMATO_MAIN_SO=ON
 
     - name: Build (tomato)
       run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -j 4 -t tomato
@@ -164,7 +164,7 @@ jobs:
     #- uses: ilammy/setup-nasm@v1
 
     - name: Configure CMake
-      run: cmake -G Ninja -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-windows-static -DSDLIMAGE_VENDORED=ON -DSDLIMAGE_DEPS_SHARED=ON -DSDLIMAGE_JXL=OFF -DSDLIMAGE_AVIF=OFF -DPKG_CONFIG_EXECUTABLE=C:/vcpkg/installed/x64-windows/tools/pkgconf/pkgconf.exe -DTOMATO_TOX_AV=ON
+      run: cmake -G Ninja -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-windows-static -DSDLIMAGE_VENDORED=ON -DSDLIMAGE_DEPS_SHARED=ON -DSDLIMAGE_JXL=OFF -DSDLIMAGE_AVIF=OFF -DPKG_CONFIG_EXECUTABLE=C:/vcpkg/installed/x64-windows/tools/pkgconf/pkgconf.exe
 
     - name: Build
       run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -t tomato
@@ -229,7 +229,7 @@ jobs:
     #- uses: ilammy/setup-nasm@v1
 
     - name: Configure CMake
-      run: cmake -G Ninja -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-windows-static -DTOMATO_ASAN=ON -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded -DSDLIMAGE_VENDORED=ON -DSDLIMAGE_DEPS_SHARED=ON -DSDLIMAGE_JXL=OFF -DSDLIMAGE_AVIF=OFF -DPKG_CONFIG_EXECUTABLE=C:/vcpkg/installed/x64-windows/tools/pkgconf/pkgconf.exe -DTOMATO_TOX_AV=ON
+      run: cmake -G Ninja -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake -DVCPKG_TARGET_TRIPLET=x64-windows-static -DTOMATO_ASAN=ON -DCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreaded -DSDLIMAGE_VENDORED=ON -DSDLIMAGE_DEPS_SHARED=ON -DSDLIMAGE_JXL=OFF -DSDLIMAGE_AVIF=OFF -DPKG_CONFIG_EXECUTABLE=C:/vcpkg/installed/x64-windows/tools/pkgconf/pkgconf.exe
 
     - name: Build
       run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} -j 4 -t tomato

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,7 +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,41 +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
-
-	./frame_streams/frame_stream2.hpp
-	./frame_streams/audio_stream2.hpp
-	./frame_streams/stream_manager.hpp
-	./frame_streams/stream_manager.cpp
-	./frame_streams/locked_frame_stream.hpp
-	./frame_streams/multi_source.hpp
-
-	./frame_streams/voip_model.hpp
-
-	./frame_streams/sdl/sdl_audio2_frame_stream2.hpp
-	./frame_streams/sdl/sdl_audio2_frame_stream2.cpp
-	./frame_streams/sdl/video.hpp
-	./frame_streams/sdl/video_push_converter.hpp
-	./frame_streams/sdl/video_push_converter.cpp
-
-	./stream_manager_ui.hpp
-	./stream_manager_ui.cpp
-
-	./debug_video_tap.hpp
-	./debug_video_tap.cpp
 )
 
 if (TOMATO_TOX_AV)
 	target_sources(tomato PUBLIC
 		./tox_av.hpp
 		./tox_av.cpp
-
-		./tox_av_voip_model.hpp
-		./tox_av_voip_model.cpp
 	)
 
 	target_compile_definitions(tomato PUBLIC TOMATO_TOX_AV)
@@ -171,18 +150,3 @@ target_link_libraries(tomato PUBLIC
 
 set_target_properties(tomato PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
-########################################
-
-add_executable(test_frame_stream2_pop_reframer EXCLUDE_FROM_ALL
-	./frame_streams/frame_stream2.hpp
-	./frame_streams/audio_stream2.hpp
-	./frame_streams/locked_frame_stream.hpp
-	./frame_streams/multi_source.hpp
-
-	./frame_streams/test_pop_reframer.cpp
-)
-
-target_link_libraries(test_frame_stream2_pop_reframer
-	solanaceae_util
-)
-

src/chat_gui/file_selector.cpp

@@ -111,60 +111,56 @@ void FileSelector::render(void) {
 				}
 			}
 
-			try {
-				// do sorting here
-				// TODO: cache the result (lol)
-				if (ImGuiTableSortSpecs* sorts_specs = ImGui::TableGetSortSpecs(); sorts_specs != nullptr && sorts_specs->SpecsCount >= 1) {
-					switch (static_cast<SortID>(sorts_specs->Specs->ColumnUserID)) {
-						break; case SortID::name:
-							if (sorts_specs->Specs->SortDirection == ImGuiSortDirection_Descending) {
-								std::sort(dirs.begin(), dirs.end(), [](const auto& a, const auto& b) -> bool {
-									return a.path() < b.path();
-								});
-								std::sort(files.begin(), files.end(), [](const auto& a, const auto& b) -> bool {
-									return a.path().filename() < b.path().filename();
-								});
-							} else {
-								std::sort(dirs.begin(), dirs.end(), [](const auto& a, const auto& b) -> bool {
-									return a.path() > b.path();
-								});
-								std::sort(files.begin(), files.end(), [](const auto& a, const auto& b) -> bool {
-									return a.path().filename() > b.path().filename();
-								});
-							}
-						break; case SortID::size:
-							if (sorts_specs->Specs->SortDirection == ImGuiSortDirection_Descending) {
-								// TODO: sort dirs?
-								std::sort(files.begin(), files.end(), [](const auto& a, const auto& b) -> bool {
-									return a.file_size() < b.file_size();
-								});
-							} else {
-								// TODO: sort dirs?
-								std::sort(files.begin(), files.end(), [](const auto& a, const auto& b) -> bool {
-									return a.file_size() > b.file_size();
-								});
-							}
-						break; case SortID::date:
-							if (sorts_specs->Specs->SortDirection == ImGuiSortDirection_Descending) {
-								std::sort(dirs.begin(), dirs.end(), [](const auto& a, const auto& b) -> bool {
-									return a.last_write_time() < b.last_write_time();
-								});
-								std::sort(files.begin(), files.end(), [](const auto& a, const auto& b) -> bool {
-									return a.last_write_time() < b.last_write_time();
-								});
-							} else {
-								std::sort(dirs.begin(), dirs.end(), [](const auto& a, const auto& b) -> bool {
-									return a.last_write_time() > b.last_write_time();
-								});
-								std::sort(files.begin(), files.end(), [](const auto& a, const auto& b) -> bool {
-									return a.last_write_time() > b.last_write_time();
-								});
-							}
-						break; default: ;
-					}
+			// do sorting here
+			// TODO: cache the result (lol)
+			if (ImGuiTableSortSpecs* sorts_specs = ImGui::TableGetSortSpecs(); sorts_specs != nullptr && sorts_specs->SpecsCount >= 1) {
+				switch (static_cast<SortID>(sorts_specs->Specs->ColumnUserID)) {
+					break; case SortID::name:
+						if (sorts_specs->Specs->SortDirection == ImGuiSortDirection_Descending) {
+							std::sort(dirs.begin(), dirs.end(), [](const auto& a, const auto& b) -> bool {
+								return a.path() < b.path();
+							});
+							std::sort(files.begin(), files.end(), [](const auto& a, const auto& b) -> bool {
+								return a.path().filename() < b.path().filename();
+							});
+						} else {
+							std::sort(dirs.begin(), dirs.end(), [](const auto& a, const auto& b) -> bool {
+								return a.path() > b.path();
+							});
+							std::sort(files.begin(), files.end(), [](const auto& a, const auto& b) -> bool {
+								return a.path().filename() > b.path().filename();
+							});
+						}
+					break; case SortID::size:
+						if (sorts_specs->Specs->SortDirection == ImGuiSortDirection_Descending) {
+							// TODO: sort dirs?
+							std::sort(files.begin(), files.end(), [](const auto& a, const auto& b) -> bool {
+								return a.file_size() < b.file_size();
+							});
+						} else {
+							// TODO: sort dirs?
+							std::sort(files.begin(), files.end(), [](const auto& a, const auto& b) -> bool {
+								return a.file_size() > b.file_size();
+							});
+						}
+					break; case SortID::date:
+						if (sorts_specs->Specs->SortDirection == ImGuiSortDirection_Descending) {
+							std::sort(dirs.begin(), dirs.end(), [](const auto& a, const auto& b) -> bool {
+								return a.last_write_time() < b.last_write_time();
+							});
+							std::sort(files.begin(), files.end(), [](const auto& a, const auto& b) -> bool {
+								return a.last_write_time() < b.last_write_time();
+							});
+						} else {
+							std::sort(dirs.begin(), dirs.end(), [](const auto& a, const auto& b) -> bool {
+								return a.last_write_time() > b.last_write_time();
+							});
+							std::sort(files.begin(), files.end(), [](const auto& a, const auto& b) -> bool {
+								return a.last_write_time() > b.last_write_time();
+							});
+						}
+					break; default: ;
 				}
-			} catch (...) {
-				// we likely saw a file disapear
 			}
 
 			for (auto const& dir_entry : dirs) {

src/chat_gui4.cpp

@@ -9,13 +9,9 @@
 #include <solanaceae/contact/components.hpp>
 #include <solanaceae/util/utils.hpp>
 
-#include "./frame_streams/voip_model.hpp"
-
 // HACK: remove them
 #include <solanaceae/tox_contacts/components.hpp>
 
-#include <entt/entity/entity.hpp>
-
 #include <imgui/imgui.h>
 #include <imgui/misc/cpp/imgui_stdlib.h>
 
@@ -34,7 +30,6 @@
 #include <fstream>
 #include <iomanip>
 #include <sstream>
-#include <string>
 #include <variant>
 
 namespace Components {
@@ -262,97 +257,6 @@ float ChatGui4::render(float time_delta) {
 
 			if (ImGui::BeginChild(chat_label.c_str(), {0, 0}, ImGuiChildFlags_Border, ImGuiWindowFlags_MenuBar)) {
 				if (ImGui::BeginMenuBar()) {
-					// check if contact has voip model
-					// use activesessioncomp instead?
-					if (_cr.all_of<VoIPModelI*>(*_selected_contact)) {
-						if (ImGui::BeginMenu("VoIP")) {
-							auto* voip_model = _cr.get<VoIPModelI*>(*_selected_contact);
-
-							std::vector<ObjectHandle> contact_sessions;
-							std::vector<ObjectHandle> acceptable_sessions;
-							for (const auto& [ov, o_vm, sc] : _os.registry().view<VoIPModelI*, Components::VoIP::SessionContact>().each()) {
-								if (o_vm != voip_model) {
-									continue;
-								}
-								if (sc.c != *_selected_contact) {
-									continue;
-								}
-
-								auto o = _os.objectHandle(ov);
-								contact_sessions.push_back(o);
-
-								if (!o.all_of<Components::VoIP::Incoming>()) {
-									continue; // not incoming
-								}
-
-								// state is ringing/not yet accepted
-								const auto* session_state = o.try_get<Components::VoIP::SessionState>();
-								if (session_state == nullptr) {
-									continue;
-								}
-
-								if (session_state->state != Components::VoIP::SessionState::State::RINGING) {
-									continue;
-								}
-								acceptable_sessions.push_back(o);
-							}
-
-							static Components::VoIP::DefaultConfig g_default_connections{};
-
-							if (ImGui::BeginMenu("default connections")) {
-								ImGui::MenuItem("incoming audio", nullptr, &g_default_connections.incoming_audio);
-								ImGui::MenuItem("incoming video", nullptr, &g_default_connections.incoming_video);
-								ImGui::Separator();
-								ImGui::MenuItem("outgoing audio", nullptr, &g_default_connections.outgoing_audio);
-								ImGui::MenuItem("outgoing video", nullptr, &g_default_connections.outgoing_video);
-								ImGui::EndMenu();
-							}
-
-							if (acceptable_sessions.size() < 2) {
-								if (ImGui::MenuItem("accept call", nullptr, false, !acceptable_sessions.empty())) {
-									voip_model->accept(acceptable_sessions.front(), g_default_connections);
-								}
-							} else {
-								if (ImGui::BeginMenu("accept call", !acceptable_sessions.empty())) {
-									for (const auto o : acceptable_sessions) {
-										std::string label = "accept #";
-										label += std::to_string(entt::to_integral(entt::to_entity(o.entity())));
-
-										if (ImGui::MenuItem(label.c_str())) {
-											voip_model->accept(o, g_default_connections);
-										}
-									}
-									ImGui::EndMenu();
-								}
-							}
-
-							// TODO: disable if already in call?
-							if (ImGui::Button(" call ")) {
-								voip_model->enter(*_selected_contact, g_default_connections);
-							}
-
-							if (contact_sessions.size() < 2) {
-								if (ImGui::MenuItem("leave/reject call", nullptr, false, !contact_sessions.empty())) {
-									voip_model->leave(contact_sessions.front());
-								}
-							} else {
-								if (ImGui::BeginMenu("leave/reject call")) {
-									// list
-									for (const auto o : contact_sessions) {
-										std::string label = "end #";
-										label += std::to_string(entt::to_integral(entt::to_entity(o.entity())));
-
-										if (ImGui::MenuItem(label.c_str())) {
-											voip_model->leave(o);
-										}
-									}
-									ImGui::EndMenu();
-								}
-							}
-
-							ImGui::EndMenu();
-						}
-					}
 					if (ImGui::BeginMenu("debug")) {
 						ImGui::Checkbox("show extra info", &_show_chat_extra_info);
 						ImGui::Checkbox("show avatar transfers", &_show_chat_avatar_tf);
@@ -1138,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/debug_video_tap.cpp

@@ -1,296 +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 "./frame_streams/sdl/video.hpp"
-#include "./frame_streams/frame_stream2.hpp"
-
-#include <string>
-#include <memory>
-#include <mutex>
-#include <deque>
-
-#include <thread>
-#include <chrono>
-#include <atomic>
-
-#include <iostream>
-
-// fwd
-namespace Message {
-uint64_t getTimeMS(void);
-}
-
-// threadsafe queue frame stream
-// protected by a simple mutex lock
-template<typename FrameType>
-struct LockedFrameStream2 : public FrameStream2I<FrameType> {
-	std::mutex _lock;
-
-	std::deque<FrameType> _frames;
-
-	~LockedFrameStream2(void) {}
-
-	int32_t size(void) { return -1; }
-
-	std::optional<FrameType> pop(void) {
-		std::lock_guard lg{_lock};
-
-		if (_frames.empty()) {
-			return std::nullopt;
-		}
-
-		FrameType new_frame = std::move(_frames.front());
-		_frames.pop_front();
-
-		return std::move(new_frame);
-	}
-
-	bool push(const FrameType& value) {
-		std::lock_guard lg{_lock};
-
-		_frames.push_back(value);
-
-		return true;
-	}
-};
-
-struct DebugVideoTapSink : public FrameStream2SinkI<SDLVideoFrame> {
-	TextureUploaderI& _tu;
-
-	uint32_t _id_counter {0};
-
-	struct Writer {
-		struct View {
-			uint32_t _id {0}; // for stable imgui ids
-
-			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
-		} view;
-
-		std::shared_ptr<LockedFrameStream2<SDLVideoFrame>> stream;
-	};
-	std::vector<Writer> _writers;
-
-	DebugVideoTapSink(TextureUploaderI& tu) : _tu(tu) {}
-	~DebugVideoTapSink(void) {}
-
-	// sink
-	std::shared_ptr<FrameStream2I<SDLVideoFrame>> subscribe(void) override {
-		_writers.emplace_back(Writer{
-			Writer::View{_id_counter++},
-			std::make_shared<LockedFrameStream2<SDLVideoFrame>>()
-		});
-
-		return _writers.back().stream;
-	}
-
-	bool unsubscribe(const std::shared_ptr<FrameStream2I<SDLVideoFrame>>& sub) override {
-		if (!sub || _writers.empty()) {
-			// nah
-			return false;
-		}
-
-		for (auto it = _writers.cbegin(); it != _writers.cend(); it++) {
-			if (it->stream == sub) {
-				_tu.destroy(it->view._tex);
-				_writers.erase(it);
-				return true;
-			}
-		}
-
-		// what
-		return false;
-	}
-};
-
-struct DebugVideoTestSource : public FrameStream2SourceI<SDLVideoFrame> {
-	std::vector<std::shared_ptr<LockedFrameStream2<SDLVideoFrame>>> _readers;
-
-	std::atomic_bool _stop {false};
-	std::thread _thread;
-
-	DebugVideoTestSource(void) {
-		std::cout << "DVTS: starting new test video source\n";
-		_thread = std::thread([this](void) {
-			while (!_stop) {
-				if (!_readers.empty()) {
-					auto* surf = SDL_CreateSurface(960, 720, SDL_PIXELFORMAT_ARGB32);
-
-					// color
-					static auto start_time = Message::getTimeMS();
-					const float time = (Message::getTimeMS() - start_time)/1000.f;
-					SDL_ClearSurface(surf, std::sin(time), std::cos(time), 0.5f, 1.f);
-
-					SDLVideoFrame frame{ // non-owning
-						Message::getTimeMS()*1000,
-						surf,
-					};
-
-					for (auto& stream : _readers) {
-						stream->push(frame); // copy
-					}
-
-					SDL_DestroySurface(surf);
-				}
-
-				std::this_thread::sleep_for(std::chrono::milliseconds(50));
-			}
-		});
-	}
-	~DebugVideoTestSource(void) {
-		_stop = true;
-		_thread.join();
-	}
-
-	std::shared_ptr<FrameStream2I<SDLVideoFrame>> subscribe(void) override {
-		return _readers.emplace_back(std::make_shared<LockedFrameStream2<SDLVideoFrame>>());
-	}
-
-	bool unsubscribe(const std::shared_ptr<FrameStream2I<SDLVideoFrame>>& sub) override {
-		for (auto it = _readers.cbegin(); it != _readers.cend(); it++) {
-			if (it->get() == sub.get()) {
-				_readers.erase(it);
-				return true;
-			}
-		}
-
-		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>(_tu);
-		_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"));
-		_tap.emplace<Components::TagDefaultTarget>();
-
-		_os.throwEventConstruct(_tap);
-	} catch (...) {
-		_os.registry().destroy(_tap);
-	}
-
-	_src = {_os.registry(), _os.registry().create()};
-	try {
-		auto dvts = std::make_unique<DebugVideoTestSource>();
-		_src.emplace<DebugVideoTestSource*>(dvts.get());
-		_src.emplace<Components::FrameStream2Source<SDLVideoFrame>>(
-			std::move(dvts)
-		);
-
-		_src.emplace<Components::StreamSource>(Components::StreamSource::create<SDLVideoFrame>("DebugVideoTest"));
-
-		_os.throwEventConstruct(_src);
-	} catch (...) {
-		_os.registry().destroy(_src);
-	}
-}
-
-DebugVideoTap::~DebugVideoTap(void) {
-	if (static_cast<bool>(_tap)) {
-		_os.registry().destroy(_tap);
-	}
-	if (static_cast<bool>(_src)) {
-		_os.registry().destroy(_src);
-	}
-}
-
-float DebugVideoTap::render(void) {
-	float min_interval {2.f};
-	auto& dvtsw = _tap.get<DebugVideoTapSink*>()->_writers;
-	for (auto& [view, stream] : dvtsw) {
-		std::string window_title {"DebugVideoTap #"};
-		window_title += std::to_string(view._id);
-		ImGui::SetNextWindowSize({250, 250}, ImGuiCond_Appearing);
-		if (ImGui::Begin(window_title.c_str())) {
-			while (auto new_frame_opt = stream->pop()) {
-				// timing
-				if (view._v_last_ts == 0) {
-					view._v_last_ts = new_frame_opt.value().timestampUS;
-				} else {
-					auto delta = int64_t(new_frame_opt.value().timestampUS) - int64_t(view._v_last_ts);
-					view._v_last_ts = new_frame_opt.value().timestampUS;
-
-					if (view._v_interval_avg == 0) {
-						view._v_interval_avg = delta/1'000'000.f;
-					} else {
-						const float r = 0.2f;
-						view._v_interval_avg = view._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 (view._tex == 0 || (int)view._tex_w != converted_surf->w || (int)view._tex_h != converted_surf->h) {
-					_tu.destroy(view._tex);
-					view._tex = _tu.uploadRGBA(
-						static_cast<const uint8_t*>(converted_surf->pixels),
-						converted_surf->w,
-						converted_surf->h,
-						TextureUploaderI::LINEAR,
-						TextureUploaderI::STREAMING
-					);
-
-					view._tex_w = converted_surf->w;
-					view._tex_h = converted_surf->h;
-				} else {
-					_tu.updateRGBA(view._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);
-				}
-			}
-
-			ImGui::Checkbox("mirror", &view._mirror);
-
-			// img here
-			if (view._tex != 0) {
-				ImGui::SameLine();
-				ImGui::Text("moving avg interval: %f", view._v_interval_avg);
-				const float img_w = ImGui::GetContentRegionAvail().x;
-				ImGui::Image(
-					reinterpret_cast<ImTextureID>(view._tex),
-					ImVec2{img_w, img_w * float(view._tex_h)/view._tex_w},
-					ImVec2{view._mirror?1.f:0.f, 0},
-					ImVec2{view._mirror?0.f:1.f, 1}
-				);
-			}
-
-		}
-		ImGui::End();
-	}
-
-	return min_interval;
-}
-

src/debug_video_tap.hpp

@@ -1,23 +0,0 @@
-#pragma once
-
-#include <solanaceae/object_store/fwd.hpp>
-#include "./frame_streams/stream_manager.hpp"
-#include "./texture_uploader.hpp"
-
-// provides a sink and a small window displaying a SDLVideoFrame
-// HACK: provides a test video source
-class DebugVideoTap {
-	ObjectStore2& _os;
-	StreamManager& _sm;
-	TextureUploaderI& _tu;
-
-	ObjectHandle _tap;
-	ObjectHandle _src;
-
-	public:
-		DebugVideoTap(ObjectStore2& os, StreamManager& sm, TextureUploaderI& tu);
-		~DebugVideoTap(void);
-
-		float render(void);
-};
-

src/frame_streams/audio_stream2.hpp

@@ -1,39 +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
-// s16 only stopgap audio frame (simplified)
-struct AudioFrame2 {
-	// samples per second
-	uint32_t sample_rate {48'000};
-
-	// only >0 is valid
-	size_t channels {0};
-
-	std::variant<
-		std::vector<int16_t>, // S16, platform endianess
-		Span<int16_t> // non owning variant, for direct consumption
-	> buffer;
-
-	// helpers
-	Span<int16_t> getSpan(void) const {
-		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);
-		}
-		return {};
-	}
-};
-
-using AudioFrame2Stream2I = FrameStream2I<AudioFrame2>;
-

src/frame_streams/audio_stream_pop_reframer.hpp

@@ -1,103 +0,0 @@
-#pragma once
-
-#include "./audio_stream2.hpp"
-
-// reframes audio frames to a specified size in ms
-// TODO: use absolute sample count instead??
-template<typename RealAudioStream>
-struct AudioStreamPopReFramer : public FrameStream2I<AudioFrame2> {
-	uint32_t _frame_length_ms {20};
-
-	// gotta be careful of the multithreaded nature
-	// and false(true) sharing
-	uint64_t _pad0{};
-	RealAudioStream _stream;
-	uint64_t _pad1{};
-
-	// dequeue?
-	std::vector<int16_t> _buffer;
-
-	uint32_t _sample_rate {48'000};
-	size_t _channels {0};
-
-	AudioStreamPopReFramer(uint32_t frame_length_ms = 20)
-	: _frame_length_ms(frame_length_ms) {
-	}
-
-	AudioStreamPopReFramer(uint32_t frame_length_ms, FrameStream2I<AudioFrame2>&& stream)
-	: _frame_length_ms(frame_length_ms), _stream(std::move(stream)) {
-	}
-
-	~AudioStreamPopReFramer(void) {}
-
-	size_t getDesiredSize(void) const {
-		return _frame_length_ms * _sample_rate * _channels / 1000;
-	}
-
-	int32_t size(void) override { return -1; }
-
-	std::optional<AudioFrame2> pop(void) override {
-		do {
-			auto new_in = _stream.pop();
-			if (new_in.has_value()) {
-				auto& new_value = new_in.value();
-
-				// changed
-				if (_sample_rate != new_value.sample_rate || _channels != new_value.channels) {
-					//if (_channels != 0) {
-					//    std::cerr << "ReFramer warning: reconfiguring, dropping buffer\n";
-					//}
-					_sample_rate = new_value.sample_rate;
-					_channels = new_value.channels;
-
-					// buffer does not exist or config changed and we discard
-					_buffer = {};
-				}
-
-				//std::cout << "new incoming frame is " << new_value.getSpan().size/new_value.channels*1000/new_value.sample_rate << "ms\n";
-
-				auto new_span = new_value.getSpan();
-
-				if (_buffer.empty()) {
-					_buffer = {new_span.cbegin(), new_span.cend()};
-				} else {
-					_buffer.insert(_buffer.cend(), new_span.cbegin(), new_span.cend());
-				}
-			} else if (_buffer.empty()) {
-				// first pop might result in invalid state
-				return std::nullopt;
-			} else {
-				// inner stream pop did not give a new value
-				break; // out of loop
-			}
-		} while (_buffer.size() < getDesiredSize());
-
-		const auto desired_size = getDesiredSize();
-
-		// > threshold?
-		if (_buffer.size() < desired_size) {
-			return std::nullopt;
-		}
-
-		// copy data
-		std::vector<int16_t> return_buffer(_buffer.cbegin(), _buffer.cbegin()+desired_size);
-
-		// now crop buffer (meh)
-		// move data from back to front
-		_buffer.erase(_buffer.cbegin(), _buffer.cbegin() + desired_size);
-
-		return AudioFrame2{
-			_sample_rate,
-			_channels,
-			std::move(return_buffer),
-		};
-	}
-
-	bool push(const AudioFrame2& value) override {
-		// might be worth it to instead do the work on push
-		//assert(false && "push reframing not implemented");
-		// passthrough
-		return _stream.push(value);
-	}
-};
-

src/frame_streams/frame_stream2.hpp

@@ -1,47 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <memory>
-#include <optional>
-#include <vector>
-
-// Frames often consist of:
-// - seq id // incremental sequential id, gaps in ids can be used to detect loss
-// - or timestamp
-// - 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
-	// returns -1 if unknown
-	[[nodiscard]] virtual int32_t size(void) = 0;
-
-	// get next frame
-	// 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;
-};
-

src/frame_streams/locked_frame_stream.hpp

@@ -1,46 +0,0 @@
-#pragma once
-
-#include "./frame_stream2.hpp"
-
-#include <mutex>
-#include <deque>
-
-// threadsafe queue frame stream
-// protected by a simple mutex lock
-// prefer lockless queue implementations, when available
-template<typename FrameType>
-struct LockedFrameStream2 : public FrameStream2I<FrameType> {
-	std::mutex _lock;
-
-	std::deque<FrameType> _frames;
-
-	~LockedFrameStream2(void) {}
-
-	int32_t size(void) { return -1; }
-
-	std::optional<FrameType> pop(void) {
-		std::lock_guard lg{_lock};
-
-		if (_frames.empty()) {
-			return std::nullopt;
-		}
-
-		FrameType new_frame = std::move(_frames.front());
-		_frames.pop_front();
-
-		return std::move(new_frame);
-	}
-
-	bool push(const FrameType& value) {
-		std::lock_guard lg{_lock};
-
-		if (_frames.size() > 1024) {
-			return false; // hard limit
-		}
-
-		_frames.push_back(value);
-
-		return true;
-	}
-};
-

src/frame_streams/multi_source.hpp

@@ -1,62 +0,0 @@
-#pragma once
-
-#include "./locked_frame_stream.hpp"
-
-#include <cassert>
-
-// implements a stream that pushes to all sub streams
-template<typename FrameType, typename SubStreamType = LockedFrameStream2<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 {
-		std::lock_guard lg{_sub_stream_lock};
-		return _sub_streams.emplace_back(std::make_unique<SubStreamType>());
-	}
-
-	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/frame_streams/sdl/sdl_audio2_frame_stream2.cpp

@@ -1,279 +0,0 @@
-#include "./sdl_audio2_frame_stream2.hpp"
-
-#include <cassert>
-#include <iostream>
-#include <optional>
-
-#include "../audio_stream_pop_reframer.hpp"
-
-// "thin" wrapper around sdl audio streams
-// we dont needs to get fance, as they already provide everything we need
-struct SDLAudio2StreamReader : public AudioFrame2Stream2I {
-	std::unique_ptr<SDL_AudioStream, decltype(&SDL_DestroyAudioStream)> _stream;
-
-	uint32_t _sample_rate {48'000};
-	size_t _channels {0};
-
-	// buffer gets reused!
-	std::vector<int16_t> _buffer;
-
-	SDLAudio2StreamReader(void) : _stream(nullptr, nullptr) {}
-	SDLAudio2StreamReader(SDLAudio2StreamReader&& other) :
-		_stream(std::move(other._stream)),
-		_sample_rate(other._sample_rate),
-		_channels(other._channels)
-	{
-		const size_t buffer_size {960*_channels};
-		_buffer.resize(buffer_size);
-	}
-
-	~SDLAudio2StreamReader(void) {
-		if (_stream) {
-			SDL_UnbindAudioStream(_stream.get());
-		}
-	}
-
-	int32_t size(void) override {
-		//assert(_stream);
-		// returns bytes
-		//SDL_GetAudioStreamAvailable(_stream.get());
-		return -1;
-	}
-
-	std::optional<AudioFrame2> pop(void) override {
-		assert(_stream);
-		if (!_stream) {
-			return std::nullopt;
-		}
-
-		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 AudioFrame2{
-			_sample_rate, _channels,
-			Span<int16_t>(_buffer.data(), read_bytes/sizeof(int16_t)),
-		};
-	}
-
-	bool push(const AudioFrame2&) override {
-		// TODO: make universal sdl stream wrapper (combine with SDLAudioOutputDeviceDefaultInstance)
-		assert(false && "read only");
-		return false;
-	}
-};
-
-SDLAudio2InputDevice::SDLAudio2InputDevice(void) : SDLAudio2InputDevice(SDL_AUDIO_DEVICE_DEFAULT_RECORDING) {
-}
-
-SDLAudio2InputDevice::SDLAudio2InputDevice(SDL_AudioDeviceID conf_device_id) : _configured_device_id(conf_device_id) {
-	if (_configured_device_id == 0) {
-		// TODO: proper error handling
-		throw int(1);
-	}
-}
-
-SDLAudio2InputDevice::~SDLAudio2InputDevice(void) {
-	_streams.clear();
-
-	if (_virtual_device_id != 0) {
-		SDL_CloseAudioDevice(_virtual_device_id);
-		_virtual_device_id = 0;
-	}
-}
-
-std::shared_ptr<FrameStream2I<AudioFrame2>> SDLAudio2InputDevice::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, // required, as AudioFrame2 only supports 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<SDLAudio2StreamReader>();
-	//// TODO: move to ctr
-	//new_stream->_stream = {sdl_stream, &SDL_DestroyAudioStream};
-	//new_stream->_sample_rate = spec.freq;
-	//new_stream->_channels = spec.channels;
-
-	auto new_stream = std::make_shared<AudioStreamPopReFramer<SDLAudio2StreamReader>>();
-	new_stream->_stream._stream = {sdl_stream, &SDL_DestroyAudioStream};
-	new_stream->_stream._sample_rate = spec.freq;
-	new_stream->_stream._channels = spec.channels;
-	new_stream->_frame_length_ms = 5; // WHY DOES THIS FIX MY ISSUE !!!
-
-	_streams.emplace_back(new_stream);
-
-	return new_stream;
-}
-
-bool SDLAudio2InputDevice::unsubscribe(const std::shared_ptr<FrameStream2I<AudioFrame2>>& 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 SDLAudio2OutputDeviceDefaultInstance : public AudioFrame2Stream2I {
-	std::unique_ptr<SDL_AudioStream, decltype(&SDL_DestroyAudioStream)> _stream;
-
-	uint32_t _last_sample_rate {48'000};
-	size_t _last_channels {0};
-
-	// TODO: audio device
-	SDLAudio2OutputDeviceDefaultInstance(void);
-	SDLAudio2OutputDeviceDefaultInstance(SDLAudio2OutputDeviceDefaultInstance&& other);
-
-	~SDLAudio2OutputDeviceDefaultInstance(void);
-
-	int32_t size(void) override;
-	std::optional<AudioFrame2> pop(void) override;
-	bool push(const AudioFrame2& value) override;
-};
-
-SDLAudio2OutputDeviceDefaultInstance::SDLAudio2OutputDeviceDefaultInstance(void) : _stream(nullptr, nullptr) {
-}
-
-SDLAudio2OutputDeviceDefaultInstance::SDLAudio2OutputDeviceDefaultInstance(SDLAudio2OutputDeviceDefaultInstance&& other) : _stream(std::move(other._stream)) {
-}
-
-SDLAudio2OutputDeviceDefaultInstance::~SDLAudio2OutputDeviceDefaultInstance(void) {
-}
-int32_t SDLAudio2OutputDeviceDefaultInstance::size(void) {
-	return -1;
-}
-
-std::optional<AudioFrame2> SDLAudio2OutputDeviceDefaultInstance::pop(void) {
-	assert(false);
-	// this is an output device, there is no data to pop
-	return std::nullopt;
-}
-
-bool SDLAudio2OutputDeviceDefaultInstance::push(const AudioFrame2& value) {
-	if (!static_cast<bool>(_stream)) {
-		return false;
-	}
-
-	// verify here the fame has the same 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
-	) {
-		const SDL_AudioSpec spec = {
-			static_cast<SDL_AudioFormat>(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";
-	}
-
-	auto data = value.getSpan();
-
-	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?
-	}
-
-	_last_sample_rate = value.sample_rate;
-	_last_channels = value.channels;
-
-	return true;
-}
-
-
-SDLAudio2OutputDeviceDefaultSink::~SDLAudio2OutputDeviceDefaultSink(void) {
-	// TODO: pause and close device?
-}
-
-std::shared_ptr<FrameStream2I<AudioFrame2>> SDLAudio2OutputDeviceDefaultSink::subscribe(void) {
-	auto new_instance = std::make_shared<SDLAudio2OutputDeviceDefaultInstance>();
-
-	constexpr SDL_AudioSpec spec = { SDL_AUDIO_S16, 2, 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;
-
-	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 SDLAudio2OutputDeviceDefaultSink::unsubscribe(const std::shared_ptr<FrameStream2I<AudioFrame2>>& sub) {
-	// TODO: i think we should keep track of them
-	if (!sub) {
-		return false;
-	}
-
-	return true;
-}
-

src/frame_streams/sdl/sdl_audio2_frame_stream2.hpp

@@ -1,43 +0,0 @@
-#pragma once
-
-#include "../frame_stream2.hpp"
-#include "../audio_stream2.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 SDLAudio2InputDevice : public FrameStream2SourceI<AudioFrame2> {
-	// 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<AudioFrame2>>> _streams;
-
-	SDLAudio2InputDevice(void);
-	SDLAudio2InputDevice(SDL_AudioDeviceID conf_device_id);
-	~SDLAudio2InputDevice(void);
-
-	std::shared_ptr<FrameStream2I<AudioFrame2>> subscribe(void) override;
-	bool unsubscribe(const std::shared_ptr<FrameStream2I<AudioFrame2>>& sub) override;
-};
-
-// sink
-// constructs entirely new streams, since sdl handles sync and mixing for us (or should)
-struct SDLAudio2OutputDeviceDefaultSink : public FrameStream2SinkI<AudioFrame2> {
-	// TODO: pause device?
-
-	~SDLAudio2OutputDeviceDefaultSink(void);
-
-	std::shared_ptr<FrameStream2I<AudioFrame2>> subscribe(void) override;
-	bool unsubscribe(const std::shared_ptr<FrameStream2I<AudioFrame2>>& sub) override;
-};
-

src/frame_streams/sdl/video.hpp

@@ -1,41 +0,0 @@
-#pragma once
-
-#include <SDL3/SDL.h>
-
-#include <cstdint>
-#include <memory>
-
-// https://youtu.be/71Iw4Q74OaE
-
-inline void nopSurfaceDestructor(SDL_Surface*) {}
-
-// this is very sdl specific
-// but allows us to autoconvert between formats (to a degree)
-struct SDLVideoFrame {
-	// 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_DuplicateSurface(other.surface.get()),
-				&SDL_DestroySurface
-			};
-		}
-	}
-	SDLVideoFrame& operator=(const SDLVideoFrame& other) = delete;
-};
-

src/frame_streams/sdl/video_push_converter.cpp

@@ -1,58 +0,0 @@
-#include "./video_push_converter.hpp"
-
-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;
-}
-

src/frame_streams/sdl/video_push_converter.hpp

@@ -1,89 +0,0 @@
-#pragma once
-
-#include "./video.hpp"
-#include "../frame_stream2.hpp"
-
-#include <cassert>
-
-#include <iostream> // meh
-
-static bool isFormatYUV(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
-	;
-}
-
-SDL_Surface* convertYUY2_IYUV(SDL_Surface* surf);
-
-template<typename RealStream>
-struct PushConversionVideoStream : public RealStream {
-	SDL_PixelFormat _forced_format {SDL_PIXELFORMAT_IYUV};
-
-	template<typename... Args>
-	PushConversionVideoStream(SDL_PixelFormat forced_format, Args&&... args) : RealStream(std::forward<Args>(args)...), _forced_format(forced_format) {}
-	~PushConversionVideoStream(void) {}
-
-	bool push(const SDLVideoFrame& value) override {
-		SDL_Surface* surf = value.surface.get();
-		if (surf->format != _forced_format) {
-			//std::cerr << "DTC: need to convert from " << SDL_GetPixelFormatName(converted_surf->format) << " to SDL_PIXELFORMAT_IYUV\n";
-			if (surf->format == SDL_PIXELFORMAT_YUY2 && _forced_format == SDL_PIXELFORMAT_IYUV) {
-				// optimized custom impl
-
-				//auto start = Message::getTimeMS();
-				surf = convertYUY2_IYUV(surf);
-				//auto end = Message::getTimeMS();
-				// 3ms
-				//std::cerr << "DTC: timing " << SDL_GetPixelFormatName(converted_surf->format) << "->SDL_PIXELFORMAT_IYUV: " << end-start << "ms\n";
-			} else if (isFormatYUV(surf->format)) {
-				// TODO: fix sdl rgb->yuv conversion resulting in too dark (colorspace) issues
-				// https://github.com/libsdl-org/SDL/issues/10877
-
-				// meh, need to convert to rgb as a stopgap
-
-				//auto start = Message::getTimeMS();
-				SDL_Surface* tmp_conv_surf = SDL_ConvertSurfaceAndColorspace(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";
-
-				//start = Message::getTimeMS();
-				surf = SDL_ConvertSurfaceAndColorspace(tmp_conv_surf, _forced_format, nullptr, SDL_COLORSPACE_YUV_DEFAULT, 0);
-				//end = Message::getTimeMS();
-				// 60ms
-				//std::cerr << "DTC: timing SDL_PIXELFORMAT_RGB24->" << SDL_GetPixelFormatName(_forced_format) << ": " << end-start << "ms\n";
-
-				SDL_DestroySurface(tmp_conv_surf);
-			} else {
-				surf = SDL_ConvertSurface(surf, _forced_format);
-			}
-
-			if (surf == nullptr) {
-				// oh god
-				std::cerr << "DTC error: failed to convert surface to IYUV: " << SDL_GetError() << "\n";
-				return false;
-			}
-		}
-		assert(surf != nullptr);
-		if (surf != value.surface.get()) {
-			// TODO: add ctr with uptr
-			SDLVideoFrame new_value{value.timestampUS, nullptr};
-			new_value.surface = {
-				surf,
-				&SDL_DestroySurface
-			};
-
-			return RealStream::push(std::move(new_value));
-		} else {
-			return RealStream::push(value);
-		}
-	}
-};
-

src/frame_streams/stream_manager.cpp

@@ -1,206 +0,0 @@
-#include "./stream_manager.hpp"
-
-StreamManager::Connection::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_
-) :
-	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;
-		});
-	}
-}
-
-StreamManager::StreamManager(ObjectStore2& os) : _os(os) {
-	_os.subscribe(this, ObjectStore_Event::object_construct);
-	//_os.subscribe(this, ObjectStore_Event::object_update);
-	_os.subscribe(this, ObjectStore_Event::object_destroy);
-}
-
-StreamManager::~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);
-	}
-}
-
-bool StreamManager::connect(Object src, Object sink, bool threaded) {
-	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);
-}
-
-bool StreamManager::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;
-}
-
-bool StreamManager::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 StreamManager::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 2.f; // TODO: 2sec makes mainthread connections unusable
-}
-
-bool StreamManager::onEvent(const ObjectStore::Events::ObjectConstruct& e) {
-	if (!e.e.any_of<Components::StreamSink, Components::StreamSource>()) {
-		return false;
-	}
-
-	// update default targets
-	if (e.e.all_of<Components::TagDefaultTarget>()) {
-		if (e.e.all_of<Components::StreamSource>()) {
-			_default_sources[e.e.get<Components::StreamSource>().frame_type_name] = e.e;
-		} else { // sink
-			_default_sinks[e.e.get<Components::StreamSink>().frame_type_name] = e.e;
-		}
-	}
-
-	// connect to default
-	// only ever do this on new objects
-	if (e.e.all_of<Components::TagConnectToDefault>()) {
-		if (e.e.all_of<Components::StreamSource>()) {
-			auto it_d_sink = _default_sinks.find(e.e.get<Components::StreamSource>().frame_type_name);
-			if (it_d_sink != _default_sinks.cend()) {
-				// TODO: threaded
-				connect(e.e, it_d_sink->second);
-			}
-		} else { // sink
-			auto it_d_src = _default_sources.find(e.e.get<Components::StreamSink>().frame_type_name);
-			if (it_d_src != _default_sources.cend()) {
-				// TODO: threaded
-				connect(it_d_src->second, e.e);
-			}
-		}
-	}
-
-	return false;
-}
-
-bool StreamManager::onEvent(const ObjectStore::Events::ObjectUpdate&) {
-	// what do we do here?
-	return false;
-}
-
-bool StreamManager::onEvent(const ObjectStore::Events::ObjectDestory& e) {
-	// typeless
-	for (auto it = _default_sources.cbegin(); it != _default_sources.cend();) {
-		if (it->second == e.e) {
-			it = _default_sources.erase(it);
-		} else {
-			it++;
-		}
-	}
-	for (auto it = _default_sinks.cbegin(); it != _default_sinks.cend();) {
-		if (it->second == e.e) {
-			it = _default_sinks.erase(it);
-		} else {
-			it++;
-		}
-	}
-
-	// TODO: destroy connections
-	// TODO: auto reconnect default following devices if another default exists
-
-	return false;
-}
-

src/frame_streams/stream_manager.hpp

@@ -1,222 +0,0 @@
-#pragma once
-
-#include <solanaceae/object_store/fwd.hpp>
-#include <solanaceae/object_store/object_store.hpp>
-
-#include <entt/core/type_info.hpp>
-
-#include "./frame_stream2.hpp"
-
-#include <unordered_map>
-#include <vector>
-#include <memory>
-#include <algorithm>
-#include <thread>
-#include <chrono>
-#include <atomic>
-
-// fwd
-class StreamManager;
-
-namespace Components {
-
-	// mark a source or sink as the(a) default
-	struct TagDefaultTarget {};
-
-	// mark a source/sink as to be connected to a default sink/source
-	// of the same type
-	struct TagConnectToDefault {};
-
-	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 : protected ObjectStoreEventI {
-	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; // TODO: make it return next interval?
-		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
-		// TODO
-
-		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
-		);
-	};
-	std::vector<std::unique_ptr<Connection>> _connections;
-
-	std::unordered_map<std::string, Object> _default_sources;
-	std::unordered_map<std::string, Object> _default_sinks;
-
-	public:
-		StreamManager(ObjectStore2& os);
-		virtual ~StreamManager(void);
-
-		template<typename FrameType>
-		bool connect(Object src, Object sink, bool threaded = true);
-
-		bool connect(Object src, Object sink, bool threaded = true);
-		bool disconnect(Object src, Object sink);
-		bool disconnectAll(Object o);
-
-		// do we need the time delta?
-		float tick(float);
-
-	protected:
-		bool onEvent(const ObjectStore::Events::ObjectConstruct&) override;
-		bool onEvent(const ObjectStore::Events::ObjectUpdate&) override;
-		bool onEvent(const ObjectStore::Events::ObjectDestory&) override;
-};
-
-// template impls
-
-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
-
-template<typename FrameType>
-bool StreamManager::connect(Object src, Object sink, bool threaded) {
-	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;
-}
-

src/frame_streams/test_pop_reframer.cpp

@@ -1,155 +0,0 @@
-#include <iostream>
-
-#include "./audio_stream_pop_reframer.hpp"
-#include "./locked_frame_stream.hpp"
-
-#include <cassert>
-
-int main(void) {
-	{ // pump perfect
-		AudioStreamPopReFramer<LockedFrameStream2<AudioFrame2>> stream;
-		stream._frame_length_ms = 10;
-
-		AudioFrame2 f1 {
-			48'000,
-			1,
-			{},
-		};
-		f1.buffer = std::vector<int16_t>(
-			// perfect size
-			stream._frame_length_ms * f1.sample_rate * f1.channels / 1000,
-			0
-		);
-
-		{ // fill with sequential value
-			int16_t seq = 0;
-			for (auto& v : std::get<std::vector<int16_t>>(f1.buffer)) {
-				v = seq++;
-			}
-		}
-
-		stream.push(f1);
-
-		auto ret_opt = stream.pop();
-		assert(ret_opt);
-
-		auto& ret = ret_opt.value();
-		assert(ret.sample_rate == f1.sample_rate);
-		assert(ret.channels == f1.channels);
-		assert(ret.getSpan().size == f1.getSpan().size);
-		{
-			int16_t seq = 0;
-			for (const auto v : ret.getSpan()) {
-				assert(v == seq++);
-			}
-		}
-	}
-
-	{ // pump half
-		AudioStreamPopReFramer<LockedFrameStream2<AudioFrame2>> stream;
-		stream._frame_length_ms = 10;
-
-		AudioFrame2 f1 {
-			48'000,
-			1,
-			{},
-		};
-		f1.buffer = std::vector<int16_t>(
-			// perfect size
-			(stream._frame_length_ms * f1.sample_rate * f1.channels / 1000) / 2,
-			0
-		);
-		AudioFrame2 f2 {
-			48'000,
-			1,
-			{},
-		};
-		f2.buffer = std::vector<int16_t>(
-			// perfect size
-			(stream._frame_length_ms * f1.sample_rate * f1.channels / 1000) / 2,
-			0
-		);
-
-		{ // fill with sequential value
-			int16_t seq = 0;
-			for (auto& v : std::get<std::vector<int16_t>>(f1.buffer)) {
-				v = seq++;
-			}
-			for (auto& v : std::get<std::vector<int16_t>>(f2.buffer)) {
-				v = seq++;
-			}
-		}
-
-		stream.push(f1);
-		stream.push(f2);
-
-		// supposed to combine both
-		auto ret_opt = stream.pop();
-		assert(ret_opt);
-
-		auto& ret = ret_opt.value();
-		assert(ret.sample_rate == f1.sample_rate);
-		assert(ret.channels == f1.channels);
-		assert(ret.getSpan().size == stream._frame_length_ms * f1.sample_rate * f1.channels / 1000);
-		{
-			int16_t seq = 0;
-			for (const auto v : ret.getSpan()) {
-				assert(v == seq++);
-			}
-		}
-	}
-
-	{ // pump double
-		AudioStreamPopReFramer<LockedFrameStream2<AudioFrame2>> stream;
-		stream._frame_length_ms = 20;
-
-		AudioFrame2 f1 {
-			48'000,
-			2,
-			{},
-		};
-		f1.buffer = std::vector<int16_t>(
-			// perfect size
-			(stream._frame_length_ms * f1.sample_rate * f1.channels / 1000) * 2,
-			0
-		);
-		{ // fill with sequential value
-			int16_t seq = 0;
-			for (auto& v : std::get<std::vector<int16_t>>(f1.buffer)) {
-				v = seq++;
-			}
-		}
-
-		stream.push(f1);
-
-		// pop 2x
-		int16_t seq = 0;
-		{
-			auto ret_opt = stream.pop();
-			assert(ret_opt);
-
-			auto& ret = ret_opt.value();
-			assert(ret.sample_rate == f1.sample_rate);
-			assert(ret.channels == f1.channels);
-			assert(ret.getSpan().size == stream._frame_length_ms * f1.sample_rate * f1.channels / 1000);
-			for (const auto v : ret.getSpan()) {
-				assert(v == seq++);
-			}
-		}
-
-		{
-			auto ret_opt = stream.pop();
-			assert(ret_opt);
-
-			auto& ret = ret_opt.value();
-			assert(ret.sample_rate == f1.sample_rate);
-			assert(ret.channels == f1.channels);
-			assert(ret.getSpan().size == stream._frame_length_ms * f1.sample_rate * f1.channels / 1000);
-			for (const auto v : ret.getSpan()) {
-				assert(v == seq++);
-			}
-		}
-	}
-
-	return 0;
-}

src/frame_streams/voip_model.hpp

@@ -1,77 +0,0 @@
-#pragma once
-
-#include <solanaceae/contact/contact_model3.hpp>
-#include <solanaceae/object_store/fwd.hpp>
-
-struct VoIPModelI;
-
-namespace Components::VoIP {
-
-	struct TagVoIPSession {};
-
-	// getting called or invited by
-	struct Incoming {
-		Contact3 c{entt::null};
-	};
-
-	struct DefaultConfig {
-		bool incoming_audio {true};
-		bool incoming_video {true};
-		bool outgoing_audio {true};
-		bool outgoing_video {true};
-	};
-
-	// to talk to the model handling this session
-	//struct VoIPModel {
-		//VoIPModelI* ptr {nullptr};
-	//};
-
-	struct SessionState {
-		// ????
-		// incoming
-		// outgoing
-		enum class State {
-			RINGING,
-			CONNECTED,
-		} state;
-	};
-
-	struct SessionContact {
-		Contact3 c{entt::null};
-	};
-
-	struct StreamSources {
-		// list of all stream sources originating from this VoIP session
-		std::vector<Object> streams;
-	};
-
-	struct StreamSinks {
-		// list of all stream sinks going to this VoIP session
-		std::vector<Object> streams;
-	};
-
-} // Components::VoIP
-
-// TODO: events? piggyback on objects?
-
-// stream model instead?? -> more generic than "just" audio and video?
-// or specialized like this
-// streams abstract type in a nice way
-struct VoIPModelI {
-	virtual ~VoIPModelI(void) {}
-
-	// enters a call/voicechat/videocall ???
-	// - contact
-	// - default stream sources/sinks ?
-	// - enable a/v ? -> done on connecting to sources
-	// returns object tieing together the VoIP session
-	virtual ObjectHandle enter(const Contact3 c, const Components::VoIP::DefaultConfig& defaults = {true, true, true, true}) { (void)c,(void)defaults; return {}; }
-
-	// accept/join an invite to a session
-	virtual bool accept(ObjectHandle session, const Components::VoIP::DefaultConfig& defaults = {true, true, true, true}) { (void)session,(void)defaults; return false; }
-
-	// leaves a call
-	// - VoIP session object
-	virtual bool leave(ObjectHandle session) { (void)session; return false; }
-};
-

src/main.cpp

@@ -28,8 +28,6 @@ int main(int argc, char** argv) {
 
 	runSysCheck();
 
-	SDL_SetAppMetadata("tomato", "0.0.0-wip", nullptr);
-
 #ifdef __ANDROID__
 	// change current working dir to internal storage
 	std::filesystem::current_path(SDL_GetAndroidInternalStoragePath());
@@ -37,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

src/main_screen.cpp

@@ -5,8 +5,6 @@
 
 #include <solanaceae/contact/components.hpp>
 
-#include "./frame_streams/sdl/sdl_audio2_frame_stream2.hpp"
-
 #include <imgui/imgui.h>
 
 #include <SDL3/SDL.h>
@@ -21,18 +19,16 @@ 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()),
+#endif
 	tcm(cr, tc, tc),
 	tmm(rmm, cr, tcm, tc, tc),
 	ttm(rmm, cr, tcm, tc, tc, os),
 	tffom(cr, rmm, tcm, tc, tc),
-#if TOMATO_TOX_AV
-	tav(tc.getTox()),
-	tavvoip(os, tav, cr, tcm),
-#endif
 	theme(theme_),
 	mmil(rmm),
 	tam(/*rmm, */ os, cr, conf),
@@ -46,8 +42,7 @@ MainScreen::MainScreen(SimpleConfigModel&& conf_, SDL_Renderer* renderer_, Theme
 	osui(os),
 	tuiu(tc, conf),
 	tdch(tpi),
-	smui(os, sm),
-	dvt(os, sm, sdlrtu)
+	tnui(tpi)
 {
 	tel.subscribeAll(tc);
 
@@ -81,7 +76,7 @@ MainScreen::MainScreen(SimpleConfigModel&& conf_, SDL_Renderer* renderer_, Theme
 		g_provideInstance<ToxPrivateI>("ToxPrivateI", "host", &tpi);
 		g_provideInstance<ToxEventProviderI>("ToxEventProviderI", "host", &tc);
 #if TOMATO_TOX_AV
-		g_provideInstance<ToxAVI>("ToxAVI", "host", &tav);
+		g_provideInstance<ToxAV>("ToxAV", "host", &tav);
 #endif
 		g_provideInstance<ToxContactModel2>("ToxContactModel2", "host", &tcm);
 
@@ -142,46 +137,9 @@ MainScreen::MainScreen(SimpleConfigModel&& conf_, SDL_Renderer* renderer_, Theme
 	}
 
 	conf.dump();
-
-	if (SDL_InitSubSystem(SDL_INIT_AUDIO)) {
-		// add system audio devices
-		{ // audio in
-			ObjectHandle asrc {os.registry(), os.registry().create()};
-			try {
-				asrc.emplace<Components::FrameStream2Source<AudioFrame2>>(
-					std::make_unique<SDLAudio2InputDevice>()
-				);
-
-				asrc.emplace<Components::StreamSource>(Components::StreamSource::create<AudioFrame2>("SDL Audio Default Recording Device"));
-				asrc.emplace<Components::TagDefaultTarget>();
-
-				os.throwEventConstruct(asrc);
-			} catch (...) {
-				os.registry().destroy(asrc);
-			}
-		}
-		{ // audio out
-			ObjectHandle asink {os.registry(), os.registry().create()};
-			try {
-				asink.emplace<Components::FrameStream2Sink<AudioFrame2>>(
-					std::make_unique<SDLAudio2OutputDeviceDefaultSink>()
-				);
-
-				asink.emplace<Components::StreamSink>(Components::StreamSink::create<AudioFrame2>("SDL Audio Default Playback Device"));
-				asink.emplace<Components::TagDefaultTarget>();
-
-				os.throwEventConstruct(asink);
-			} catch (...) {
-				os.registry().destroy(asink);
-			}
-		}
-	} else {
-		std::cerr << "MS warning: no sdl audio: " << SDL_GetError() << "\n";
-	}
 }
 
 MainScreen::~MainScreen(void) {
-	// TODO: quit sdl audio
 }
 
 bool MainScreen::handleEvent(SDL_Event& e) {
@@ -303,8 +261,7 @@ Screen* MainScreen::render(float time_delta, bool&) {
 	osui.render();
 	tuiu.render(); // render
 	tdch.render(); // render
-	smui.render();
-	const float dvt_interval = dvt.render();
+	const float tnui_interval = tnui.render(time_delta);
 
 	{ // main window menubar injection
 		if (ImGui::Begin("tomato")) {
@@ -487,7 +444,7 @@ Screen* MainScreen::render(float time_delta, bool&) {
 	if (!_window_hidden && _time_since_event < curr_profile.low_delay_window) {
 		_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, dvt_interval);
+		_render_interval = std::min<float>(_render_interval, tnui_interval);
 
 		_render_interval = std::clamp(
 			_render_interval,
@@ -498,7 +455,7 @@ Screen* MainScreen::render(float time_delta, bool&) {
 	} else if (!_window_hidden && _time_since_event < curr_profile.mid_delay_window) {
 		_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, dvt_interval);
+		_render_interval = std::min<float>(_render_interval, tnui_interval);
 
 		_render_interval = std::clamp(
 			_render_interval,
@@ -521,20 +478,8 @@ Screen* MainScreen::render(float time_delta, bool&) {
 }
 
 Screen* MainScreen::tick(float time_delta, bool& quit) {
-	const float sm_interval = sm.tick(time_delta);
-
 	quit = !tc.iterate(time_delta); // compute
 
-#if TOMATO_TOX_AV
-	tav.toxavIterate();
-	// breaks it
-	// HACK: pow by 1.18 to increase 200 -> ~500
-	//const float av_interval = std::pow(tav.toxavIterationInterval(), 1.18)/1000.f;
-	const float av_interval = tav.toxavIterationInterval()/1000.f;
-
-	tavvoip.tick();
-#endif
-
 	tcm.iterate(time_delta); // compute
 
 	const float fo_interval = tffom.tick(time_delta);
@@ -544,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)
 
@@ -564,22 +510,11 @@ Screen* MainScreen::tick(float time_delta, bool& quit) {
 		std::pow(tc.toxIterationInterval(), 1.6f)/1000.f,
 		pm_interval
 	);
-	_min_tick_interval = std::min<float>(
-		_min_tick_interval,
-		sm_interval
-	);
 	_min_tick_interval = std::min<float>(
 		_min_tick_interval,
 		fo_interval
 	);
 
-#if TOMATO_TOX_AV
-	_min_tick_interval = std::min<float>(
-		_min_tick_interval,
-		av_interval
-	);
-#endif
-
 	//std::cout << "MS: min tick interval: " << _min_tick_interval << "\n";
 
 	switch (_compute_perf_mode) {

src/main_screen.hpp

@@ -11,7 +11,6 @@
 #include <solanaceae/plugin/plugin_manager.hpp>
 #include <solanaceae/toxcore/tox_event_logger.hpp>
 #include "./tox_private_impl.hpp"
-#include "./frame_streams/stream_manager.hpp"
 
 #include <solanaceae/tox_contacts/tox_contact_model2.hpp>
 #include <solanaceae/tox_messages/tox_message_manager.hpp>
@@ -33,13 +32,11 @@
 #include "./object_store_ui.hpp"
 #include "./tox_ui_utils.hpp"
 #include "./tox_dht_cap_histo.hpp"
+#include "./tox_netprof_ui.hpp"
 #include "./tox_friend_faux_offline_messaging.hpp"
-#include "./stream_manager_ui.hpp"
-#include "./debug_video_tap.hpp"
 
 #if TOMATO_TOX_AV
 #include "./tox_av.hpp"
-#include "./tox_av_voip_model.hpp"
 #endif
 
 #include <string>
@@ -62,20 +59,17 @@ 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;
+#endif
 	ToxContactModel2 tcm;
 	ToxMessageManager tmm;
 	ToxTransferManager ttm;
 	ToxFriendFauxOfflineMessaging tffom;
-#if TOMATO_TOX_AV
-	ToxAVI tav;
-	ToxAVVoIPModel tavvoip;
-#endif
 
 	Theme& theme;
 
@@ -95,8 +89,7 @@ struct MainScreen final : public Screen {
 	ObjectStoreUI osui;
 	ToxUIUtils tuiu;
 	ToxDHTCapHisto tdch;
-	StreamManagerUI smui;
-	DebugVideoTap dvt;
+	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_ui.cpp

@@ -1,234 +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)));
-
-					if (_os.registry().all_of<Components::TagDefaultTarget>(oc)) {
-						ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg1, ImGui::GetColorU32(ImVec4{0.6f, 0.f, 0.6f, 0.25f}));
-					} else if (_os.registry().all_of<Components::TagConnectToDefault>(oc)) {
-						ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg1, ImGui::GetColorU32(ImVec4{0.6f, 0.6f, 0.f, 0.25f}));
-					}
-
-					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)));
-
-					if (_os.registry().all_of<Components::TagDefaultTarget>(oc)) {
-						ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg1, ImGui::GetColorU32(ImVec4{0.6f, 0.f, 0.6f, 0.25f}));
-					} else if (_os.registry().all_of<Components::TagConnectToDefault>(oc)) {
-						ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg1, ImGui::GetColorU32(ImVec4{0.6f, 0.6f, 0.f, 0.25f}));
-					}
-
-					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 "./frame_streams/stream_manager.hpp"
-
-class StreamManagerUI {
-	ObjectStore2& _os;
-	StreamManager& _sm;
-
-	bool _show_window {false};
-
-	public:
-		StreamManagerUI(ObjectStore2& os, StreamManager& sm);
-
-		void render(void);
-};
-

src/tox_av.cpp

@@ -2,239 +2,81 @@
 
 #include <cassert>
 
-#include <cstdint>
-#include <iostream>
-
 // https://almogfx.bandcamp.com/track/crushed-w-cassade
 
-ToxAVI::ToxAVI(Tox* tox) : _tox(tox) {
+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<ToxAVI*>(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<ToxAVI*>(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<ToxAVI*>(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<ToxAVI*>(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<ToxAVI*>(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<ToxAVI*>(user_data)->cb_video_receive_frame(friend_number, width, height, y, u, v, ystride, ustride, vstride);
-		},
-		this
-	);
 }
-
-ToxAVI::~ToxAVI(void) {
+ToxAV::~ToxAV(void) {
 	toxav_kill(_tox_av);
 }
 
-uint32_t ToxAVI::toxavIterationInterval(void) const {
+uint32_t ToxAV::toxavIterationInterval(void) const {
 	return toxav_iteration_interval(_tox_av);
 }
 
-void ToxAVI::toxavIterate(void) {
+void ToxAV::toxavIterate(void) {
 	toxav_iterate(_tox_av);
 }
 
-uint32_t ToxAVI::toxavAudioIterationInterval(void) const {
+uint32_t ToxAV::toxavAudioIterationInterval(void) const {
 	return toxav_audio_iteration_interval(_tox_av);
 }
 
-void ToxAVI::toxavAudioIterate(void) {
+void ToxAV::toxavAudioIterate(void) {
 	toxav_audio_iterate(_tox_av);
 }
 
-uint32_t ToxAVI::toxavVideoIterationInterval(void) const {
+uint32_t ToxAV::toxavVideoIterationInterval(void) const {
 	return toxav_video_iteration_interval(_tox_av);
 }
 
-void ToxAVI::toxavVideoIterate(void) {
+void ToxAV::toxavVideoIterate(void) {
 	toxav_video_iterate(_tox_av);
 }
 
-Toxav_Err_Call ToxAVI::toxavCall(uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate) {
+Toxav_Err_Call ToxAV::toxavCall(uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate) {
 	Toxav_Err_Call err {TOXAV_ERR_CALL_OK};
 	toxav_call(_tox_av, friend_number, audio_bit_rate, video_bit_rate, &err);
 	return err;
 }
 
-Toxav_Err_Answer ToxAVI::toxavAnswer(uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate) {
+Toxav_Err_Answer ToxAV::toxavAnswer(uint32_t friend_number, uint32_t audio_bit_rate, uint32_t video_bit_rate) {
 	Toxav_Err_Answer err {TOXAV_ERR_ANSWER_OK};
 	toxav_answer(_tox_av, friend_number, audio_bit_rate, video_bit_rate, &err);
 	return err;
 }
 
-Toxav_Err_Call_Control ToxAVI::toxavCallControl(uint32_t friend_number, Toxav_Call_Control control) {
+Toxav_Err_Call_Control ToxAV::toxavCallControl(uint32_t friend_number, Toxav_Call_Control control) {
 	Toxav_Err_Call_Control err {TOXAV_ERR_CALL_CONTROL_OK};
 	toxav_call_control(_tox_av, friend_number, control, &err);
 	return err;
 }
 
-Toxav_Err_Send_Frame ToxAVI::toxavAudioSendFrame(uint32_t friend_number, const int16_t pcm[], size_t sample_count, uint8_t channels, uint32_t sampling_rate) {
+Toxav_Err_Send_Frame ToxAV::toxavAudioSendFrame(uint32_t friend_number, const int16_t pcm[], size_t sample_count, uint8_t channels, uint32_t sampling_rate) {
 	Toxav_Err_Send_Frame err {TOXAV_ERR_SEND_FRAME_OK};
 	toxav_audio_send_frame(_tox_av, friend_number, pcm, sample_count, channels, sampling_rate, &err);
 	return err;
 }
 
-Toxav_Err_Bit_Rate_Set ToxAVI::toxavAudioSetBitRate(uint32_t friend_number, uint32_t bit_rate) {
+Toxav_Err_Bit_Rate_Set ToxAV::toxavAudioSetBitRate(uint32_t friend_number, uint32_t bit_rate) {
 	Toxav_Err_Bit_Rate_Set err {TOXAV_ERR_BIT_RATE_SET_OK};
 	toxav_audio_set_bit_rate(_tox_av, friend_number, bit_rate, &err);
 	return err;
 }
 
-Toxav_Err_Send_Frame ToxAVI::toxavVideoSendFrame(uint32_t friend_number, uint16_t width, uint16_t height, const uint8_t y[], const uint8_t u[], const uint8_t v[]) {
+Toxav_Err_Send_Frame ToxAV::toxavVideoSendFrame(uint32_t friend_number, uint16_t width, uint16_t height, const uint8_t y[], const uint8_t u[], const uint8_t v[]) {
 	Toxav_Err_Send_Frame err {TOXAV_ERR_SEND_FRAME_OK};
 	toxav_video_send_frame(_tox_av, friend_number, width, height, y, u, v, &err);
 	return err;
 }
 
-Toxav_Err_Bit_Rate_Set ToxAVI::toxavVideoSetBitRate(uint32_t friend_number, uint32_t bit_rate) {
+Toxav_Err_Bit_Rate_Set ToxAV::toxavVideoSetBitRate(uint32_t friend_number, uint32_t bit_rate) {
 	Toxav_Err_Bit_Rate_Set err {TOXAV_ERR_BIT_RATE_SET_OK};
 	toxav_video_set_bit_rate(_tox_av, friend_number, bit_rate, &err);
 	return err;
 }
 
-void ToxAVI::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 ToxAVI::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 ToxAVI::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 ToxAVI::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 ToxAVI::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 ToxAVI::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,99 +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>;
-
-// TODO: seperate out implementation from interface
-struct ToxAVI : public ToxAVEventProviderI {
+struct ToxAV {
 	Tox* _tox = nullptr;
 	ToxAV* _tox_av = nullptr;
 
-	static constexpr const char* version {"0"};
-
-	ToxAVI(Tox* tox);
-	virtual ~ToxAVI(void);
+	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);
 
@@ -117,32 +33,5 @@ struct ToxAVI : 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
-	);
-};
-
-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; }
 };
 

src/tox_av_voip_model.cpp

@@ -1,711 +0,0 @@
-#include "./tox_av_voip_model.hpp"
-
-#include <solanaceae/object_store/object_store.hpp>
-#include <solanaceae/tox_contacts/components.hpp>
-
-#include "./frame_streams/stream_manager.hpp"
-#include "./frame_streams/audio_stream2.hpp"
-#include "./frame_streams/locked_frame_stream.hpp"
-#include "./frame_streams/multi_source.hpp"
-#include "./frame_streams/audio_stream_pop_reframer.hpp"
-
-#include "./frame_streams/sdl/video.hpp"
-#include "./frame_streams/sdl/video_push_converter.hpp"
-
-#include <cstring>
-
-#include <iostream>
-
-// fwd
-namespace Message {
-uint64_t getTimeMS(void);
-} // Message
-
-namespace Components {
-	struct ToxAVIncomingAV {
-		bool incoming_audio {false};
-		bool incoming_video {false};
-	};
-
-	struct ToxAVAudioSink {
-		ObjectHandle o;
-		// ptr?
-	};
-	struct ToxAVVideoSink {
-		ObjectHandle o;
-	};
-	struct ToxAVAudioSource {
-		ObjectHandle o;
-	};
-	struct ToxAVVideoSource {
-		ObjectHandle o;
-	};
-} // Components
-
-struct ToxAVCallAudioSink : public FrameStream2SinkI<AudioFrame2> {
-	ToxAVI& _toxav;
-
-	// bitrate for enabled state
-	uint32_t _audio_bitrate {32};
-
-	uint32_t _fid;
-	std::shared_ptr<AudioStreamPopReFramer<LockedFrameStream2<AudioFrame2>>> _writer;
-
-	ToxAVCallAudioSink(ToxAVI& toxav, uint32_t fid) : _toxav(toxav), _fid(fid) {}
-	~ToxAVCallAudioSink(void) {
-		if (_writer) {
-			_writer = nullptr;
-			_toxav.toxavAudioSetBitRate(_fid, 0);
-		}
-	}
-
-	// sink
-	std::shared_ptr<FrameStream2I<AudioFrame2>> 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;
-		}
-
-		// 20ms for now, 10ms would work too, further investigate stutters at 5ms (probably too slow interval rate)
-		_writer = std::make_shared<AudioStreamPopReFramer<LockedFrameStream2<AudioFrame2>>>(20);
-
-		return _writer;
-	}
-
-	bool unsubscribe(const std::shared_ptr<FrameStream2I<AudioFrame2>>& 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;
-	}
-};
-
-// exlusive
-struct ToxAVCallVideoSink : public FrameStream2SinkI<SDLVideoFrame> {
-	using stream_type = PushConversionVideoStream<LockedFrameStream2<SDLVideoFrame>>;
-	ToxAVI& _toxav;
-
-	// bitrate for enabled state
-	uint32_t _video_bitrate {2}; // HACK: hardcode to 2mbits (toxap wrongly multiplies internally by 1000)
-
-	uint32_t _fid;
-	std::shared_ptr<stream_type> _writer;
-
-	ToxAVCallVideoSink(ToxAVI& 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;
-		}
-
-		// toxav needs I420
-		_writer = std::make_shared<stream_type>(SDL_PIXELFORMAT_IYUV);
-
-		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;
-	}
-};
-
-void ToxAVVoIPModel::addAudioSource(ObjectHandle session, uint32_t friend_number) {
-	auto& stream_source = session.get_or_emplace<Components::VoIP::StreamSources>().streams;
-
-	ObjectHandle incoming_audio {_os.registry(), _os.registry().create()};
-
-	auto new_asrc = std::make_unique<FrameStream2MultiSource<AudioFrame2>>();
-	incoming_audio.emplace<FrameStream2MultiSource<AudioFrame2>*>(new_asrc.get());
-	incoming_audio.emplace<Components::FrameStream2Source<AudioFrame2>>(std::move(new_asrc));
-	incoming_audio.emplace<Components::StreamSource>(Components::StreamSource::create<AudioFrame2>("ToxAV Friend Call Incoming Audio"));
-
-	if (
-		const auto* defaults = session.try_get<Components::VoIP::DefaultConfig>();
-		defaults != nullptr && defaults->incoming_audio
-	) {
-		incoming_audio.emplace<Components::TagConnectToDefault>(); // depends on what was specified in enter()
-	}
-
-	stream_source.push_back(incoming_audio);
-	session.emplace<Components::ToxAVAudioSource>(incoming_audio);
-	// TODO: tie session to stream
-
-	_audio_sources[friend_number] = incoming_audio;
-
-	_os.throwEventConstruct(incoming_audio);
-}
-
-void ToxAVVoIPModel::addAudioSink(ObjectHandle session, uint32_t friend_number) {
-	auto& stream_sinks = session.get_or_emplace<Components::VoIP::StreamSinks>().streams;
-	ObjectHandle outgoing_audio {_os.registry(), _os.registry().create()};
-
-	auto new_asink = std::make_unique<ToxAVCallAudioSink>(_av, friend_number);
-	outgoing_audio.emplace<ToxAVCallAudioSink*>(new_asink.get());
-	outgoing_audio.emplace<Components::FrameStream2Sink<AudioFrame2>>(std::move(new_asink));
-	outgoing_audio.emplace<Components::StreamSink>(Components::StreamSink::create<AudioFrame2>("ToxAV Friend Call Outgoing Audio"));
-
-	if (
-		const auto* defaults = session.try_get<Components::VoIP::DefaultConfig>();
-		defaults != nullptr && defaults->outgoing_audio
-	) {
-		outgoing_audio.emplace<Components::TagConnectToDefault>(); // depends on what was specified in enter()
-	}
-
-	stream_sinks.push_back(outgoing_audio);
-	session.emplace<Components::ToxAVAudioSink>(outgoing_audio);
-	// TODO: tie session to stream
-
-	_os.throwEventConstruct(outgoing_audio);
-}
-
-void ToxAVVoIPModel::addVideoSource(ObjectHandle session, uint32_t friend_number) {
-	auto& stream_source = session.get_or_emplace<Components::VoIP::StreamSources>().streams;
-
-	ObjectHandle incoming_video {_os.registry(), _os.registry().create()};
-
-	auto new_vsrc = std::make_unique<FrameStream2MultiSource<SDLVideoFrame>>();
-	incoming_video.emplace<FrameStream2MultiSource<SDLVideoFrame>*>(new_vsrc.get());
-	incoming_video.emplace<Components::FrameStream2Source<SDLVideoFrame>>(std::move(new_vsrc));
-	incoming_video.emplace<Components::StreamSource>(Components::StreamSource::create<SDLVideoFrame>("ToxAV Friend Call Incoming Video"));
-
-	if (
-		const auto* defaults = session.try_get<Components::VoIP::DefaultConfig>();
-		defaults != nullptr && defaults->incoming_video
-	) {
-		incoming_video.emplace<Components::TagConnectToDefault>(); // depends on what was specified in enter()
-	}
-
-	stream_source.push_back(incoming_video);
-	session.emplace<Components::ToxAVVideoSource>(incoming_video);
-	// TODO: tie session to stream
-
-	_video_sources[friend_number] = incoming_video;
-
-	_os.throwEventConstruct(incoming_video);
-}
-
-void ToxAVVoIPModel::addVideoSink(ObjectHandle session, uint32_t friend_number) {
-	auto& stream_sinks = session.get_or_emplace<Components::VoIP::StreamSinks>().streams;
-	ObjectHandle outgoing_video {_os.registry(), _os.registry().create()};
-
-	auto new_vsink = std::make_unique<ToxAVCallVideoSink>(_av, friend_number);
-	outgoing_video.emplace<ToxAVCallVideoSink*>(new_vsink.get());
-	outgoing_video.emplace<Components::FrameStream2Sink<SDLVideoFrame>>(std::move(new_vsink));
-	outgoing_video.emplace<Components::StreamSink>(Components::StreamSink::create<SDLVideoFrame>("ToxAV Friend Call Outgoing Video"));
-
-	if (
-		const auto* defaults = session.try_get<Components::VoIP::DefaultConfig>();
-		defaults != nullptr && defaults->outgoing_video
-	) {
-		outgoing_video.emplace<Components::TagConnectToDefault>(); // depends on what was specified in enter()
-	}
-
-	stream_sinks.push_back(outgoing_video);
-	session.emplace<Components::ToxAVVideoSink>(outgoing_video);
-	// TODO: tie session to stream
-
-	_os.throwEventConstruct(outgoing_video);
-}
-
-void ToxAVVoIPModel::destroySession(ObjectHandle session) {
-	if (!static_cast<bool>(session)) {
-		return;
-	}
-
-	// remove lookup
-	if (session.all_of<Components::ToxAVAudioSource>()) {
-		auto it_asrc = std::find_if(
-			_audio_sources.cbegin(), _audio_sources.cend(),
-			[o = session.get<Components::ToxAVAudioSource>().o](const auto& it) {
-				return it.second == o;
-			}
-		);
-
-		if (it_asrc != _audio_sources.cend()) {
-			_audio_sources.erase(it_asrc);
-		}
-	}
-	if (session.all_of<Components::ToxAVVideoSource>()) {
-		auto it_vsrc = std::find_if(
-			_video_sources.cbegin(), _video_sources.cend(),
-			[o = session.get<Components::ToxAVVideoSource>().o](const auto& it) {
-				return it.second == o;
-			}
-		);
-
-		if (it_vsrc != _video_sources.cend()) {
-			_video_sources.erase(it_vsrc);
-		}
-	}
-
-	// destory sources
-	if (auto* ss = session.try_get<Components::VoIP::StreamSources>(); ss != nullptr) {
-		for (const auto ssov : ss->streams) {
-
-			_os.throwEventDestroy(ssov);
-			_os.registry().destroy(ssov);
-		}
-	}
-
-	// destory sinks
-	if (auto* ss = session.try_get<Components::VoIP::StreamSinks>(); ss != nullptr) {
-		for (const auto ssov : ss->streams) {
-
-			_os.throwEventDestroy(ssov);
-			_os.registry().destroy(ssov);
-		}
-	}
-
-	// destory session
-	_os.throwEventDestroy(session);
-	_os.registry().destroy(session);
-}
-
-ToxAVVoIPModel::ToxAVVoIPModel(ObjectStore2& os, ToxAVI& av, Contact3Registry& cr, ToxContactModel2& tcm) :
-	_os(os), _av(av), _cr(cr), _tcm(tcm)
-{
-	_av.subscribe(this, ToxAV_Event::friend_call);
-	_av.subscribe(this, ToxAV_Event::friend_call_state);
-	_av.subscribe(this, ToxAV_Event::friend_audio_bitrate);
-	_av.subscribe(this, ToxAV_Event::friend_video_bitrate);
-	_av.subscribe(this, ToxAV_Event::friend_audio_frame);
-	_av.subscribe(this, ToxAV_Event::friend_video_frame);
-
-	// attach to all tox friend contacts
-
-	for (const auto& [cv, _] : _cr.view<Contact::Components::ToxFriendPersistent>().each()) {
-		_cr.emplace<VoIPModelI*>(cv, this);
-	}
-	// TODO: events
-}
-
-ToxAVVoIPModel::~ToxAVVoIPModel(void) {
-	for (const auto& [ov, voipmodel] : _os.registry().view<VoIPModelI*>().each()) {
-		if (voipmodel == this) {
-			destroySession(_os.objectHandle(ov));
-		}
-	}
-}
-
-void ToxAVVoIPModel::tick(void) {
-	for (const auto& [oc, asink] : _os.registry().view<ToxAVCallAudioSink*>().each()) {
-		if (!asink->_writer) {
-			continue;
-		}
-
-		for (size_t i = 0; i < 100; i++) {
-			auto new_frame_opt = asink->_writer->pop();
-			if (!new_frame_opt.has_value()) {
-				break;
-			}
-			const auto& new_frame = new_frame_opt.value();
-
-			//* @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 = _av.toxavAudioSendFrame(
-				asink->_fid,
-				new_frame.getSpan().ptr,
-				new_frame.getSpan().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";
-			}
-		}
-	}
-
-	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;
-			}
-			const auto& new_frame = new_frame_opt.value();
-
-			if (!new_frame.surface) {
-				// wtf?
-				continue;
-			}
-
-			// conversion is done in the sink's stream
-			SDL_Surface* surf = new_frame.surface.get();
-			assert(surf != nullptr);
-
-			SDL_LockSurface(surf);
-			_av.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);
-		}
-	}
-}
-
-ObjectHandle ToxAVVoIPModel::enter(const Contact3 c, const Components::VoIP::DefaultConfig& defaults) {
-	if (!_cr.all_of<Contact::Components::ToxFriendEphemeral>(c)) {
-		return {};
-	}
-
-	const auto friend_number = _cr.get<Contact::Components::ToxFriendEphemeral>(c).friend_number;
-
-	const auto err = _av.toxavCall(friend_number, 0, 0);
-	if (err != TOXAV_ERR_CALL_OK) {
-		std::cerr << "TAVVOIP error: failed to start call: " << err << "\n";
-		return {};
-	}
-
-	ObjectHandle new_session {_os.registry(), _os.registry().create()};
-
-	new_session.emplace<VoIPModelI*>(this);
-	new_session.emplace<Components::VoIP::TagVoIPSession>(); // ??
-	new_session.emplace<Components::VoIP::SessionContact>(c);
-	new_session.emplace<Components::VoIP::SessionState>().state = Components::VoIP::SessionState::State::RINGING;
-	new_session.emplace<Components::VoIP::DefaultConfig>(defaults);
-
-	_os.throwEventConstruct(new_session);
-	return new_session;
-}
-
-bool ToxAVVoIPModel::accept(ObjectHandle session, const Components::VoIP::DefaultConfig& defaults) {
-	if (!static_cast<bool>(session)) {
-		return false;
-	}
-
-	if (!session.all_of<
-		Components::VoIP::TagVoIPSession,
-		VoIPModelI*,
-		Components::VoIP::SessionContact,
-		Components::VoIP::Incoming
-	>()) {
-		return false;
-	}
-
-	// check if self
-	if (session.get<VoIPModelI*>() != this) {
-		return false;
-	}
-
-	const auto session_contact = session.get<Components::VoIP::SessionContact>().c;
-	if (!_cr.all_of<Contact::Components::ToxFriendEphemeral>(session_contact)) {
-		return false;
-	}
-
-	const auto friend_number = _cr.get<Contact::Components::ToxFriendEphemeral>(session_contact).friend_number;
-	auto err = _av.toxavAnswer(friend_number, 0, 0);
-	if (err != TOXAV_ERR_ANSWER_OK) {
-		std::cerr << "TOXAVVOIP error: ansering call failed: " << err << "\n";
-		// we simply let it be for now, it apears we can try ansering later again
-		// we also get an error here when the call is already in progress (:
-		return false;
-	}
-
-	session.emplace<Components::VoIP::DefaultConfig>(defaults);
-
-	// answer defaults to enabled receiving audio and video
-	// TODO: think about how we should handle this
-	// set to disabled? and enable on src connection?
-	// we already default disabled send and enabled on sink connection
-	//_av.toxavCallControl(friend_number, TOXAV_CALL_CONTROL_HIDE_VIDEO);
-	//_av.toxavCallControl(friend_number, TOXAV_CALL_CONTROL_MUTE_AUDIO);
-
-
-	// how do we know the other side is accepting audio
-	// bitrate cb or what?
-	assert(!session.all_of<Components::ToxAVAudioSink>());
-	addAudioSink(session, friend_number);
-	assert(!session.all_of<Components::ToxAVVideoSink>());
-	addVideoSink(session, friend_number);
-
-	if (const auto* i_av = session.try_get<Components::ToxAVIncomingAV>(); i_av != nullptr) {
-		// create audio src
-		if (i_av->incoming_audio) {
-			assert(!session.all_of<Components::ToxAVAudioSource>());
-			addAudioSource(session, friend_number);
-		}
-
-		// create video src
-		if (i_av->incoming_video) {
-			assert(!session.all_of<Components::ToxAVVideoSource>());
-			addVideoSource(session, friend_number);
-		}
-	}
-
-	session.get_or_emplace<Components::VoIP::SessionState>().state = Components::VoIP::SessionState::State::CONNECTED;
-	_os.throwEventUpdate(session);
-	return true;
-}
-
-bool ToxAVVoIPModel::leave(ObjectHandle session) {
-	// rename to end?
-
-	if (!static_cast<bool>(session)) {
-		return false;
-	}
-
-	if (!session.all_of<
-		Components::VoIP::TagVoIPSession,
-		VoIPModelI*,
-		Components::VoIP::SessionContact
-	>()) {
-		return false;
-	}
-
-	// check if self
-	if (session.get<VoIPModelI*>() != this) {
-		return false;
-	}
-
-	const auto session_contact = session.get<Components::VoIP::SessionContact>().c;
-	if (!_cr.all_of<Contact::Components::ToxFriendEphemeral>(session_contact)) {
-		return false;
-	}
-
-	const auto friend_number = _cr.get<Contact::Components::ToxFriendEphemeral>(session_contact).friend_number;
-	// check error? (we delete anyway)
-	_av.toxavCallControl(friend_number, Toxav_Call_Control::TOXAV_CALL_CONTROL_CANCEL);
-
-	destroySession(session);
-	return true;
-}
-
-bool ToxAVVoIPModel::onEvent(const Events::FriendCall& e) {
-	// new incoming call, create voip session, ready to be accepted
-	// (or rejected...)
-
-	const auto session_contact = _tcm.getContactFriend(e.friend_number);
-	if (!_cr.valid(session_contact)) {
-		return false;
-	}
-
-	ObjectHandle new_session {_os.registry(), _os.registry().create()};
-
-	new_session.emplace<VoIPModelI*>(this);
-	new_session.emplace<Components::VoIP::TagVoIPSession>(); // ??
-	new_session.emplace<Components::VoIP::Incoming>(session_contact); // in 1on1 its always the same contact, might leave blank
-	new_session.emplace<Components::VoIP::SessionContact>(session_contact);
-	new_session.emplace<Components::VoIP::SessionState>().state = Components::VoIP::SessionState::State::RINGING;
-	new_session.emplace<Components::ToxAVIncomingAV>(e.audio_enabled, e.video_enabled);
-
-	_os.throwEventConstruct(new_session);
-	return true;
-}
-
-bool ToxAVVoIPModel::onEvent(const Events::FriendCallState& e) {
-	const auto session_contact = _tcm.getContactFriend(e.friend_number);
-	if (!_cr.valid(session_contact)) {
-		return false;
-	}
-
-	ToxAVFriendCallState s{e.state};
-
-	// find session(s?)
-	// TODO: keep lookup table
-	for (const auto& [ov, voipmodel] : _os.registry().view<VoIPModelI*>().each()) {
-		if (voipmodel == this) {
-			auto o = _os.objectHandle(ov);
-
-			if (!o.all_of<Components::VoIP::SessionContact>()) {
-				continue;
-			}
-			if (session_contact != o.get<Components::VoIP::SessionContact>().c) {
-				continue;
-			}
-
-			if (s.is_error() || s.is_finished()) {
-				// destroy call
-				destroySession(o);
-			} else {
-				// remote accepted our call, or av send/recv conditions changed?
-				o.get<Components::VoIP::SessionState>().state = Components::VoIP::SessionState::State::CONNECTED; // set to in call ??
-
-				if (s.is_accepting_a() && !o.all_of<Components::ToxAVAudioSink>()) {
-					addAudioSink(o, e.friend_number);
-				} else if (!s.is_accepting_a() && o.all_of<Components::ToxAVAudioSink>()) {
-					// remove asink?
-				}
-
-				// video
-				if (s.is_accepting_v() && !o.all_of<Components::ToxAVVideoSink>()) {
-					addVideoSink(o, e.friend_number);
-				} else if (!s.is_accepting_v() && o.all_of<Components::ToxAVVideoSink>()) {
-					// remove vsink?
-				}
-
-				// add/update sources
-				// audio
-				if (s.is_sending_a() && !o.all_of<Components::ToxAVAudioSource>()) {
-					addAudioSource(o, e.friend_number);
-				} else if (!s.is_sending_a() && o.all_of<Components::ToxAVAudioSource>()) {
-					// remove asrc?
-				}
-
-				// video
-				if (s.is_sending_v() && !o.all_of<Components::ToxAVVideoSource>()) {
-					addVideoSource(o, e.friend_number);
-				} else if (!s.is_sending_v() && o.all_of<Components::ToxAVVideoSource>()) {
-					// remove vsrc?
-				}
-			}
-		}
-	}
-
-	return true;
-}
-
-bool ToxAVVoIPModel::onEvent(const Events::FriendAudioBitrate&) {
-	return false;
-}
-
-bool ToxAVVoIPModel::onEvent(const Events::FriendVideoBitrate&) {
-	return false;
-}
-
-bool ToxAVVoIPModel::onEvent(const Events::FriendAudioFrame& e) {
-	auto asrc_it = _audio_sources.find(e.friend_number);
-	if (asrc_it == _audio_sources.cend()) {
-		// missing src from lookup table
-		return false;
-	}
-
-	auto asrc = asrc_it->second;
-
-	if (!static_cast<bool>(asrc)) {
-		// missing src to put frame into ??
-		return false;
-	}
-
-	assert(asrc.all_of<FrameStream2MultiSource<AudioFrame2>*>());
-	assert(asrc.all_of<Components::FrameStream2Source<AudioFrame2>>());
-
-	asrc.get<FrameStream2MultiSource<AudioFrame2>*>()->push(AudioFrame2{
-		e.sampling_rate,
-		e.channels,
-		std::vector<int16_t>(e.pcm.begin(), e.pcm.end()) // copy
-	});
-
-	return true;
-}
-
-bool ToxAVVoIPModel::onEvent(const Events::FriendVideoFrame& e) {
-	auto vsrc_it = _video_sources.find(e.friend_number);
-	if (vsrc_it == _video_sources.cend()) {
-		// missing src from lookup table
-		return false;
-	}
-
-	auto vsrc = vsrc_it->second;
-
-	if (!static_cast<bool>(vsrc)) {
-		// missing src to put frame into ??
-		return false;
-	}
-
-	assert(vsrc.all_of<FrameStream2MultiSource<SDLVideoFrame>*>());
-	assert(vsrc.all_of<Components::FrameStream2Source<SDLVideoFrame>>());
-
-	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);
-	}
-
-	vsrc.get<FrameStream2MultiSource<SDLVideoFrame>*>()->push({
-		// ms -> us
-		Message::getTimeMS() * 1000, // TODO: make more precise
-		new_surf
-	});
-
-	SDL_DestroySurface(new_surf);
-	return false;
-}
-

src/tox_av_voip_model.hpp

@@ -1,48 +0,0 @@
-#pragma once
-
-#include <solanaceae/object_store/fwd.hpp>
-#include <solanaceae/contact/contact_model3.hpp>
-#include <solanaceae/tox_contacts/tox_contact_model2.hpp>
-#include "./frame_streams/voip_model.hpp"
-#include "./tox_av.hpp"
-
-#include <unordered_map>
-
-class ToxAVVoIPModel : protected ToxAVEventI, public VoIPModelI {
-	ObjectStore2& _os;
-	ToxAVI& _av;
-	Contact3Registry& _cr;
-	ToxContactModel2& _tcm;
-
-	// for faster lookup
-	std::unordered_map<uint32_t, ObjectHandle> _audio_sources;
-	std::unordered_map<uint32_t, ObjectHandle> _video_sources;
-
-	// TODO: virtual? strategy? protected?
-	virtual void addAudioSource(ObjectHandle session, uint32_t friend_number);
-	virtual void addAudioSink(ObjectHandle session, uint32_t friend_number);
-	virtual void addVideoSource(ObjectHandle session, uint32_t friend_number);
-	virtual void addVideoSink(ObjectHandle session, uint32_t friend_number);
-
-	void destroySession(ObjectHandle session);
-
-	public:
-		ToxAVVoIPModel(ObjectStore2& os, ToxAVI& av, Contact3Registry& cr, ToxContactModel2& tcm);
-		~ToxAVVoIPModel(void);
-
-		void tick(void);
-
-	public: // voip model
-		ObjectHandle enter(const Contact3 c, const Components::VoIP::DefaultConfig& defaults) override;
-		bool accept(ObjectHandle session, const Components::VoIP::DefaultConfig& defaults) override;
-		bool leave(ObjectHandle session) override;
-
-	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/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);
+	}
+
 };