First commit

Signed-off-by: Pablo Alessandro Santos Hugen <phugen@redhat.com>

Author: Tomcat-42

.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        zig-version: [master]
+        os: [ubuntu-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Zig
+        uses: mlugg/setup-zig@v2
+        with:
+          version: ${{ matrix.zig-version }}
+
+      - name: Check Formatting
+        run: zig fmt --ast-check --check .
+
+      - name: Build
+        run: zig build --summary all

.gitignore

@@ -0,0 +1,4 @@
+.zig-cache/
+zig-cache/
+zig-out/
+zig-pkg/

LICENSE

@@ -0,0 +1,22 @@
+Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
+Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next
+paragraph) shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.

README.md

@@ -0,0 +1,20 @@
+# libdrm zig
+
+[libdrm](https://gitlab.freedesktop.org/mesa/libdrm), packaged for the Zig build system.
+
+Core library only (no GPU-specific sub-libraries).
+
+## Using
+
+First, update your `build.zig.zon`:
+
+```
+zig fetch --save git+https://github.com/allyourcodebase/libdrm.git
+```
+
+Then in your `build.zig`:
+
+```zig
+const libdrm = b.dependency("libdrm", .{ .target = target, .optimize = optimize });
+exe.linkLibrary(libdrm.artifact("drm"));
+```

build.zig

@@ -0,0 +1,68 @@
+const std = @import("std");
+const manifest = @import("build.zig.zon");
+
+pub fn build(b: *std.Build) !void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+    const linkage = b.option(std.builtin.LinkMode, "linkage", "Library linkage type") orelse .static;
+
+    const upstream = b.dependency("upstream", .{});
+    const src = upstream.path("");
+
+    const os = target.result.os.tag;
+    const is_linux = os == .linux;
+
+    const gen_fourcc = b.addExecutable(.{
+        .name = "gen_table_fourcc",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("tools/gen_table_fourcc.zig"),
+            .target = b.graph.host,
+        }),
+    });
+    const gen_run = b.addRunArtifact(gen_fourcc);
+    gen_run.addFileArg(src.path(b, "include/drm/drm_fourcc.h"));
+    const fourcc_wf = b.addWriteFiles();
+    _ = fourcc_wf.addCopyFile(gen_run.captureStdOut(.{}), "generated_static_table_fourcc.h");
+
+    // Module
+    const mod = b.createModule(.{ .target = target, .optimize = optimize, .link_libc = true });
+    mod.addIncludePath(src);
+    mod.addIncludePath(src.path(b, "include/drm"));
+    mod.addIncludePath(fourcc_wf.getDirectory());
+
+    const flags: []const []const u8 = flags: {
+        var list: std.ArrayListUnmanaged([]const u8) = .empty;
+        try list.ensureTotalCapacity(b.allocator, 1 << 4);
+
+        list.appendSliceAssumeCapacity(&.{
+            "-fvisibility=hidden",
+            "-DHAVE_LIBDRM_ATOMIC_PRIMITIVES=1",
+            "-DHAVE_VISIBILITY=1",
+            "-D_GNU_SOURCE",
+            "-DHAVE_OPEN_MEMSTREAM=1",
+            "-DHAVE_SECURE_GETENV=1",
+            "-DHAVE_SYS_SELECT_H=1",
+            "-DHAVE_ALLOCA_H=1",
+        });
+        if (is_linux) list.appendAssumeCapacity("-DMAJOR_IN_SYSMACROS=1");
+        break :flags try list.toOwnedSlice(b.allocator);
+    };
+
+    mod.addCSourceFiles(.{ .root = src, .files = &.{
+        "xf86drm.c",
+        "xf86drmHash.c",
+        "xf86drmRandom.c",
+        "xf86drmSL.c",
+        "xf86drmMode.c",
+    }, .flags = flags });
+
+    // Library
+    const lib = b.addLibrary(.{ .name = "drm", .root_module = mod, .linkage = linkage });
+
+    // Install headers
+    inline for (.{ "xf86drm.h", "xf86drmMode.h", "libsync.h" }) |h|
+        lib.installHeader(src.path(b, h), h);
+    lib.installHeadersDirectory(src.path(b, "include/drm"), "libdrm", .{});
+
+    b.installArtifact(lib);
+}

build.zig.zon

@@ -0,0 +1,13 @@
+.{
+    .name = .libdrm,
+    .version = "2.4.131",
+    .dependencies = .{
+        .upstream = .{
+            .url = "https://gitlab.freedesktop.org/mesa/libdrm/-/archive/libdrm-2.4.131/libdrm-libdrm-2.4.131.tar.gz",
+            .hash = "N-V-__8AAC3VLACNGc7Wsy7XkL-SyMdb3mfe_MPouEAZNt-A",
+        },
+    },
+    .minimum_zig_version = "0.16.0-dev.2653+784e89fd4",
+    .paths = .{ "build.zig", "build.zig.zon", "tools", "README.md", "LICENSE" },
+    .fingerprint = 0xaa2d215b57727d27,
+}

