wip

We can build omt again, but something weird happens on import

.gitmodules

@@ -1,15 +1,12 @@
-[submodule "3rd/libomt"]
-	path = 3rd/libomt
-	url = https://github.com/openmediatransport/libomt
-[submodule "3rd/libomtnet"]
-	path = 3rd/libomtnet
-	url = https://github.com/openmediatransport/libomtnet
-[submodule "3rd/omt-examples"]
-	path = 3rd/omt-examples
+[submodule "omt-examples"]
+	path = omt/3rd/omt-examples
 	url = https://github.com/openmediatransport/Examples.git
-[submodule "3rd/libvmx"]
-	path = 3rd/libvmx
+[submodule "libomt"]
+	path = omt/3rd/libomt
+	url = https://github.com/openmediatransport/libomt.git
+[submodule "libomtnet"]
+	path = omt/3rd/libomtnet
+	url = https://github.com/openmediatransport/libomtnet.git
+[submodule "libvmx"]
+	path = omt/3rd/libvmx
 	url = https://github.com/openmediatransport/libvmx.git
-[submodule "3rd/glfw"]
-	path = 3rd/glfw
-	url = https://github.com/glfw/glfw.git

build.zig

@@ -15,202 +15,38 @@ pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
-    const triple = target.result;
-    if (triple.os.tag != .linux or triple.cpu.arch != .x86_64) {
-        std.log.warn("The build file only supports Linux x86-64 right now.\n", .{});
-        std.log.warn(
-            "You can extend the build.zig to call the appropriate platform scripts " ++
-                "in 3rd/libomtnet/build/ and 3rd/libomt/build and 3rd/libvmx/build/ " ++
-                "and modifying the install scripts",
-            .{},
-        );
-        return;
-    }
-
-    // This comes from the libomt build scripts
-    const omt_out_path = "3rd/libomt/bin/Release/net8.0/linux-x64/publish/";
-
-    // Build libomtnet
-    const libomtnet_build_script = b.addSystemCommand(&.{"bash"});
-    libomtnet_build_script.cwd = b.path("3rd/libomtnet/build");
-    libomtnet_build_script.addFileArg(b.path("3rd/libomtnet/build/buildall.sh"));
-
-    // Build libomt
-    const libomt_build_script = b.addSystemCommand(&.{"bash"});
-    libomt_build_script.cwd = b.path("3rd/libomt/build");
-    libomt_build_script.addFileArg(b.path("3rd/libomt/build/buildlinuxx64.sh"));
-    libomt_build_script.step.dependOn(&libomtnet_build_script.step);
-
-    // Install libomt
-    const install_omt_h = b.addInstallHeaderFile(
-        b.path(b.pathJoin(&.{ omt_out_path, "libomt.h" })),
-        "libomt.h",
-    );
-    install_omt_h.step.dependOn(&libomt_build_script.step);
-
-    const install_omt_so = b.addInstallLibFile(
-        b.path(b.pathJoin(&.{ omt_out_path, "libomt.so" })),
-        "libomt.so",
-    );
-    install_omt_so.step.dependOn(&libomt_build_script.step);
-
-    // Build libvmx
-    const libvmx_build = b.addSystemCommand(&.{"bash"});
-    libvmx_build.cwd = b.path("3rd/libvmx/build");
-    libvmx_build.addFileArg(b.path("3rd/libvmx/build/buildlinuxx64.sh"));
-
-    // Install libvmx
-    const install_vmx_so = b.addInstallLibFile(
-        b.path("3rd/libvmx/build/libvmx.so"),
-        "libvmx.so",
-    );
-    install_vmx_so.step.dependOn(&libvmx_build.step);
-
-    {
-        // Manual build step for libomt dependencies
-        const build_omt_step = b.step("omt", "Build libomtnet, libomt and libvmx");
-        build_omt_step.dependOn(&install_omt_h.step);
-        build_omt_step.dependOn(&install_omt_so.step);
-        build_omt_step.dependOn(&install_vmx_so.step);
-    }
-
-    // The output lib and header directories
-    const lib_output_path: std.Build.LazyPath = .{
-        .cwd_relative = b.lib_dir,
-    };
-    const include_output_path: std.Build.LazyPath = .{
-        .cwd_relative = b.h_dir,
-    };
-
-    // Zig omt module
-    const omt_mod = b.addModule("omt", .{
-        .root_source_file = b.path("src/omt.zig"),
+    const zomt_dep = b.dependency("zomt", .{
         .target = target,
         .optimize = optimize,
     });
+    const zomt_mod = zomt_dep.module("zomt");
 
-    omt_mod.linkSystemLibrary("omt", .{});
-    omt_mod.addLibraryPath(lib_output_path);
-    omt_mod.addIncludePath(include_output_path);
-
-    const sdl3 = b.dependency("sdl3", .{
-        .target = target,
-        .optimize = optimize,
-
-        // Lib options.
-        // .callbacks = false,
-        // .ext_image = false,
-        // .ext_net = false,
-        // .ext_ttf = false,
-        // .log_message_stack_size = 1024,
-        // .main = false,
-        // .renderer_debug_text_stack_size = 1024,
-
-        // Options passed directly to https://github.com/castholm/SDL (SDL3 C Bindings):
-        // .c_sdl_preferred_linkage = .static,
-        // .c_sdl_strip = false,
-        // .c_sdl_sanitize_c = .off,
-        // .c_sdl_lto = .none,
-        // .c_sdl_emscripten_pthreads = false,
-        // .c_sdl_install_build_config_h = false,
-
-        // Options if `ext_image` is enabled:
-        // .image_enable_bmp = true,
-        // .image_enable_gif = true,
-        // .image_enable_jpg = true,
-        // .image_enable_lbm = true,
-        // .image_enable_pcx = true,
-        // .image_enable_png = true,
-        // .image_enable_pnm = true,
-        // .image_enable_qoi = true,
-        // .image_enable_svg = true,
-        // .image_enable_tga = true,
-        // .image_enable_xcf = true,
-        // .image_enable_xpm = true,
-        // .image_enable_xv = true,
-    });
-
-    {
-        // Main executable
-        const omtoy_exe = b.addExecutable(.{
+    const exe = b.addExecutable((.{
         .name = "omtoy",
         .root_module = b.createModule(.{
             .root_source_file = b.path("src/main.zig"),
             .target = target,
             .optimize = optimize,
         }),
-        });
+    }));
 
-        omtoy_exe.root_module.addImport("sdl3", sdl3.module("sdl3"));
-        b.installArtifact(omtoy_exe);
+    // exe.root_module.addLibraryPath(zomt_dep.namedLazyPath("output_dir"));
+    exe.root_module.addIncludePath(zomt_dep.namedLazyPath("output_dir"));
+    // exe.root_module.linkSystemLibrary("omt", .{});
+    exe.root_module.addImport("zomt", zomt_mod);
 
-        // Run step for main executable
-        const run_step = b.step("run", "Run omtoy");
-        const run_cmd = b.addRunArtifact(omtoy_exe);
+    b.installArtifact(exe);
+
+    // Run step
+    const run_step = b.step("run", "Run Omtoy");
+    const run_cmd = b.addRunArtifact(exe);
     run_step.dependOn(&run_cmd.step);
     run_cmd.step.dependOn(b.getInstallStep());
-    }
 
-    // Util executables
-    {
-        // Define executables
-        const sender_exe = b.addExecutable(.{
-            .name = "sender",
-            .root_module = b.createModule(.{
-                .root_source_file = b.path("utils/sender.zig"),
-                .target = target,
-                .optimize = optimize,
-            }),
-        });
-        sender_exe.root_module.addImport("omt", omt_mod);
-
-        sender_exe.root_module.addLibraryPath(lib_output_path);
-        sender_exe.root_module.addIncludePath(include_output_path);
-        sender_exe.linkSystemLibrary("omt");
-        sender_exe.linkLibC();
-
-        b.installArtifact(sender_exe);
-
-        // Add run step for sender
-        const run_sender_step = b.step("sender-run", "Run the sender client");
-        const run_sender_cmd = b.addRunArtifact(sender_exe);
-        run_sender_step.dependOn(&run_sender_cmd.step);
-        run_sender_cmd.step.dependOn(b.getInstallStep());
-
-        // Don't actually have arguments, so this is moot
     if (b.args) |args| {
-            run_sender_cmd.addArgs(args);
-        }
+        run_cmd.addArgs(args);
     }
 
-    {
-        const receiver_exe = b.addExecutable(.{
-            .name = "receiver",
-            .root_module = b.createModule(.{
-                .root_source_file = b.path("utils/receiver.zig"),
-                .target = target,
-                .optimize = optimize,
-            }),
-        });
-        receiver_exe.root_module.addImport("omt", omt_mod);
-
-        receiver_exe.root_module.addLibraryPath(lib_output_path);
-        receiver_exe.root_module.addIncludePath(include_output_path);
-        receiver_exe.linkSystemLibrary("omt");
-        receiver_exe.linkLibC();
-
-        b.installArtifact(receiver_exe);
-
-        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);
-        run_receiver_cmd.step.dependOn(b.getInstallStep());
-
-        // Don't actually have arguments so this is moot
-        if (b.args) |args| {
-            run_receiver_cmd.addArgs(args);
-        }
-    }
     // TODO: write tests and stuff
     // const exe_tests = b.addTest(.{
     //     .root_module = sender_exe.root_module,

build.zig.zon

@@ -9,7 +9,7 @@
     .name = .omtoy,
     // This is a [Semantic Version](https://semver.org/).
     // In a future version of Zig it will be used for package deduplication.
-    .version = "0.0.0",
+    .version = "0.0.1",
     // Together with name, this represents a globally unique package
     // identifier. This field is generated by the Zig toolchain when the
     // package is first created, and then *never changes*. This allows
@@ -32,9 +32,8 @@
     // Once all dependencies are fetched, `zig build` no longer requires
     // internet connectivity.
     .dependencies = .{
-        .sdl3 = .{
-            .url = "git+https://github.com/Gota7/zig-sdl3?ref=v0.1.5#014b7bcb2899f3ed9c945c4abfcfe1b25d75bfeb",
-            .hash = "sdl3-0.1.5-NmT1QxARJgAH1Wp0cMBJDAc9vD7weufTkIwVa5rehA2q",
+        .zomt = .{
+            .path = "omt/",
         },
     },
     .paths = .{

omt/build.zig

@@ -0,0 +1,161 @@
+//
+// OMT module for zig
+//
+// Build required OMT parts and link against our code
+//
+// I don't know yet how to best create a conditional step to build and install
+// the dependencies only if they aren't installed yet. Just putting the installs
+// as dependencies runs the omt build scripts on every `zig build`.
+//
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    const triple = target.result;
+    if (triple.os.tag != .linux or triple.cpu.arch != .x86_64) {
+        std.log.warn("The build file only supports Linux x86-64 right now.\n", .{});
+        std.log.warn(
+            "You can extend the build.zig to call the appropriate platform scripts " ++
+                "in 3rd/libomtnet/build/ and 3rd/libomt/build and 3rd/libvmx/build/ " ++
+                "and modifying the install scripts",
+            .{},
+        );
+        return;
+    }
+
+    // This path comes from the libomt build scripts
+    const omt_out_path = "3rd/libomt/bin/Release/net8.0/linux-x64/publish/";
+    const output_dir_path: std.Build.LazyPath = .{
+        .src_path = .{
+            .owner = b,
+            .sub_path = omt_out_path,
+        },
+    };
+    b.addNamedLazyPath("output_dir", output_dir_path);
+
+    // The output lib and header directories
+    const lib_output_path: std.Build.LazyPath = .{
+        .cwd_relative = b.getInstallPath(.lib, ""),
+    };
+    const include_output_path: std.Build.LazyPath = .{
+        .cwd_relative = b.getInstallPath(.header, ""),
+    };
+
+    std.debug.print("install-path: {s}\n", .{b.getInstallPath(.prefix, "")});
+    std.debug.print("lib_output_path: {s}\n", .{lib_output_path.getDisplayName()});
+    std.debug.print("include_output_path: {s}\n", .{include_output_path.getDisplayName()});
+
+    // zomt module
+    const omt_mod = b.addModule("zomt", .{
+        .root_source_file = b.path("src/omt.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    omt_mod.addLibraryPath(output_dir_path);
+    omt_mod.addIncludePath(output_dir_path);
+    omt_mod.linkSystemLibrary("omt", .{});
+
+    // Build libomtnet
+    const libomtnet_build_script = b.addSystemCommand(&.{"bash"});
+    libomtnet_build_script.cwd = b.path("3rd/libomtnet/build");
+    libomtnet_build_script.addFileArg(b.path("3rd/libomtnet/build/buildall.sh"));
+
+    // Build libomt
+    const libomt_build_script = b.addSystemCommand(&.{"bash"});
+    libomt_build_script.cwd = b.path("3rd/libomt/build");
+    libomt_build_script.addFileArg(b.path("3rd/libomt/build/buildlinuxx64.sh"));
+    libomt_build_script.step.dependOn(&libomtnet_build_script.step);
+
+    // Install libomt
+    const install_omt_h = b.addInstallHeaderFile(
+        b.path(b.pathJoin(&.{ omt_out_path, "libomt.h" })),
+        "libomt.h",
+    );
+    install_omt_h.step.dependOn(&libomt_build_script.step);
+
+    const install_omt_so = b.addInstallLibFile(
+        b.path(b.pathJoin(&.{ omt_out_path, "libomt.so" })),
+        "libomt.so",
+    );
+    install_omt_so.step.dependOn(&libomt_build_script.step);
+
+    // Build libvmx
+    const libvmx_build = b.addSystemCommand(&.{"bash"});
+    libvmx_build.cwd = b.path("3rd/libvmx/build");
+    libvmx_build.addFileArg(b.path("3rd/libvmx/build/buildlinuxx64.sh"));
+
+    // Install libvmx
+    const install_vmx_so = b.addInstallLibFile(
+        b.path("3rd/libvmx/build/libvmx.so"),
+        "libvmx.so",
+    );
+    install_vmx_so.step.dependOn(&libvmx_build.step);
+
+    // Add object as dependency for module
+    const libomtso_path = b.path(b.pathJoin(&.{ omt_out_path, "libomt.so" }));
+    // Has no discernable effect atm
+    omt_mod.addObjectFile(libomtso_path);
+
+    {
+        // Manual build step for libomt dependencies
+        const build_omt_step = b.step("omt", "Build libomtnet, libomt and libvmx");
+        build_omt_step.dependOn(&install_omt_h.step);
+        build_omt_step.dependOn(&install_omt_so.step);
+        build_omt_step.dependOn(&install_vmx_so.step);
+    }
+
+    // Test executables
+    {
+        // Define executables
+        const sender_exe = b.addExecutable(.{
+            .name = "sender",
+            .root_module = b.createModule(.{
+                .root_source_file = b.path("utils/sender.zig"),
+                .target = target,
+                .optimize = optimize,
+            }),
+        });
+        sender_exe.root_module.addImport("omt", omt_mod);
+
+        // These cause invocations for every zig build command, even tho it's not
+        // usually needed, so prefer to use a manual step
+        sender_exe.step.dependOn(&install_omt_h.step);
+        sender_exe.step.dependOn(&install_omt_so.step);
+        sender_exe.step.dependOn(&install_vmx_so.step);
+
+        sender_exe.root_module.addLibraryPath(lib_output_path);
+        sender_exe.root_module.addIncludePath(include_output_path);
+        sender_exe.linkSystemLibrary("omt");
+        sender_exe.linkLibC();
+
+        b.installArtifact(sender_exe);
+    }
+
+    {
+        const receiver_exe = b.addExecutable(.{
+            .name = "receiver",
+            .root_module = b.createModule(.{
+                .root_source_file = b.path("utils/receiver.zig"),
+                .target = target,
+                .optimize = optimize,
+            }),
+        });
+        receiver_exe.root_module.addImport("omt", omt_mod);
+
+        // These cause invocations for every zig build command, even tho it's not
+        // usually needed, so prefer to use a manual step
+        receiver_exe.step.dependOn(&install_omt_h.step);
+        receiver_exe.step.dependOn(&install_omt_so.step);
+        receiver_exe.step.dependOn(&install_vmx_so.step);
+
+        receiver_exe.root_module.addLibraryPath(lib_output_path);
+        receiver_exe.root_module.addIncludePath(include_output_path);
+        receiver_exe.linkSystemLibrary("omt");
+        receiver_exe.linkLibC();
+
+        b.installArtifact(receiver_exe);
+    }
+}

omt/build.zig.zon

@@ -0,0 +1,81 @@
+.{
+    // This is the default name used by packages depending on this one. For
+    // example, when a user runs `zig fetch --save <url>`, this field is used
+    // as the key in the `dependencies` table. Although the user can choose a
+    // different name, most users will stick with this provided value.
+    //
+    // It is redundant to include "zig" in this name because it is already
+    // within the Zig package namespace.
+    .name = .zomt,
+    // This is a [Semantic Version](https://semver.org/).
+    // In a future version of Zig it will be used for package deduplication.
+    .version = "0.0.1",
+    // Together with name, this represents a globally unique package
+    // identifier. This field is generated by the Zig toolchain when the
+    // package is first created, and then *never changes*. This allows
+    // unambiguous detection of one package being an updated version of
+    // another.
+    //
+    // When forking a Zig project, this id should be regenerated (delete the
+    // field and run `zig build`) if the upstream project is still maintained.
+    // Otherwise, the fork is *hostile*, attempting to take control over the
+    // original project's identity. Thus it is recommended to leave the comment
+    // on the following line intact, so that it shows up in code reviews that
+    // modify the field.
+    .fingerprint = 0xe176b336b44e42a7,
+    // Tracks the earliest Zig version that the package considers to be a
+    // supported use case.
+    .minimum_zig_version = "0.16.0-dev.699+529aa9f27",
+    // This field is optional.
+    // Each dependency must either provide a `url` and `hash`, or a `path`.
+    // `zig build --fetch` can be used to fetch all dependencies of a package, recursively.
+    // Once all dependencies are fetched, `zig build` no longer requires
+    // internet connectivity.
+    .dependencies = .{
+        // See `zig fetch --save <url>` for a command-line interface for adding dependencies.
+        //.example = .{
+        //    // When updating this field to a new URL, be sure to delete the corresponding
+        //    // `hash`, otherwise you are communicating that you expect to find the old hash at
+        //    // the new URL. If the contents of a URL change this will result in a hash mismatch
+        //    // which will prevent zig from using it.
+        //    .url = "https://example.com/foo.tar.gz",
+        //
+        //    // This is computed from the file contents of the directory of files that is
+        //    // obtained after fetching `url` and applying the inclusion rules given by
+        //    // `paths`.
+        //    //
+        //    // This field is the source of truth; packages do not come from a `url`; they
+        //    // come from a `hash`. `url` is just one of many possible mirrors for how to
+        //    // obtain a package matching this `hash`.
+        //    //
+        //    // Uses the [multihash](https://multiformats.io/multihash/) format.
+        //    .hash = "...",
+        //
+        //    // When this is provided, the package is found in a directory relative to the
+        //    // build root. In this case the package's hash is irrelevant and therefore not
+        //    // computed. This field and `url` are mutually exclusive.
+        //    .path = "foo",
+        //
+        //    // When this is set to `true`, a package is declared to be lazily
+        //    // fetched. This makes the dependency only get fetched if it is
+        //    // actually used.
+        //    .lazy = false,
+        //},
+    },
+    // Specifies the set of files and directories that are included in this package.
+    // Only files and directories listed here are included in the `hash` that
+    // is computed for this package. Only files listed here will remain on disk
+    // when using the zig package manager. As a rule of thumb, one should list
+    // files required for compilation plus any license(s).
+    // Paths are relative to the build root. Use the empty string (`""`) to refer to
+    // the build root itself.
+    // A directory listed here means that all files within, recursively, are included.
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+        // For example...
+        //"LICENSE",
+        //"README.md",
+    },
+}

omt/utils/sender.zig

@@ -55,18 +55,7 @@ pub fn main() !void {
         .FrameMetadataLength = 0,
     };
 
-    // 0.15
-    const content = try std.fs.cwd().readFileAlloc(
-        allocator,
-        "california-1080-uyvy.yuv",
-        std.math.maxInt(usize),
-    );
-    // 0.16
-    // const content = try std.fs.cwd().readFileAlloc(
-    //     "california-1080-uyvy.yuv",
-    //     allocator,
-    //     .unlimited,
-    // );
+    const content = try std.fs.cwd().readFileAlloc("california-1080-uyvy.yuv", allocator, .unlimited);
     defer allocator.free(content);
 
     const audio_samples = 800;

src/main.zig

@@ -1,45 +1,31 @@
-const sdl3 = @import("sdl3");
 const std = @import("std");
+const c = @cImport(@cInclude("libomt.h"));
 
-const fps = 60;
-const screen_width = 640;
-const screen_height = 480;
+fn discoverStream() ?[*c]u8 {
+    var discovery_count: i32 = 0;
+
+    while (discovery_count == 0) {
+        const discovered = c.omt_discovery_getaddresses(&discovery_count);
+        std.log.info("Found {} streams:", .{discovery_count});
+
+        const count: usize = @intCast(discovery_count);
+        for (0..count) |i| {
+            const name = discovered[i];
+            std.log.info("  {s}", .{name});
+        }
+
+        if (discovery_count > 0) {
+            return discovered[0];
+        }
+        std.Thread.sleep(1000 * 1000 * 1000);
+    }
+    return null;
+}
 
 pub fn main() !void {
     std.log.info("Starting omtoy...", .{});
+    c.omt_setloggingfilename("omtoy-omt.log");
 
-    defer sdl3.shutdown();
-
-    // Initialize SDL with subsystems you need here.
-    const init_flags = sdl3.InitFlags{ .video = true };
-    try sdl3.init(init_flags);
-    defer sdl3.quit(init_flags);
-
-    // Initial window setup.
-    const window = try sdl3.video.Window.init("Hello SDL3", screen_width, screen_height, .{});
-    defer window.deinit();
-
-    // Useful for limiting the FPS and getting the delta time.
-    var fps_capper = sdl3.extras.FramerateCapper(f32){ .mode = .{ .limited = fps } };
-
-    var quit = false;
-    while (!quit) {
-
-        // Delay to limit the FPS, returned delta time not needed.
-        const dt = fps_capper.delay();
-        _ = dt;
-
-        // Update logic.
-        const surface = try window.getSurface();
-        try surface.fillRect(null, surface.mapRgb(128, 30, 255));
-        try window.updateSurface();
-
-        // Event logic.
-        while (sdl3.events.poll()) |event|
-            switch (event) {
-                .quit => quit = true,
-                .terminating => quit = true,
-                else => {},
-            };
-    }
+    // _ = discoverStream() orelse undefined;
+    std.log.info("Exiting omtoy!", .{});
 }