built receiver, they did not come

build.zig

@@ -26,48 +26,80 @@ pub fn build(b: *std.Build) void {
     libomt_build.step.dependOn(&libomtnet_build.step);
 
     // Define executable
-    const exe = b.addExecutable(.{
+    const sender_exe = b.addExecutable(.{
-        .name = "omtoy",
+        .name = "omtoy-sender",
         .root_module = b.createModule(.{
-            .root_source_file = b.path("src/main.zig"),
+            .root_source_file = b.path("src/sender.zig"),
             .target = target,
             .optimize = optimize,
         }),
     });
 
-    // Link libomt with the build
+    const receiver_exe = b.addExecutable(.{
+        .name = "omtoy-receiver",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/receiver.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
+    });
+
+    // Link libomt with the sender and receiver
+    {
+        const omt_output_dir = b.path("3rd/libomt/bin/Release/net8.0/linux-x64/publish");
+        sender_exe.addIncludePath(omt_output_dir);
+        sender_exe.addLibraryPath(omt_output_dir);
+        sender_exe.linkSystemLibrary("omt");
+        sender_exe.linkLibC();
+        receiver_exe.addIncludePath(omt_output_dir);
+        receiver_exe.addLibraryPath(omt_output_dir);
+        receiver_exe.linkSystemLibrary("omt");
+        receiver_exe.linkLibC();
+    }
+
+    b.installArtifact(sender_exe);
+    b.installArtifact(receiver_exe);
+
+    // Link libomt with the receiver
     {
         const omt_output_dir = b.path("3rd/libomt/bin/Release/net8.0/linux-x64/publish");
         // exe.step.dependOn(&libomt_build.step);
-        exe.addIncludePath(omt_output_dir);
+        sender_exe.addIncludePath(omt_output_dir);
-        exe.addLibraryPath(omt_output_dir);
+        sender_exe.addLibraryPath(omt_output_dir);
-        exe.linkSystemLibrary("omt");
+        sender_exe.linkSystemLibrary("omt");
-        exe.linkLibC();
+        sender_exe.linkLibC();
     }
 
-    b.installArtifact(exe);
-
     // Manual build step for libomt dependencies
     const build_omt_step = b.step("build-omt", "Build libomt and libomtnet");
     build_omt_step.dependOn(&libomt_build.step);
 
-    // Add run step
+    // Add run step for sender
-    const run_step = b.step("run", "Run the app");
+    const run_sender_step = b.step("sender-run", "Run the sender client");
-    const run_cmd = b.addRunArtifact(exe);
+    const run_sender_cmd = b.addRunArtifact(sender_exe);
-    run_step.dependOn(&run_cmd.step);
+    run_sender_step.dependOn(&run_sender_cmd.step);
 
-    run_cmd.step.dependOn(b.getInstallStep());
+    const run_receiver_step = b.step("receiver-run", "Run the receiver client");
+    const run_receiver_cmd = b.addRunArtifact(receiver_exe);
+    run_receiver_step.dependOn(&run_receiver_cmd.step);
+
+    // Add run step for receiver
+
+    run_sender_cmd.step.dependOn(b.getInstallStep());
+    run_receiver_cmd.step.dependOn(b.getInstallStep());
 
     if (b.args) |args| {
-        run_cmd.addArgs(args);
+        run_sender_cmd.addArgs(args);
+        run_receiver_cmd.addArgs(args);
     }
 
-    const exe_tests = b.addTest(.{
+    // TODO: write tests and stuff
-        .root_module = exe.root_module,
+    // const exe_tests = b.addTest(.{
-    });
+    //     .root_module = sender_exe.root_module,
+    // });
 
-    const run_exe_tests = b.addRunArtifact(exe_tests);
+    // const run_exe_tests = b.addRunArtifact(exe_tests);
 
-    const test_step = b.step("test", "Run tests");
+    // const test_step = b.step("test", "Run tests");
-    test_step.dependOn(&run_exe_tests.step);
+    // test_step.dependOn(&run_exe_tests.step);
 }

src/receiver.zig

@@ -0,0 +1,56 @@
+const std = @import("std");
+const omt = @cImport(@cInclude("libomt.h"));
+
+pub fn main() !void {
+    // var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    // const allocator = gpa.allocator();
+
+    std.log.info("Receiving...", .{});
+    omt.omt_setloggingfilename("omtrecvtest.log");
+
+    var found_address_count: i32 = 0;
+    _ = omt.omt_discovery_getaddresses(&found_address_count);
+
+    std.log.info("Found {d} omt addresses\n", .{found_address_count});
+
+    const receiver_flags = omt.OMTFrameType_Video | omt.OMTFrameType_Audio | omt.OMTFrameType_Metadata;
+    const receiver = omt.omt_receive_create(
+        "pop-os (Omtoy Sender)",
+        receiver_flags,
+        omt.OMTPreferredVideoFormat_UYVYorUYVAorP216orPA16,
+        0,
+    );
+    defer omt.omt_receive_destroy(receiver);
+
+    while (true) {
+        const frame = omt.omt_receive(receiver, receiver_flags, 40);
+        if (frame != null) {
+            dumpOMTMediaFrameInfo(frame);
+        }
+    }
+}
+
+fn dumpOMTMediaFrameInfo(frame: *omt.OMTMediaFrame) void {
+    std.log.info("--------- Received --------", .{});
+    switch (frame.*.Type) {
+        omt.OMTFrameType_Video => dumpVideoFrameInfo(frame),
+        omt.OMTFrameType_Audio => dumpAudioFrameInfo(frame),
+        omt.OMTFrameType_Metadata => dumpMetadataFrameInfo(frame),
+        else => std.log.err("Undefined frame type", .{}),
+    }
+}
+
+fn dumpVideoFrameInfo(frame: *omt.OMTMediaFrame) void {
+    std.log.info("Frame: Video", .{});
+    _ = frame;
+}
+
+fn dumpAudioFrameInfo(frame: *omt.OMTMediaFrame) void {
+    std.log.info("Frame: Audio", .{});
+    _ = frame;
+}
+
+fn dumpMetadataFrameInfo(frame: *omt.OMTMediaFrame) void {
+    std.log.info("Frame: Metadata", .{});
+    _ = frame;
+}

src/sender.zig

@@ -5,12 +5,7 @@ pub fn main() !void {
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     const allocator = gpa.allocator();
 
-    var found_address_count: i32 = 0;
+    std.log.info("Sending...", .{});
-    _ = omt.omt_discovery_getaddresses(&found_address_count);
-
-    std.debug.print("Found {d} omt addresses\n", .{found_address_count});
-
-    std.log.info("Send test...", .{});
     omt.omt_setloggingfilename("omtsendtest.log");
 
     const sender = omt.omt_send_create("Omtoy Sender", omt.OMTQuality_Default) orelse undefined;
@@ -64,6 +59,7 @@ pub fn main() !void {
 
     const audio_samples = 800;
     const audio_buffer = try allocator.alloc(f32, audio_samples);
+    defer allocator.free(audio_buffer);
 
     var prng = std.Random.DefaultPrng.init(80085);
     const rng = prng.random();
@@ -89,6 +85,8 @@ pub fn main() !void {
     var bytes: i32 = 0;
 
     const two_lines = try allocator.alloc(u8, stride * 2);
+    defer allocator.free(two_lines);
+
     @memset(two_lines, 255);
     var line_position: usize = 0;
 
@@ -128,9 +126,6 @@ pub fn main() !void {
         _ = omt.omt_send(sender, &audio_frame);
         fillAudioBuffer(rng, audio_buffer);
     }
-
-    // Check we're on!
-
 }
 
 fn fillAudioBuffer(rng: std.Random, buffer: []f32) void {