tools/gen_table_fourcc.zig

@@ -0,0 +1,95 @@
+const std = @import("std");
+const Io = std.Io;
+
+pub fn main(init: std.process.Init) !void {
+    const alloc = init.arena.allocator();
+    const io = init.io;
+
+    var args = std.process.Args.Iterator.init(init.minimal.args);
+    _ = args.skip();
+    const input_path = args.next() orelse return error.MissingArgument;
+
+    const data = try Io.Dir.readFileAlloc(.cwd(), io, input_path, alloc, .unlimited);
+
+    var intel_mods: std.ArrayList([]const u8) = .empty;
+    var other_mods: std.ArrayList(struct { []const u8, []const u8 }) = .empty;
+    var vendors: std.ArrayList([]const u8) = .empty;
+
+    var lines = std.mem.splitScalar(u8, data, '\n');
+    while (lines.next()) |line| {
+        if (parseAfter(line, "#define I915_FORMAT_MOD_")) |name| {
+            try intel_mods.append(alloc, name);
+        } else if (parseVendorMod(line)) |vm| {
+            try other_mods.append(alloc, vm);
+        } else if (parseAfter(line, "#define DRM_FORMAT_MOD_VENDOR_")) |name| {
+            try vendors.append(alloc, name);
+        }
+    }
+
+    var buf: [4096]u8 = undefined;
+    var fw = Io.File.stdout().writerStreaming(io, &buf);
+    const w = &fw.interface;
+
+    try w.writeAll(
+        \\/* AUTOMATICALLY GENERATED by gen_table_fourcc.zig */
+        \\static const struct drmFormatModifierInfo drm_format_modifier_table[] = {
+        \\    { DRM_MODIFIER_INVALID(NONE, INVALID) },
+        \\    { DRM_MODIFIER_LINEAR(NONE, LINEAR) },
+        \\
+    );
+
+    for (intel_mods.items) |mod|
+        try w.print("    {{ DRM_MODIFIER_INTEL({s}, {s}) }},\n", .{ mod, mod });
+
+    for (other_mods.items) |entry| {
+        const vendor, const mod = entry;
+        try w.print("    {{ DRM_MODIFIER({s}, {s}, {s}) }},\n", .{ vendor, mod, mod });
+    }
+
+    try w.writeAll(
+        \\};
+        \\static const struct drmFormatModifierVendorInfo drm_format_modifier_vendor_table[] = {
+        \\
+    );
+
+    for (vendors.items) |v|
+        try w.print("    {{ DRM_FORMAT_MOD_VENDOR_{s}, \"{s}\" }},\n", .{ v, v });
+
+    try w.writeAll("};\n");
+    try fw.flush();
+}
+
+fn parseAfter(line: []const u8, prefix: []const u8) ?[]const u8 {
+    const trimmed = std.mem.trimStart(u8, line, " \t");
+    if (!std.mem.startsWith(u8, trimmed, prefix)) return null;
+    const after = trimmed[prefix.len..];
+    const end = std.mem.indexOfAny(u8, after, " \t\r\n") orelse return null;
+    if (end == 0) return null;
+    const name = after[0..end];
+    if (std.mem.indexOfScalar(u8, name, '(') != null) return null;
+    return name;
+}
+
+fn parseVendorMod(line: []const u8) ?struct { []const u8, []const u8 } {
+    const prefix = "#define DRM_FORMAT_MOD_";
+    const trimmed = std.mem.trimStart(u8, line, " \t");
+    if (!std.mem.startsWith(u8, trimmed, prefix)) return null;
+    const after = trimmed[prefix.len..];
+
+    for ([_][]const u8{ "ARM", "SAMSUNG", "QCOM", "VIVANTE", "NVIDIA", "BROADCOM", "ALLWINNER" }) |vendor| {
+        if (std.mem.startsWith(u8, after, vendor) and after.len > vendor.len and after[vendor.len] == '_') {
+            const mod_start = vendor.len + 1;
+            // Require trailing whitespace (like the Python regex `\s` at end)
+            const end = std.mem.indexOfAny(u8, after[mod_start..], " \t\r\n") orelse continue;
+            if (end == 0) continue;
+            const mod = after[mod_start..][0..end];
+            if (std.mem.indexOfScalar(u8, mod, '(') != null) continue;
+            if (std.mem.eql(u8, vendor, "ARM") and
+                (std.mem.eql(u8, mod, "TYPE_AFBC") or
+                    std.mem.eql(u8, mod, "TYPE_MISC") or
+                    std.mem.eql(u8, mod, "TYPE_AFRC"))) continue;
+            return .{ vendor, mod };
+        }
+    }
+    return null;
+}