wip

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

.gitmodules

@@ -1,15 +1,12 @@
-[submodule "3rd/libomt"]
+[submodule "omt-examples"]
-	path = 3rd/libomt
+	path = omt/3rd/omt-examples
-	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
 	url = https://github.com/openmediatransport/Examples.git
-[submodule "3rd/libvmx"]
+[submodule "libomt"]
-	path = 3rd/libvmx
+	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,144 +15,36 @@ pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
-    const triple = target.result;
+    const zomt_dep = b.dependency("zomt", .{
-    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_module = b.addModule("omt", .{
-        .root_source_file = b.path("src/omt.zig"),
         .target = target,
         .optimize = optimize,
     });
+    const zomt_mod = zomt_dep.module("zomt");
 
-    omt_module.linkSystemLibrary("omt", .{});
+    const exe = b.addExecutable((.{
-    omt_module.addLibraryPath(lib_output_path);
+        .name = "omtoy",
-    omt_module.addIncludePath(include_output_path);
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/main.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
+    }));
 
-    {
+    // exe.root_module.addLibraryPath(zomt_dep.namedLazyPath("output_dir"));
-        // Define executables
+    exe.root_module.addIncludePath(zomt_dep.namedLazyPath("output_dir"));
-        const sender_exe = b.addExecutable(.{
+    // exe.root_module.linkSystemLibrary("omt", .{});
-            .name = "omtoy-sender",
+    exe.root_module.addImport("zomt", zomt_mod);
-            .root_module = b.createModule(.{
-                .root_source_file = b.path("src/sender.zig"),
-                .target = target,
-                .optimize = optimize,
-            }),
-        });
-        sender_exe.root_module.addImport("omt", omt_module);
 
-        sender_exe.root_module.addLibraryPath(lib_output_path);
+    b.installArtifact(exe);
-        sender_exe.root_module.addIncludePath(include_output_path);
-        sender_exe.linkSystemLibrary("omt");
-        sender_exe.linkLibC();
 
-        b.installArtifact(sender_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());
 
-        // Add run step for sender
+    if (b.args) |args| {
-        const run_sender_step = b.step("sender-run", "Run the sender client");
+        run_cmd.addArgs(args);
-        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);
-        }
-    }
-
-    {
-        const receiver_exe = b.addExecutable(.{
-            .name = "omtoy-receiver",
-            .root_module = b.createModule(.{
-                .root_source_file = b.path("src/receiver.zig"),
-                .target = target,
-                .optimize = optimize,
-            }),
-        });
-        receiver_exe.root_module.addImport("omt", omt_module);
-
-        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

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,44 +32,10 @@
     // 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.
+        .zomt = .{
-        //.example = .{
+            .path = "omt/",
-        //    // 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",

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",
+    },
+}

src/main.zig

@@ -0,0 +1,31 @@
+const std = @import("std");
+const c = @cImport(@cInclude("libomt.h"));
+
+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");
+
+    // _ = discoverStream() orelse undefined;
+    std.log.info("Exiting omtoy!", .{});
+}