From c82d3dcccd0c274a44ea400af49ee7fbccff9fd8 Mon Sep 17 00:00:00 2001 From: Mason Remaley Date: Tue, 4 Nov 2025 13:53:34 -0800 Subject: [PATCH 01/11] Removes outdated comment --- build.zig | 131 +++++++++++++++++++++++++----------------------------- 1 file changed, 61 insertions(+), 70 deletions(-) diff --git a/build.zig b/build.zig index 4204311..2fe2fb3 100644 --- a/build.zig +++ b/build.zig @@ -107,76 +107,67 @@ pub fn build(b: *std.Build) void { }); // Build libpipewire - { - // Build the library - const libpipewire = b.addLibrary(.{ - .name = "pipewire-0.3", - // Pipewire needs to be build as a dynamic library for its symbols to be available to the - // dynamic libraries it dlopens. Alternatively, you can link it statically, but you'll need - // to set rdynamic on the executable to make these symbols available. - .linkage = .static, - .root_module = b.createModule(.{ - .target = target, - .optimize = optimize, - }), - }); - libpipewire.addCSourceFiles(.{ - .root = upstream.path("src/pipewire"), - .files = &.{ - "buffers.c", - "conf.c", - "context.c", - "control.c", - "core.c", - "data-loop.c", - "filter.c", - "global.c", - "impl-client.c", - "impl-core.c", - "impl-device.c", - "impl-factory.c", - "impl-link.c", - "impl-metadata.c", - "impl-module.c", - "impl-node.c", - "impl-port.c", - "introspect.c", - "log.c", - "loop.c", - "main-loop.c", - "mem.c", - "pipewire.c", - "properties.c", - "protocol.c", - "proxy.c", - "resource.c", - "settings.c", - "stream.c", - "thread-loop.c", - "thread.c", - "timer-queue.c", - "utils.c", - "work-queue.c", - }, - .flags = flags, - }); - libpipewire.linkLibC(); - - // Add include paths - libpipewire.addIncludePath(b.dependency("valgrind_h", .{}).path("")); - libpipewire.addIncludePath(upstream.path("spa/include")); - libpipewire.addIncludePath(upstream.path("src")); - libpipewire.addConfigHeader(version_h); - libpipewire.addConfigHeader(config_h); - - // Install public headers - libpipewire.installHeadersDirectory(upstream.path("src/pipewire"), "pipewire", .{}); - libpipewire.installHeadersDirectory(upstream.path("spa/include/spa"), "spa", .{}); - libpipewire.installConfigHeader(version_h); - - // Install the library - b.installArtifact(libpipewire); - } + const libpipewire = b.addLibrary(.{ + .name = "pipewire-0.3", + .linkage = .static, + .root_module = b.createModule(.{ + .target = target, + .optimize = optimize, + }), + }); + libpipewire.addCSourceFiles(.{ + .root = upstream.path("src/pipewire"), + .files = &.{ + "buffers.c", + "conf.c", + "context.c", + "control.c", + "core.c", + "data-loop.c", + "filter.c", + "global.c", + "impl-client.c", + "impl-core.c", + "impl-device.c", + "impl-factory.c", + "impl-link.c", + "impl-metadata.c", + "impl-module.c", + "impl-node.c", + "impl-port.c", + "introspect.c", + "log.c", + "loop.c", + "main-loop.c", + "mem.c", + "pipewire.c", + "properties.c", + "protocol.c", + "proxy.c", + "resource.c", + "settings.c", + "stream.c", + "thread-loop.c", + "thread.c", + "timer-queue.c", + "utils.c", + "work-queue.c", + }, + .flags = flags, + }); + libpipewire.linkLibC(); + + libpipewire.addIncludePath(b.dependency("valgrind_h", .{}).path("")); + libpipewire.addIncludePath(upstream.path("spa/include")); + libpipewire.addIncludePath(upstream.path("src")); + libpipewire.addConfigHeader(version_h); + libpipewire.addConfigHeader(config_h); + + libpipewire.installHeadersDirectory(upstream.path("src/pipewire"), "pipewire", .{}); + libpipewire.installHeadersDirectory(upstream.path("spa/include/spa"), "spa", .{}); + libpipewire.installConfigHeader(version_h); + + b.installArtifact(libpipewire); // Build the plugins and modules { From b39754bfbc3fa32712699d9c95d3463c79e1a2fa Mon Sep 17 00:00:00 2001 From: Mason Remaley Date: Tue, 4 Nov 2025 17:02:20 -0800 Subject: [PATCH 02/11] Temporarily links everything dynamically This is "more static" than dlopen, and will let us start to implement our own dlsym, at which point we can switch everything to static. --- build.zig | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/build.zig b/build.zig index 2fe2fb3..c74a6c0 100644 --- a/build.zig +++ b/build.zig @@ -109,7 +109,7 @@ pub fn build(b: *std.Build) void { // Build libpipewire const libpipewire = b.addLibrary(.{ .name = "pipewire-0.3", - .linkage = .static, + .linkage = .dynamic, .root_module = b.createModule(.{ .target = target, .optimize = optimize, @@ -169,6 +169,9 @@ pub fn build(b: *std.Build) void { b.installArtifact(libpipewire); + _ = install_dir.addCopyFile(libpipewire.getEmittedBin(), "libpipewire-0.3.so"); + _ = install_dir.addCopyFile(libpipewire.getEmittedBin(), "libpipewire-0.3.so.0"); + // Build the plugins and modules { const pm_ctx: PluginAndModuleCtx = .{ @@ -178,6 +181,7 @@ pub fn build(b: *std.Build) void { .version = version_h, .config = config_h, .install_dir = install_dir, + .libpipewire = libpipewire, }; // Build and install the plugins @@ -319,9 +323,6 @@ pub fn linkAndInstall( // Statically link libpipewire exe.linkLibrary(dep.artifact("pipewire-0.3")); - // Necessary for SPA to load symbols from the statically linked libpipewire - exe.rdynamic = true; - // Note that the cache rpath will still be present: https://github.com/ziglang/zig/issues/24349 exe.root_module.addRPathSpecial("$ORIGIN/pipewire-0.3"); @@ -350,6 +351,7 @@ pub const PluginAndModuleCtx = struct { target: std.Build.ResolvedTarget, optimize: std.builtin.OptimizeMode, install_dir: *std.Build.Step.WriteFile, + libpipewire: *std.Build.Step.Compile, }; pub const PipewireModule = struct { @@ -385,6 +387,8 @@ pub const PipewireModule = struct { b.fmt("libpipewire-module-{s}.so", .{self.name}), })); + ctx.libpipewire.linkLibrary(lib); + return lib; } }; @@ -425,6 +429,8 @@ pub const PipewirePlugin = struct { b.fmt("libspa-{s}.so", .{self.name}), })); + ctx.libpipewire.linkLibrary(lib); + return lib; } }; From 0b225c94af3d8dcb3e34512bab2d127e10d2b3b8 Mon Sep 17 00:00:00 2001 From: Mason Remaley Date: Tue, 4 Nov 2025 17:50:14 -0800 Subject: [PATCH 03/11] Stubs out dlopen/dlclose/dlsym/dlerror Need to actually implement dlsym for this to work. This will also break SDL, so we may need to switch to an example that doesn't require it or switch to a statically linked window alternative, or just modify the example temporarily to not need graphics. --- build.zig | 36 +++++++++++++++--------------------- src/dl.zig | 37 +++++++++++++++++++++++++++++++++++++ 2 files changed, 52 insertions(+), 21 deletions(-) create mode 100644 src/dl.zig diff --git a/build.zig b/build.zig index c74a6c0..1a33044 100644 --- a/build.zig +++ b/build.zig @@ -26,6 +26,17 @@ pub fn build(b: *std.Build) void { .install_subdir = "pipewire-0.3", }); + // Compile our dl stub + const dl = b.addLibrary(.{ + .name = "dl", + .linkage = .static, + .root_module = b.createModule(.{ + .root_source_file = b.path("src/dl.zig"), + .target = target, + .optimize = optimize, + }), + }); + // Build and install the configuration { const generate_conf = b.addExecutable(.{ @@ -109,12 +120,13 @@ pub fn build(b: *std.Build) void { // Build libpipewire const libpipewire = b.addLibrary(.{ .name = "pipewire-0.3", - .linkage = .dynamic, + .linkage = .static, .root_module = b.createModule(.{ .target = target, .optimize = optimize, }), }); + libpipewire.linkLibrary(dl); libpipewire.addCSourceFiles(.{ .root = upstream.path("src/pipewire"), .files = &.{ @@ -169,9 +181,6 @@ pub fn build(b: *std.Build) void { b.installArtifact(libpipewire); - _ = install_dir.addCopyFile(libpipewire.getEmittedBin(), "libpipewire-0.3.so"); - _ = install_dir.addCopyFile(libpipewire.getEmittedBin(), "libpipewire-0.3.so.0"); - // Build the plugins and modules { const pm_ctx: PluginAndModuleCtx = .{ @@ -365,7 +374,7 @@ pub const PipewireModule = struct { ) *std.Build.Step.Compile { const lib = b.addLibrary(.{ .name = b.fmt("pipewire-module-{s}", .{self.name}), - .linkage = .dynamic, + .linkage = .static, .root_module = b.createModule(.{ .target = ctx.target, .optimize = ctx.optimize, @@ -382,13 +391,6 @@ pub const PipewireModule = struct { lib.addConfigHeader(ctx.config); lib.linkLibC(); - _ = ctx.install_dir.addCopyFile(lib.getEmittedBin(), b.pathJoin(&.{ - "modules", - b.fmt("libpipewire-module-{s}.so", .{self.name}), - })); - - ctx.libpipewire.linkLibrary(lib); - return lib; } }; @@ -404,7 +406,7 @@ pub const PipewirePlugin = struct { ) *std.Build.Step.Compile { const lib = b.addLibrary(.{ .name = b.fmt("spa-{s}", .{self.name}), - .linkage = .dynamic, + .linkage = .static, .root_module = b.createModule(.{ .target = ctx.target, .optimize = ctx.optimize, @@ -423,14 +425,6 @@ pub const PipewirePlugin = struct { lib.addConfigHeader(ctx.config); lib.linkLibC(); - _ = ctx.install_dir.addCopyFile(lib.getEmittedBin(), b.pathJoin(&.{ - "plugins", - self.name, - b.fmt("libspa-{s}.so", .{self.name}), - })); - - ctx.libpipewire.linkLibrary(lib); - return lib; } }; diff --git a/src/dl.zig b/src/dl.zig new file mode 100644 index 0000000..86f6d68 --- /dev/null +++ b/src/dl.zig @@ -0,0 +1,37 @@ +const std = @import("std"); + +const log = std.log.scoped(.dl); // XXX: use this +const gpa = std.heap.smp_allocator; +const assert = std.debug.assert; + +export fn dlopen(path: ?[*:0]const c_char, flags: c_int) callconv(.c) ?*anyopaque { + comptime assert(@sizeOf(c_char) == @sizeOf(u8)); + const path_u8: ?[*:0]const u8 = @ptrCast(path); + log.info("dlopen({?s}, {})", .{ path_u8, flags }); + + const span = std.mem.span(path_u8 orelse return null); + const handle = gpa.dupeZ(u8, span) catch return null; + return handle.ptr; +} + +export fn dlclose(handle: ?*anyopaque) callconv(.c) c_int { + comptime assert(@sizeOf(c_char) == @sizeOf(u8)); + const path: [*:0]const u8 = @ptrCast(handle.?); + log.info("dlclose({s})", .{path}); + + gpa.free(std.mem.span(path)); + return 0; +} + +export fn dlsym(noalias handle: *anyopaque, noalias symbol_c: ?[*:0]c_char) ?*anyopaque { + const path: ?[*:0]u8 = @ptrCast(handle); + const symbol: ?[*:0]u8 = @ptrCast(symbol_c); + log.info("dlsym({?s}, {?s})", .{ path, symbol }); + + log.err("dlsym unimplemented!", .{}); + return null; +} + +export fn dlerror() ?[*:0]const u8 { + return null; +} From aa444efa4570a17ef0afd578584d62597d9c54ef Mon Sep 17 00:00:00 2001 From: Mason Remaley Date: Wed, 5 Nov 2025 14:47:28 -0800 Subject: [PATCH 04/11] Progress on dlfcn stub, need to try wirign up to actual symbols now --- build.zig | 8 ++-- src/dl.zig | 37 ----------------- src/dlfcn.zig | 110 ++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 114 insertions(+), 41 deletions(-) delete mode 100644 src/dl.zig create mode 100644 src/dlfcn.zig diff --git a/build.zig b/build.zig index 1a33044..b9e0d2f 100644 --- a/build.zig +++ b/build.zig @@ -27,11 +27,11 @@ pub fn build(b: *std.Build) void { }); // Compile our dl stub - const dl = b.addLibrary(.{ - .name = "dl", + const dlfcn = b.addLibrary(.{ + .name = "dlfcn", .linkage = .static, .root_module = b.createModule(.{ - .root_source_file = b.path("src/dl.zig"), + .root_source_file = b.path("src/dlfcn.zig"), .target = target, .optimize = optimize, }), @@ -126,7 +126,7 @@ pub fn build(b: *std.Build) void { .optimize = optimize, }), }); - libpipewire.linkLibrary(dl); + libpipewire.linkLibrary(dlfcn); libpipewire.addCSourceFiles(.{ .root = upstream.path("src/pipewire"), .files = &.{ diff --git a/src/dl.zig b/src/dl.zig deleted file mode 100644 index 86f6d68..0000000 --- a/src/dl.zig +++ /dev/null @@ -1,37 +0,0 @@ -const std = @import("std"); - -const log = std.log.scoped(.dl); // XXX: use this -const gpa = std.heap.smp_allocator; -const assert = std.debug.assert; - -export fn dlopen(path: ?[*:0]const c_char, flags: c_int) callconv(.c) ?*anyopaque { - comptime assert(@sizeOf(c_char) == @sizeOf(u8)); - const path_u8: ?[*:0]const u8 = @ptrCast(path); - log.info("dlopen({?s}, {})", .{ path_u8, flags }); - - const span = std.mem.span(path_u8 orelse return null); - const handle = gpa.dupeZ(u8, span) catch return null; - return handle.ptr; -} - -export fn dlclose(handle: ?*anyopaque) callconv(.c) c_int { - comptime assert(@sizeOf(c_char) == @sizeOf(u8)); - const path: [*:0]const u8 = @ptrCast(handle.?); - log.info("dlclose({s})", .{path}); - - gpa.free(std.mem.span(path)); - return 0; -} - -export fn dlsym(noalias handle: *anyopaque, noalias symbol_c: ?[*:0]c_char) ?*anyopaque { - const path: ?[*:0]u8 = @ptrCast(handle); - const symbol: ?[*:0]u8 = @ptrCast(symbol_c); - log.info("dlsym({?s}, {?s})", .{ path, symbol }); - - log.err("dlsym unimplemented!", .{}); - return null; -} - -export fn dlerror() ?[*:0]const u8 { - return null; -} diff --git a/src/dlfcn.zig b/src/dlfcn.zig new file mode 100644 index 0000000..b8f0a70 --- /dev/null +++ b/src/dlfcn.zig @@ -0,0 +1,110 @@ +const std = @import("std"); + +const log = std.log.scoped(.dl); +const assert = std.debug.assert; + +pub const Lib = struct { + name: []const u8, + symbols: std.StaticStringMap(*anyopaque), + + pub fn format(self: @This(), writer: *std.Io.Writer) std.Io.Writer.Error!void { + try writer.print("@\"{f}\"", .{std.zig.fmtString(self.name)}); + } +}; + +const main_program = "@SELF"; +const libs: std.StaticStringMap(Lib) = .initComptime(.{ + .{ + main_program, + Lib{ + .name = main_program, + .symbols = .initComptime(.{}), + }, + }, + .{ + "pipewire-0.3/plugins/support/libspa-support.so", + Lib{ + .name = "spa-support", + .symbols = .initComptime(.{ + // Implement! + // .{ "spa_handle_factory_enum", null }, + }), + }, + }, +}); + +export fn dlopen(path: ?[*:0]const c_char, flags: Flags) callconv(.c) ?*anyopaque { + comptime assert(@sizeOf(c_char) == @sizeOf(u8)); + const path_u8: [*:0]const u8 = if (path) |p| @ptrCast(p) else main_program; + const span = std.mem.span(path_u8); + const lib = if (libs.getIndex(span)) |index| &libs.kvs.values[index] else null; + log.info("dlopen(\"{f}\", {f}) -> {?f}", .{ std.zig.fmtString(span), flags, lib }); + return @ptrCast(@constCast(lib)); +} + +export fn dlclose(handle: ?*anyopaque) callconv(.c) c_int { + const lib: *const Lib = @ptrCast(@alignCast(handle.?)); + log.info("dlclose({f})", .{lib}); + return 0; +} + +export fn dlsym(noalias handle: ?*anyopaque, noalias name_c: ?[*:0]c_char) ?*anyopaque { + const lib: *const Lib = @ptrCast(@alignCast(handle.?)); + const name = std.mem.span(@as([*:0]u8, @ptrCast(name_c.?))); + const symbol = lib.symbols.get(name) orelse null; + log.info("dlsym({f}, \"{f}\") -> 0x{x}", .{ + lib, + std.zig.fmtString(name), + @intFromPtr(symbol), + }); + return symbol; +} + +export fn dlerror() ?[*:0]const u8 { + return null; +} + +export fn dlinfo(noalias handle: ?*anyopaque, request: c_int, noalias info: ?*anyopaque) c_int { + const lib: *const Lib = @ptrCast(@alignCast(handle.?)); // XXX: null allowed? + log.info("dlinfo({f}, {}, {x})", .{ lib, request, @intFromPtr(info) }); + @panic("unimplemented"); +} + +const Flags = packed struct(c_int) { + lazy: bool, + now: bool, + noload: bool, + _pad0: u5 = 0, + global: bool, + _pad1: u3 = 0, + nodelete: bool, + _pad2: std.meta.Int(.unsigned, @bitSizeOf(c_int) - 13) = 0, + + pub fn format(self: @This(), writer: *std.Io.Writer) std.Io.Writer.Error!void { + try writer.writeAll(".{"); + var first = true; + inline for (@typeInfo(@This()).@"struct".fields) |field| { + const val = @field(self, field.name); + switch (@typeInfo(field.type)) { + .bool => if (val) { + if (!first) { + try writer.writeAll(","); + } + first = false; + try writer.writeAll(" "); + try writer.print(".{s} = true", .{field.name}); + }, + .int => if (val != 0) { + if (!first) { + try writer.writeAll(", "); + first = false; + } + try writer.print(".{s} = {x}", .{ field.name, val }); + }, + else => comptime unreachable, + } + } + if (!first) try writer.writeAll(" "); + try writer.writeAll("}"); + } +}; From 751a5e62ea457ce933698fa08a4b6ba623c74b01 Mon Sep 17 00:00:00 2001 From: Mason Remaley Date: Wed, 5 Nov 2025 15:50:07 -0800 Subject: [PATCH 05/11] Adds actual symbols to table --- build.zig | 8 +++++ src/dlfcn.zig | 84 +++++++++++++++++++++++++++++++-------------------- 2 files changed, 59 insertions(+), 33 deletions(-) diff --git a/build.zig b/build.zig index b9e0d2f..ed80181 100644 --- a/build.zig +++ b/build.zig @@ -191,6 +191,7 @@ pub fn build(b: *std.Build) void { .config = config_h, .install_dir = install_dir, .libpipewire = libpipewire, + .dlfcn = dlfcn, }; // Build and install the plugins @@ -361,6 +362,7 @@ pub const PluginAndModuleCtx = struct { optimize: std.builtin.OptimizeMode, install_dir: *std.Build.Step.WriteFile, libpipewire: *std.Build.Step.Compile, + dlfcn: *std.Build.Step.Compile, }; pub const PipewireModule = struct { @@ -391,6 +393,9 @@ pub const PipewireModule = struct { lib.addConfigHeader(ctx.config); lib.linkLibC(); + ctx.dlfcn.linkLibrary(lib); + ctx.dlfcn.addIncludePath(ctx.upstream.path("spa/include")); + return lib; } }; @@ -425,6 +430,9 @@ pub const PipewirePlugin = struct { lib.addConfigHeader(ctx.config); lib.linkLibC(); + ctx.dlfcn.linkLibrary(lib); + ctx.dlfcn.addIncludePath(ctx.upstream.path("spa/include")); + return lib; } }; diff --git a/src/dlfcn.zig b/src/dlfcn.zig index b8f0a70..f8c947c 100644 --- a/src/dlfcn.zig +++ b/src/dlfcn.zig @@ -3,21 +3,20 @@ const std = @import("std"); const log = std.log.scoped(.dl); const assert = std.debug.assert; -pub const Lib = struct { - name: []const u8, - symbols: std.StaticStringMap(*anyopaque), +const support = struct { + pub const c = @cImport({ + @cInclude("spa/support/plugin.h"); + @cInclude("spa/support/log.h"); + }); - pub fn format(self: @This(), writer: *std.Io.Writer) std.Io.Writer.Error!void { - try writer.print("@\"{f}\"", .{std.zig.fmtString(self.name)}); - } + extern const spa_log_topic_enum: c.spa_log_topic_enum; }; -const main_program = "@SELF"; const libs: std.StaticStringMap(Lib) = .initComptime(.{ .{ - main_program, + Lib.main_program_name, Lib{ - .name = main_program, + .name = Lib.main_program_name, .symbols = .initComptime(.{}), }, }, @@ -26,19 +25,17 @@ const libs: std.StaticStringMap(Lib) = .initComptime(.{ Lib{ .name = "spa-support", .symbols = .initComptime(.{ - // Implement! - // .{ "spa_handle_factory_enum", null }, + .{ "spa_handle_factory_enum", Lib.sym(&support.c.spa_handle_factory_enum) }, + .{ "spa_log_topic_enum", Lib.sym(&support.spa_log_topic_enum) }, }), }, }, }); -export fn dlopen(path: ?[*:0]const c_char, flags: Flags) callconv(.c) ?*anyopaque { - comptime assert(@sizeOf(c_char) == @sizeOf(u8)); - const path_u8: [*:0]const u8 = if (path) |p| @ptrCast(p) else main_program; - const span = std.mem.span(path_u8); +export fn dlopen(path: ?[*:0]const u8, mode: std.c.RTLD) callconv(.c) ?*anyopaque { + const span = if (path) |p| std.mem.span(p) else Lib.main_program_name; const lib = if (libs.getIndex(span)) |index| &libs.kvs.values[index] else null; - log.info("dlopen(\"{f}\", {f}) -> {?f}", .{ std.zig.fmtString(span), flags, lib }); + log.info("dlopen(\"{f}\", {f}) -> {?f}", .{ std.zig.fmtString(span), FmtMode.init(mode), lib }); return @ptrCast(@constCast(lib)); } @@ -48,20 +45,29 @@ export fn dlclose(handle: ?*anyopaque) callconv(.c) c_int { return 0; } -export fn dlsym(noalias handle: ?*anyopaque, noalias name_c: ?[*:0]c_char) ?*anyopaque { +export fn dlsym(noalias handle: ?*anyopaque, noalias name: [*:0]u8) ?*anyopaque { const lib: *const Lib = @ptrCast(@alignCast(handle.?)); - const name = std.mem.span(@as([*:0]u8, @ptrCast(name_c.?))); - const symbol = lib.symbols.get(name) orelse null; - log.info("dlsym({f}, \"{f}\") -> 0x{x}", .{ + const span = std.mem.span(name); + var msg: ?[:0]const u8 = null; + const symbol = lib.symbols.get(span) orelse b: { + msg = "symbol not found"; + break :b null; + }; + log.info("dlsym({f}, \"{f}\") -> 0x{x} ({s})", .{ lib, - std.zig.fmtString(name), + std.zig.fmtString(span), @intFromPtr(symbol), + if (msg) |m| m else "success", }); + if (msg) |m| err = m; return symbol; } +var err: ?[*:0]const u8 = null; export fn dlerror() ?[*:0]const u8 { - return null; + const result = err; + err = null; + return result; } export fn dlinfo(noalias handle: ?*anyopaque, request: c_int, noalias info: ?*anyopaque) c_int { @@ -70,21 +76,33 @@ export fn dlinfo(noalias handle: ?*anyopaque, request: c_int, noalias info: ?*an @panic("unimplemented"); } -const Flags = packed struct(c_int) { - lazy: bool, - now: bool, - noload: bool, - _pad0: u5 = 0, - global: bool, - _pad1: u3 = 0, - nodelete: bool, - _pad2: std.meta.Int(.unsigned, @bitSizeOf(c_int) - 13) = 0, +pub const Lib = struct { + const main_program_name = "@SELF"; + + name: []const u8, + symbols: std.StaticStringMap(*anyopaque), pub fn format(self: @This(), writer: *std.Io.Writer) std.Io.Writer.Error!void { + try writer.print("@\"{f}\"", .{std.zig.fmtString(self.name)}); + } + + pub fn sym(val: anytype) *anyopaque { + return @ptrCast(@constCast(val)); + } +}; + +pub const FmtMode = struct { + val: std.c.RTLD, + + pub fn init(val: std.c.RTLD) @This() { + return .{ .val = val }; + } + + pub fn format(self: anytype, writer: *std.Io.Writer) std.Io.Writer.Error!void { try writer.writeAll(".{"); var first = true; - inline for (@typeInfo(@This()).@"struct".fields) |field| { - const val = @field(self, field.name); + inline for (@typeInfo(@TypeOf(self.val)).@"struct".fields) |field| { + const val = @field(self.val, field.name); switch (@typeInfo(field.type)) { .bool => if (val) { if (!first) { From 004267ede55b0222fb335574873aed6df086f1d1 Mon Sep 17 00:00:00 2001 From: Mason Remaley Date: Wed, 5 Nov 2025 15:50:16 -0800 Subject: [PATCH 06/11] Temporarily disables SDL in example so we can test without dynamic linking --- src/screen-play.c | 100 +++++++++++++++++++++++----------------------- src/sdl.h | 38 +++++++++--------- 2 files changed, 70 insertions(+), 68 deletions(-) diff --git a/src/screen-play.c b/src/screen-play.c index f13af81..3d1dcfe 100644 --- a/src/screen-play.c +++ b/src/screen-play.c @@ -61,14 +61,14 @@ struct data { static void handle_events(struct data *data) { - SDL_Event event; - while (SDL_PollEvent(&event)) { - switch (event.type) { - case SDL_EVENT_QUIT: - pw_main_loop_quit(data->loop); - break; - } - } + // SDL_Event event; + // while (SDL_PollEvent(&event)) { + // switch (event.type) { + // case SDL_EVENT_QUIT: + // pw_main_loop_quit(data->loop); + // break; + // } + // } } /* our data processing function is in general: @@ -147,19 +147,19 @@ on_process(void *_data) data->cursor_rect.w = mb->size.width; data->cursor_rect.h = mb->size.height; - if (data->cursor == NULL) { - data->cursor = SDL_CreateTexture(data->renderer, - id_to_sdl_format(mb->format), - SDL_TEXTUREACCESS_STREAMING, - mb->size.width, mb->size.height); - SDL_SetTextureBlendMode(data->cursor, SDL_BLENDMODE_BLEND); - } + // if (data->cursor == NULL) { + // data->cursor = SDL_CreateTexture(data->renderer, + // id_to_sdl_format(mb->format), + // SDL_TEXTUREACCESS_STREAMING, + // mb->size.width, mb->size.height); + // SDL_SetTextureBlendMode(data->cursor, SDL_BLENDMODE_BLEND); + // } - if (!SDL_LockTexture(data->cursor, NULL, &cdata, &cstride)) { - fprintf(stderr, "Couldn't lock cursor texture: %s\n", SDL_GetError()); - goto done; - } + // if (!SDL_LockTexture(data->cursor, NULL, &cdata, &cstride)) { + // fprintf(stderr, "Couldn't lock cursor texture: %s\n", SDL_GetError()); + // goto done; + // } /* copy the cursor bitmap into the texture */ src = SPA_PTROFF(mb, mb->offset, uint8_t); @@ -171,7 +171,7 @@ on_process(void *_data) dst += cstride; src += mb->stride; } - SDL_UnlockTexture(data->cursor); + // SDL_UnlockTexture(data->cursor); render_cursor = true; } @@ -181,22 +181,22 @@ on_process(void *_data) void *datas[4]; sstride = data->stride; if (buf->n_datas == 1) { - SDL_UpdateTexture(data->texture, NULL, - sdata, sstride); + // SDL_UpdateTexture(data->texture, NULL, + // sdata, sstride); } else { datas[0] = sdata; datas[1] = buf->datas[1].data; datas[2] = buf->datas[2].data; - SDL_UpdateYUVTexture(data->texture, NULL, - datas[0], sstride, - datas[1], sstride / 2, - datas[2], sstride / 2); + // SDL_UpdateYUVTexture(data->texture, NULL, + // datas[0], sstride, + // datas[1], sstride / 2, + // datas[2], sstride / 2); } } else { - if (!SDL_LockTexture(data->texture, NULL, &ddata, &dstride)) { - fprintf(stderr, "Couldn't lock texture: %s\n", SDL_GetError()); - } + // if (!SDL_LockTexture(data->texture, NULL, &ddata, &dstride)) { + // fprintf(stderr, "Couldn't lock texture: %s\n", SDL_GetError()); + // } sstride = buf->datas[0].chunk->stride; if (sstride == 0) @@ -225,16 +225,16 @@ on_process(void *_data) dst += dstride; } } - SDL_UnlockTexture(data->texture); + // SDL_UnlockTexture(data->texture); } - SDL_RenderClear(data->renderer); - /* now render the video and then the cursor if any */ - SDL_RenderTexture(data->renderer, data->texture, &data->rect, NULL); - if (render_cursor) { - SDL_RenderTexture(data->renderer, data->cursor, NULL, &data->cursor_rect); - } - SDL_RenderPresent(data->renderer); + // SDL_RenderClear(data->renderer); + // /* now render the video and then the cursor if any */ + // SDL_RenderTexture(data->renderer, data->texture, &data->rect, NULL); + // if (render_cursor) { + // SDL_RenderTexture(data->renderer, data->cursor, NULL, &data->cursor_rect); + // } + // SDL_RenderPresent(data->renderer); done: pw_stream_queue_buffer(stream, b); @@ -498,15 +498,15 @@ int main(int argc, char *argv[]) &stream_events, &data); - if (!SDL_Init(SDL_INIT_VIDEO)) { - fprintf(stderr, "can't initialize SDL: %s\n", SDL_GetError()); - return -1; - } + // if (!SDL_Init(SDL_INIT_VIDEO)) { + // fprintf(stderr, "can't initialize SDL: %s\n", SDL_GetError()); + // return -1; + // } - if (!SDL_CreateWindowAndRenderer("Demo", WIDTH, HEIGHT, SDL_WINDOW_RESIZABLE, &data.window, &data.renderer)) { - fprintf(stderr, "can't create window: %s\n", SDL_GetError()); - return -1; - } + // if (!SDL_CreateWindowAndRenderer("Demo", WIDTH, HEIGHT, SDL_WINDOW_RESIZABLE, &data.window, &data.renderer)) { + // fprintf(stderr, "can't create window: %s\n", SDL_GetError()); + // return -1; + // } /* build the extra parameters to connect with. To connect, we can provide * a list of supported formats. We use a builder that writes the param @@ -543,11 +543,11 @@ int main(int argc, char *argv[]) pw_stream_destroy(data.stream); pw_main_loop_destroy(data.loop); - SDL_DestroyTexture(data.texture); - if (data.cursor) - SDL_DestroyTexture(data.cursor); - SDL_DestroyRenderer(data.renderer); - SDL_DestroyWindow(data.window); + // SDL_DestroyTexture(data.texture); + // if (data.cursor) + // SDL_DestroyTexture(data.cursor); + // SDL_DestroyRenderer(data.renderer); + // SDL_DestroyWindow(data.window); pw_deinit(); return 0; diff --git a/src/sdl.h b/src/sdl.h index 002d134..b066476 100644 --- a/src/sdl.h +++ b/src/sdl.h @@ -148,21 +148,22 @@ static inline struct spa_pod *sdl_build_formats(SDL_Renderer * renderer, struct SDL_PropertiesID props = SDL_GetRendererProperties(renderer); - const SDL_PixelFormat *texture_formats = SDL_GetPointerProperty( - props, - SDL_PROP_RENDERER_TEXTURE_FORMATS_POINTER, - NULL - ); + // const SDL_PixelFormat *texture_formats = nullptr; + // SDL_GetPointerProperty( + // props, + // SDL_PROP_RENDERER_TEXTURE_FORMATS_POINTER, + // NULL + // ); /* first the formats supported by the textures */ - for (i = 0, c = 0; texture_formats[i] != SDL_PIXELFORMAT_UNKNOWN; i++) { - uint32_t id = sdl_format_to_id(texture_formats[i]); - if (id == 0) - continue; - if (c++ == 0) - spa_pod_builder_id(b, SPA_VIDEO_FORMAT_UNKNOWN); - spa_pod_builder_id(b, id); - } + // for (i = 0, c = 0; texture_formats[i] != SDL_PIXELFORMAT_UNKNOWN; i++) { + // uint32_t id = sdl_format_to_id(texture_formats[i]); + // if (id == 0) + // continue; + // if (c++ == 0) + // spa_pod_builder_id(b, SPA_VIDEO_FORMAT_UNKNOWN); + // spa_pod_builder_id(b, id); + // } /* then all the other ones SDL can convert from/to */ SPA_FOR_EACH_ELEMENT_VAR(sdl_video_formats, f) { uint32_t id = f->id; @@ -172,11 +173,12 @@ static inline struct spa_pod *sdl_build_formats(SDL_Renderer * renderer, struct spa_pod_builder_id(b, SPA_VIDEO_FORMAT_RGBA_F32); spa_pod_builder_pop(b, &f[1]); /* add size and framerate ranges */ - uint64_t max_texture_size = SDL_GetNumberProperty( - props, - SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, - 0 - ); + // uint64_t max_texture_size = SDL_GetNumberProperty( + // props, + // SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, + // 0 + // ); + uint64_t max_texture_size = 4096; spa_pod_builder_add(b, SPA_FORMAT_VIDEO_size, SPA_POD_CHOICE_RANGE_Rectangle( &SPA_RECTANGLE(WIDTH, HEIGHT), From 93d6718241974d77a264d995f8506608b760fe27 Mon Sep 17 00:00:00 2001 From: Mason Remaley Date: Fri, 7 Nov 2025 16:17:55 -0800 Subject: [PATCH 07/11] Adds all modules and plugins for screen play example, namespaces symbols to avoid collisions I believe this is now working with full static linking, but to be sure we'll need to find a way to display the image with static linking, write it to a file, or use a different example that doesn't require video. --- build.zig | 40 ++++++++++++++-- src/dlfcn.zig | 129 ++++++++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 157 insertions(+), 12 deletions(-) diff --git a/build.zig b/build.zig index ed80181..e5ec658 100644 --- a/build.zig +++ b/build.zig @@ -333,9 +333,6 @@ pub fn linkAndInstall( // Statically link libpipewire exe.linkLibrary(dep.artifact("pipewire-0.3")); - // Note that the cache rpath will still be present: https://github.com/ziglang/zig/issues/24349 - exe.root_module.addRPathSpecial("$ORIGIN/pipewire-0.3"); - // Install Pipewire's dependencies b.installDirectory(.{ .install_dir = .bin, @@ -393,6 +390,9 @@ pub const PipewireModule = struct { lib.addConfigHeader(ctx.config); lib.linkLibC(); + namespace(lib, "pipewire__module_init"); + namespace(lib, "mod_topic"); + ctx.dlfcn.linkLibrary(lib); ctx.dlfcn.addIncludePath(ctx.upstream.path("spa/include")); @@ -430,9 +430,43 @@ pub const PipewirePlugin = struct { lib.addConfigHeader(ctx.config); lib.linkLibC(); + namespace(lib, "spa_handle_factory_enum"); + namespace(lib, "spa_log_topic_enum"); + ctx.dlfcn.linkLibrary(lib); ctx.dlfcn.addIncludePath(ctx.upstream.path("spa/include")); return lib; } }; + +pub fn namespace(library: *std.Build.Step.Compile, symbol: []const u8) void { + const b = library.root_module.owner; + library.root_module.addCMacro( + symbol, + b.fmt("{f}", .{Namespaced.init(library.name, symbol)}), + ); +} + +pub const Namespaced = struct { + prefix: []const u8, + symbol: []const u8, + + pub fn init(prefix: []const u8, symbol: []const u8) Namespaced { + return .{ + .prefix = prefix, + .symbol = symbol, + }; + } + + pub fn format(self: @This(), writer: *std.Io.Writer) std.Io.Writer.Error!void { + for (self.prefix) |c| { + switch (c) { + '-' => try writer.writeByte('_'), + else => try writer.writeByte(c), + } + } + try writer.writeAll("__"); + try writer.writeAll(self.symbol); + } +}; diff --git a/src/dlfcn.zig b/src/dlfcn.zig index f8c947c..4027af4 100644 --- a/src/dlfcn.zig +++ b/src/dlfcn.zig @@ -3,13 +3,30 @@ const std = @import("std"); const log = std.log.scoped(.dl); const assert = std.debug.assert; -const support = struct { - pub const c = @cImport({ - @cInclude("spa/support/plugin.h"); - @cInclude("spa/support/log.h"); - }); +pub const c = @cImport({ + @cInclude("spa/support/plugin.h"); + @cInclude("spa/support/log.h"); +}); + +const plugins = struct { + const SpaHandleFactoryEnum = @TypeOf(c.spa_handle_factory_enum); + + pub extern const spa_support__spa_handle_factory_enum: SpaHandleFactoryEnum; + pub extern const spa_videoconvert__spa_handle_factory_enum: SpaHandleFactoryEnum; - extern const spa_log_topic_enum: c.spa_log_topic_enum; + pub extern const spa_support__spa_log_topic_enum: c.spa_log_topic_enum; + pub extern const spa_videoconvert__spa_log_topic_enum: c.spa_log_topic_enum; +}; + +const modules = struct { + const PipewireModuleInit = fn (_: *anyopaque, _: *anyopaque) callconv(.c) void; + + pub extern const pipewire_module_protocol_native__pipewire__module_init: PipewireModuleInit; + pub extern const pipewire_module_client_node__pipewire__module_init: PipewireModuleInit; + pub extern const pipewire_module_client_device__pipewire__module_init: PipewireModuleInit; + pub extern const pipewire_module_adapter__pipewire__module_init: PipewireModuleInit; + pub extern const pipewire_module_metadata__pipewire__module_init: PipewireModuleInit; + pub extern const pipewire_module_session_manager__pipewire__module_init: PipewireModuleInit; }; const libs: std.StaticStringMap(Lib) = .initComptime(.{ @@ -25,8 +42,102 @@ const libs: std.StaticStringMap(Lib) = .initComptime(.{ Lib{ .name = "spa-support", .symbols = .initComptime(.{ - .{ "spa_handle_factory_enum", Lib.sym(&support.c.spa_handle_factory_enum) }, - .{ "spa_log_topic_enum", Lib.sym(&support.spa_log_topic_enum) }, + .{ + "spa_handle_factory_enum", + Lib.sym(&plugins.spa_support__spa_handle_factory_enum), + }, + .{ + "spa_log_topic_enum", + Lib.sym(&plugins.spa_support__spa_log_topic_enum), + }, + }), + }, + }, + .{ + "pipewire-0.3/plugins/videoconvert/libspa-videoconvert.so", + Lib{ + .name = "libspa-videoconvert", + .symbols = .initComptime(.{ + .{ + "spa_handle_factory_enum", + Lib.sym(&plugins.spa_videoconvert__spa_handle_factory_enum), + }, + .{ + "spa_log_topic_enum", + Lib.sym(&plugins.spa_videoconvert__spa_log_topic_enum), + }, + }), + }, + }, + .{ + "pipewire-0.3/modules/libpipewire-module-protocol-native.so", + Lib{ + .name = "libpipewire-module-protocol-native", + .symbols = .initComptime(.{ + .{ + "pipewire__module_init", + Lib.sym(&modules.pipewire_module_protocol_native__pipewire__module_init), + }, + }), + }, + }, + .{ + "pipewire-0.3/modules/libpipewire-module-client-node.so", + Lib{ + .name = "libpipewire-module-client-node", + .symbols = .initComptime(.{ + .{ + "pipewire__module_init", + Lib.sym(&modules.pipewire_module_client_node__pipewire__module_init), + }, + }), + }, + }, + .{ + "pipewire-0.3/modules/libpipewire-module-client-device.so", + Lib{ + .name = "libpipewire-module-client-device", + .symbols = .initComptime(.{ + .{ + "pipewire__module_init", + Lib.sym(&modules.pipewire_module_client_device__pipewire__module_init), + }, + }), + }, + }, + .{ + "pipewire-0.3/modules/libpipewire-module-adapter.so", + Lib{ + .name = "libpipewire-module-adapter", + .symbols = .initComptime(.{ + .{ + "pipewire__module_init", + Lib.sym(&modules.pipewire_module_adapter__pipewire__module_init), + }, + }), + }, + }, + .{ + "pipewire-0.3/modules/libpipewire-module-metadata.so", + Lib{ + .name = "libpipewire-module-metadata", + .symbols = .initComptime(.{ + .{ + "pipewire__module_init", + Lib.sym(&modules.pipewire_module_metadata__pipewire__module_init), + }, + }), + }, + }, + .{ + "pipewire-0.3/modules/libpipewire-module-session-manager.so", + Lib{ + .name = "libpipewire-module-session-manager", + .symbols = .initComptime(.{ + .{ + "pipewire__module_init", + Lib.sym(&modules.pipewire_module_session_manager__pipewire__module_init), + }, }), }, }, @@ -71,7 +182,7 @@ export fn dlerror() ?[*:0]const u8 { } export fn dlinfo(noalias handle: ?*anyopaque, request: c_int, noalias info: ?*anyopaque) c_int { - const lib: *const Lib = @ptrCast(@alignCast(handle.?)); // XXX: null allowed? + const lib: *const Lib = @ptrCast(@alignCast(handle.?)); log.info("dlinfo({f}, {}, {x})", .{ lib, request, @intFromPtr(info) }); @panic("unimplemented"); } From b1a88b689223c77590314d1e8d4b06217945f81c Mon Sep 17 00:00:00 2001 From: Mason Remaley Date: Fri, 7 Nov 2025 17:27:45 -0800 Subject: [PATCH 08/11] Adds stubs for when RTLD_NEXT is passed in --- src/dlfcn.zig | 91 +++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 88 insertions(+), 3 deletions(-) diff --git a/src/dlfcn.zig b/src/dlfcn.zig index 4027af4..f4ea479 100644 --- a/src/dlfcn.zig +++ b/src/dlfcn.zig @@ -6,6 +6,7 @@ const assert = std.debug.assert; pub const c = @cImport({ @cInclude("spa/support/plugin.h"); @cInclude("spa/support/log.h"); + @cInclude("dlfcn.h"); }); const plugins = struct { @@ -29,6 +30,51 @@ const modules = struct { pub extern const pipewire_module_session_manager__pipewire__module_init: PipewireModuleInit; }; +const fops = struct { + pub fn OPENAT64( + dirfd: c_int, + path: [*:0]const u8, + oflag: c_int, + mode: std.c.mode_t, + ) callconv(.c) c_int { + return @intCast(std.os.linux.openat(dirfd, path, @bitCast(oflag), mode)); + } + + pub fn dup(oldfd: c_int) callconv(.c) c_int { + return @intCast(std.os.linux.dup(oldfd)); + } + + pub fn close(fd: c_int) callconv(.c) c_int { + return @intCast(std.os.linux.close(fd)); + } + + pub fn ioctl(fd: c_int, request: c_ulong, arg: *anyopaque) callconv(.c) c_int { + return @intCast(std.os.linux.ioctl(fd, @intCast(request), @intFromPtr(arg))); + } + + pub fn mmap64( + addr: ?[*]u8, + length: usize, + prot: c_int, + flags: c_int, + fd: c_int, + offset: i64, + ) callconv(.c) *anyopaque { + return @ptrFromInt(std.os.linux.mmap( + addr, + length, + @intCast(prot), + @bitCast(flags), + fd, + offset, + )); + } + + pub fn munmap(addr: [*]const u8, length: usize) callconv(.c) c_int { + return @intCast(std.os.linux.munmap(addr, length)); + } +}; + const libs: std.StaticStringMap(Lib) = .initComptime(.{ .{ Lib.main_program_name, @@ -37,6 +83,38 @@ const libs: std.StaticStringMap(Lib) = .initComptime(.{ .symbols = .initComptime(.{}), }, }, + .{ + Lib.rtld_next_name, + Lib{ + .name = Lib.rtld_next_name, + .symbols = .initComptime(.{ + .{ + "OPENAT64", + Lib.sym(&fops.OPENAT64), + }, + .{ + "dup", + Lib.sym(&fops.dup), + }, + .{ + "close", + Lib.sym(&fops.close), + }, + .{ + "ioctl", + Lib.sym(&fops.ioctl), + }, + .{ + "mmap64", + Lib.sym(&fops.mmap64), + }, + .{ + "munmap", + Lib.sym(&fops.munmap), + }, + }), + }, + }, .{ "pipewire-0.3/plugins/support/libspa-support.so", Lib{ @@ -160,9 +238,15 @@ export fn dlsym(noalias handle: ?*anyopaque, noalias name: [*:0]u8) ?*anyopaque const lib: *const Lib = @ptrCast(@alignCast(handle.?)); const span = std.mem.span(name); var msg: ?[:0]const u8 = null; - const symbol = lib.symbols.get(span) orelse b: { - msg = "symbol not found"; - break :b null; + const symbol = b: { + if (handle == c.RTLD_NEXT) { + break :b lib.symbols.get(Lib.rtld_next_name).?; + } + const symbol = lib.symbols.get(span) orelse { + msg = "symbol not found"; + break :b null; + }; + break :b symbol; }; log.info("dlsym({f}, \"{f}\") -> 0x{x} ({s})", .{ lib, @@ -189,6 +273,7 @@ export fn dlinfo(noalias handle: ?*anyopaque, request: c_int, noalias info: ?*an pub const Lib = struct { const main_program_name = "@SELF"; + const rtld_next_name = "@RTLD_NEXT"; name: []const u8, symbols: std.StaticStringMap(*anyopaque), From 1a2976b6cd2d3a508cfd5af6e937dc601090e668 Mon Sep 17 00:00:00 2001 From: Mason Remaley Date: Fri, 14 Nov 2025 15:20:14 -0800 Subject: [PATCH 09/11] Caches translated headers to work around translate c issue Will fix compiler errors in followup commit --- src/c.zig | 22565 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 22565 insertions(+) create mode 100644 src/c.zig diff --git a/src/c.zig b/src/c.zig new file mode 100644 index 0000000..268275c --- /dev/null +++ b/src/c.zig @@ -0,0 +1,22565 @@ +//! HACK: +//! +//! This file is a hack to unblock me while I wait to land a translate C patch. +//! +//! Translate C currently translates `sizeof(T)` to `@sizeOf(T)`, which isn't quite right--it should +//! be `@as(usize, @sizeOf(T))`, this becomes important when doing a bitcast on the result. This +//! file has the fix applied manually, I'll delete this file and upstream a real patch to translate +//! C soon. +//! +//! Source generated by: +//! ``` +//! const c = @cImport({ +//! @cInclude("spa/utils/defs.h"); +//! @cInclude("pipewire/pipewire.h"); +//! @cInclude("spa/param/video/format-utils.h"); +//! @cInclude("spa/debug/format.h"); +//! }); +//! + +pub const __builtin_bswap16 = @import("std").zig.c_builtins.__builtin_bswap16; +pub const __builtin_bswap32 = @import("std").zig.c_builtins.__builtin_bswap32; +pub const __builtin_bswap64 = @import("std").zig.c_builtins.__builtin_bswap64; +pub const __builtin_signbit = @import("std").zig.c_builtins.__builtin_signbit; +pub const __builtin_signbitf = @import("std").zig.c_builtins.__builtin_signbitf; +pub const __builtin_popcount = @import("std").zig.c_builtins.__builtin_popcount; +pub const __builtin_ctz = @import("std").zig.c_builtins.__builtin_ctz; +pub const __builtin_clz = @import("std").zig.c_builtins.__builtin_clz; +pub const __builtin_sqrt = @import("std").zig.c_builtins.__builtin_sqrt; +pub const __builtin_sqrtf = @import("std").zig.c_builtins.__builtin_sqrtf; +pub const __builtin_sin = @import("std").zig.c_builtins.__builtin_sin; +pub const __builtin_sinf = @import("std").zig.c_builtins.__builtin_sinf; +pub const __builtin_cos = @import("std").zig.c_builtins.__builtin_cos; +pub const __builtin_cosf = @import("std").zig.c_builtins.__builtin_cosf; +pub const __builtin_exp = @import("std").zig.c_builtins.__builtin_exp; +pub const __builtin_expf = @import("std").zig.c_builtins.__builtin_expf; +pub const __builtin_exp2 = @import("std").zig.c_builtins.__builtin_exp2; +pub const __builtin_exp2f = @import("std").zig.c_builtins.__builtin_exp2f; +pub const __builtin_log = @import("std").zig.c_builtins.__builtin_log; +pub const __builtin_logf = @import("std").zig.c_builtins.__builtin_logf; +pub const __builtin_log2 = @import("std").zig.c_builtins.__builtin_log2; +pub const __builtin_log2f = @import("std").zig.c_builtins.__builtin_log2f; +pub const __builtin_log10 = @import("std").zig.c_builtins.__builtin_log10; +pub const __builtin_log10f = @import("std").zig.c_builtins.__builtin_log10f; +pub const __builtin_abs = @import("std").zig.c_builtins.__builtin_abs; +pub const __builtin_labs = @import("std").zig.c_builtins.__builtin_labs; +pub const __builtin_llabs = @import("std").zig.c_builtins.__builtin_llabs; +pub const __builtin_fabs = @import("std").zig.c_builtins.__builtin_fabs; +pub const __builtin_fabsf = @import("std").zig.c_builtins.__builtin_fabsf; +pub const __builtin_floor = @import("std").zig.c_builtins.__builtin_floor; +pub const __builtin_floorf = @import("std").zig.c_builtins.__builtin_floorf; +pub const __builtin_ceil = @import("std").zig.c_builtins.__builtin_ceil; +pub const __builtin_ceilf = @import("std").zig.c_builtins.__builtin_ceilf; +pub const __builtin_trunc = @import("std").zig.c_builtins.__builtin_trunc; +pub const __builtin_truncf = @import("std").zig.c_builtins.__builtin_truncf; +pub const __builtin_round = @import("std").zig.c_builtins.__builtin_round; +pub const __builtin_roundf = @import("std").zig.c_builtins.__builtin_roundf; +pub const __builtin_strlen = @import("std").zig.c_builtins.__builtin_strlen; +pub const __builtin_strcmp = @import("std").zig.c_builtins.__builtin_strcmp; +pub const __builtin_object_size = @import("std").zig.c_builtins.__builtin_object_size; +pub const __builtin___memset_chk = @import("std").zig.c_builtins.__builtin___memset_chk; +pub const __builtin_memset = @import("std").zig.c_builtins.__builtin_memset; +pub const __builtin___memcpy_chk = @import("std").zig.c_builtins.__builtin___memcpy_chk; +pub const __builtin_memcpy = @import("std").zig.c_builtins.__builtin_memcpy; +pub const __builtin_expect = @import("std").zig.c_builtins.__builtin_expect; +pub const __builtin_nanf = @import("std").zig.c_builtins.__builtin_nanf; +pub const __builtin_huge_valf = @import("std").zig.c_builtins.__builtin_huge_valf; +pub const __builtin_inff = @import("std").zig.c_builtins.__builtin_inff; +pub const __builtin_isnan = @import("std").zig.c_builtins.__builtin_isnan; +pub const __builtin_isinf = @import("std").zig.c_builtins.__builtin_isinf; +pub const __builtin_isinf_sign = @import("std").zig.c_builtins.__builtin_isinf_sign; +pub const __has_builtin = @import("std").zig.c_builtins.__has_builtin; +pub const __builtin_assume = @import("std").zig.c_builtins.__builtin_assume; +pub const __builtin_unreachable = @import("std").zig.c_builtins.__builtin_unreachable; +pub const __builtin_constant_p = @import("std").zig.c_builtins.__builtin_constant_p; +pub const __builtin_mul_overflow = @import("std").zig.c_builtins.__builtin_mul_overflow; +pub const __u_char = u8; +pub const __u_short = c_ushort; +pub const __u_int = c_uint; +pub const __u_long = c_ulong; +pub const __int8_t = i8; +pub const __uint8_t = u8; +pub const __int16_t = c_short; +pub const __uint16_t = c_ushort; +pub const __int32_t = c_int; +pub const __uint32_t = c_uint; +pub const __int64_t = c_long; +pub const __uint64_t = c_ulong; +pub const __int_least8_t = __int8_t; +pub const __uint_least8_t = __uint8_t; +pub const __int_least16_t = __int16_t; +pub const __uint_least16_t = __uint16_t; +pub const __int_least32_t = __int32_t; +pub const __uint_least32_t = __uint32_t; +pub const __int_least64_t = __int64_t; +pub const __uint_least64_t = __uint64_t; +pub const __quad_t = c_long; +pub const __u_quad_t = c_ulong; +pub const __intmax_t = c_long; +pub const __uintmax_t = c_ulong; +pub const __dev_t = c_ulong; +pub const __uid_t = c_uint; +pub const __gid_t = c_uint; +pub const __ino_t = c_ulong; +pub const __ino64_t = c_ulong; +pub const __mode_t = c_uint; +pub const __nlink_t = c_ulong; +pub const __off_t = c_long; +pub const __off64_t = c_long; +pub const __pid_t = c_int; +pub const __fsid_t = extern struct { + __val: [2]c_int = @import("std").mem.zeroes([2]c_int), +}; +pub const __clock_t = c_long; +pub const __rlim_t = c_ulong; +pub const __rlim64_t = c_ulong; +pub const __id_t = c_uint; +pub const __time_t = c_long; +pub const __useconds_t = c_uint; +pub const __suseconds_t = c_long; +pub const __suseconds64_t = c_long; +pub const __daddr_t = c_int; +pub const __key_t = c_int; +pub const __clockid_t = c_int; +pub const __timer_t = ?*anyopaque; +pub const __blksize_t = c_long; +pub const __blkcnt_t = c_long; +pub const __blkcnt64_t = c_long; +pub const __fsblkcnt_t = c_ulong; +pub const __fsblkcnt64_t = c_ulong; +pub const __fsfilcnt_t = c_ulong; +pub const __fsfilcnt64_t = c_ulong; +pub const __fsword_t = c_long; +pub const __ssize_t = c_long; +pub const __syscall_slong_t = c_long; +pub const __syscall_ulong_t = c_ulong; +pub const __loff_t = __off64_t; +pub const __caddr_t = [*c]u8; +pub const __intptr_t = c_long; +pub const __socklen_t = c_uint; +pub const __sig_atomic_t = c_int; +pub const int_least8_t = __int_least8_t; +pub const int_least16_t = __int_least16_t; +pub const int_least32_t = __int_least32_t; +pub const int_least64_t = __int_least64_t; +pub const uint_least8_t = __uint_least8_t; +pub const uint_least16_t = __uint_least16_t; +pub const uint_least32_t = __uint_least32_t; +pub const uint_least64_t = __uint_least64_t; +pub const int_fast8_t = i8; +pub const int_fast16_t = c_long; +pub const int_fast32_t = c_long; +pub const int_fast64_t = c_long; +pub const uint_fast8_t = u8; +pub const uint_fast16_t = c_ulong; +pub const uint_fast32_t = c_ulong; +pub const uint_fast64_t = c_ulong; +pub const intmax_t = __intmax_t; +pub const uintmax_t = __uintmax_t; +pub const __gwchar_t = c_int; +pub const imaxdiv_t = extern struct { + quot: c_long = @import("std").mem.zeroes(c_long), + rem: c_long = @import("std").mem.zeroes(c_long), +}; +pub extern fn imaxabs(__n: intmax_t) intmax_t; +pub extern fn imaxdiv(__numer: intmax_t, __denom: intmax_t) imaxdiv_t; +pub extern fn strtoimax(noalias __nptr: [*c]const u8, noalias __endptr: [*c][*c]u8, __base: c_int) intmax_t; +pub extern fn strtoumax(noalias __nptr: [*c]const u8, noalias __endptr: [*c][*c]u8, __base: c_int) uintmax_t; +pub extern fn wcstoimax(noalias __nptr: [*c]const __gwchar_t, noalias __endptr: [*c][*c]__gwchar_t, __base: c_int) intmax_t; +pub extern fn wcstoumax(noalias __nptr: [*c]const __gwchar_t, noalias __endptr: [*c][*c]__gwchar_t, __base: c_int) uintmax_t; +pub const sig_atomic_t = __sig_atomic_t; +pub const __sigset_t = extern struct { + __val: [16]c_ulong = @import("std").mem.zeroes([16]c_ulong), +}; +pub const sigset_t = __sigset_t; +pub const pid_t = __pid_t; +pub const uid_t = __uid_t; +pub const time_t = __time_t; +pub const struct_timespec = extern struct { + tv_sec: __time_t = @import("std").mem.zeroes(__time_t), + tv_nsec: __syscall_slong_t = @import("std").mem.zeroes(__syscall_slong_t), +}; +pub const union_sigval = extern union { + sival_int: c_int, + sival_ptr: ?*anyopaque, +}; +pub const __sigval_t = union_sigval; +const struct_unnamed_2 = extern struct { + si_pid: __pid_t = @import("std").mem.zeroes(__pid_t), + si_uid: __uid_t = @import("std").mem.zeroes(__uid_t), +}; +const struct_unnamed_3 = extern struct { + si_tid: c_int = @import("std").mem.zeroes(c_int), + si_overrun: c_int = @import("std").mem.zeroes(c_int), + si_sigval: __sigval_t = @import("std").mem.zeroes(__sigval_t), +}; +const struct_unnamed_4 = extern struct { + si_pid: __pid_t = @import("std").mem.zeroes(__pid_t), + si_uid: __uid_t = @import("std").mem.zeroes(__uid_t), + si_sigval: __sigval_t = @import("std").mem.zeroes(__sigval_t), +}; +const struct_unnamed_5 = extern struct { + si_pid: __pid_t = @import("std").mem.zeroes(__pid_t), + si_uid: __uid_t = @import("std").mem.zeroes(__uid_t), + si_status: c_int = @import("std").mem.zeroes(c_int), + si_utime: __clock_t = @import("std").mem.zeroes(__clock_t), + si_stime: __clock_t = @import("std").mem.zeroes(__clock_t), +}; +const struct_unnamed_8 = extern struct { + _lower: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + _upper: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), +}; +const union_unnamed_7 = extern union { + _addr_bnd: struct_unnamed_8, + _pkey: __uint32_t, +}; +const struct_unnamed_6 = extern struct { + si_addr: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + si_addr_lsb: c_short = @import("std").mem.zeroes(c_short), + _bounds: union_unnamed_7 = @import("std").mem.zeroes(union_unnamed_7), +}; +const struct_unnamed_9 = extern struct { + si_band: c_long = @import("std").mem.zeroes(c_long), + si_fd: c_int = @import("std").mem.zeroes(c_int), +}; +const struct_unnamed_10 = extern struct { + _call_addr: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + _syscall: c_int = @import("std").mem.zeroes(c_int), + _arch: c_uint = @import("std").mem.zeroes(c_uint), +}; +const union_unnamed_1 = extern union { + _pad: [28]c_int, + _kill: struct_unnamed_2, + _timer: struct_unnamed_3, + _rt: struct_unnamed_4, + _sigchld: struct_unnamed_5, + _sigfault: struct_unnamed_6, + _sigpoll: struct_unnamed_9, + _sigsys: struct_unnamed_10, +}; +pub const siginfo_t = extern struct { + si_signo: c_int = @import("std").mem.zeroes(c_int), + si_errno: c_int = @import("std").mem.zeroes(c_int), + si_code: c_int = @import("std").mem.zeroes(c_int), + __pad0: c_int = @import("std").mem.zeroes(c_int), + _sifields: union_unnamed_1 = @import("std").mem.zeroes(union_unnamed_1), +}; +pub const SI_ASYNCNL: c_int = -60; +pub const SI_DETHREAD: c_int = -7; +pub const SI_TKILL: c_int = -6; +pub const SI_SIGIO: c_int = -5; +pub const SI_ASYNCIO: c_int = -4; +pub const SI_MESGQ: c_int = -3; +pub const SI_TIMER: c_int = -2; +pub const SI_QUEUE: c_int = -1; +pub const SI_USER: c_int = 0; +pub const SI_KERNEL: c_int = 128; +const enum_unnamed_11 = c_int; +pub const ILL_ILLOPC: c_int = 1; +pub const ILL_ILLOPN: c_int = 2; +pub const ILL_ILLADR: c_int = 3; +pub const ILL_ILLTRP: c_int = 4; +pub const ILL_PRVOPC: c_int = 5; +pub const ILL_PRVREG: c_int = 6; +pub const ILL_COPROC: c_int = 7; +pub const ILL_BADSTK: c_int = 8; +pub const ILL_BADIADDR: c_int = 9; +const enum_unnamed_12 = c_uint; +pub const FPE_INTDIV: c_int = 1; +pub const FPE_INTOVF: c_int = 2; +pub const FPE_FLTDIV: c_int = 3; +pub const FPE_FLTOVF: c_int = 4; +pub const FPE_FLTUND: c_int = 5; +pub const FPE_FLTRES: c_int = 6; +pub const FPE_FLTINV: c_int = 7; +pub const FPE_FLTSUB: c_int = 8; +pub const FPE_FLTUNK: c_int = 14; +pub const FPE_CONDTRAP: c_int = 15; +const enum_unnamed_13 = c_uint; +pub const SEGV_MAPERR: c_int = 1; +pub const SEGV_ACCERR: c_int = 2; +pub const SEGV_BNDERR: c_int = 3; +pub const SEGV_PKUERR: c_int = 4; +pub const SEGV_ACCADI: c_int = 5; +pub const SEGV_ADIDERR: c_int = 6; +pub const SEGV_ADIPERR: c_int = 7; +pub const SEGV_MTEAERR: c_int = 8; +pub const SEGV_MTESERR: c_int = 9; +pub const SEGV_CPERR: c_int = 10; +const enum_unnamed_14 = c_uint; +pub const BUS_ADRALN: c_int = 1; +pub const BUS_ADRERR: c_int = 2; +pub const BUS_OBJERR: c_int = 3; +pub const BUS_MCEERR_AR: c_int = 4; +pub const BUS_MCEERR_AO: c_int = 5; +const enum_unnamed_15 = c_uint; +pub const CLD_EXITED: c_int = 1; +pub const CLD_KILLED: c_int = 2; +pub const CLD_DUMPED: c_int = 3; +pub const CLD_TRAPPED: c_int = 4; +pub const CLD_STOPPED: c_int = 5; +pub const CLD_CONTINUED: c_int = 6; +const enum_unnamed_16 = c_uint; +pub const POLL_IN: c_int = 1; +pub const POLL_OUT: c_int = 2; +pub const POLL_MSG: c_int = 3; +pub const POLL_ERR: c_int = 4; +pub const POLL_PRI: c_int = 5; +pub const POLL_HUP: c_int = 6; +const enum_unnamed_17 = c_uint; +pub const sigval_t = __sigval_t; +pub const union_pthread_attr_t = extern union { + __size: [56]u8, + __align: c_long, +}; +pub const pthread_attr_t = union_pthread_attr_t; +const struct_unnamed_19 = extern struct { + _function: ?*const fn (__sigval_t) callconv(.c) void = @import("std").mem.zeroes(?*const fn (__sigval_t) callconv(.c) void), + _attribute: [*c]pthread_attr_t = @import("std").mem.zeroes([*c]pthread_attr_t), +}; +const union_unnamed_18 = extern union { + _pad: [12]c_int, + _tid: __pid_t, + _sigev_thread: struct_unnamed_19, +}; +pub const struct_sigevent = extern struct { + sigev_value: __sigval_t = @import("std").mem.zeroes(__sigval_t), + sigev_signo: c_int = @import("std").mem.zeroes(c_int), + sigev_notify: c_int = @import("std").mem.zeroes(c_int), + _sigev_un: union_unnamed_18 = @import("std").mem.zeroes(union_unnamed_18), +}; +pub const sigevent_t = struct_sigevent; +pub const SIGEV_SIGNAL: c_int = 0; +pub const SIGEV_NONE: c_int = 1; +pub const SIGEV_THREAD: c_int = 2; +pub const SIGEV_THREAD_ID: c_int = 4; +const enum_unnamed_20 = c_uint; +pub const __sighandler_t = ?*const fn (c_int) callconv(.c) void; +pub extern fn __sysv_signal(__sig: c_int, __handler: __sighandler_t) __sighandler_t; +pub extern fn signal(__sig: c_int, __handler: __sighandler_t) __sighandler_t; +pub extern fn kill(__pid: __pid_t, __sig: c_int) c_int; +pub extern fn killpg(__pgrp: __pid_t, __sig: c_int) c_int; +pub extern fn raise(__sig: c_int) c_int; +pub extern fn ssignal(__sig: c_int, __handler: __sighandler_t) __sighandler_t; +pub extern fn gsignal(__sig: c_int) c_int; +pub extern fn psignal(__sig: c_int, __s: [*c]const u8) void; +pub extern fn psiginfo(__pinfo: [*c]const siginfo_t, __s: [*c]const u8) void; +pub extern fn sigblock(__mask: c_int) c_int; +pub extern fn sigsetmask(__mask: c_int) c_int; +pub extern fn siggetmask() c_int; +pub const sig_t = __sighandler_t; +pub extern fn sigemptyset(__set: [*c]sigset_t) c_int; +pub extern fn sigfillset(__set: [*c]sigset_t) c_int; +pub extern fn sigaddset(__set: [*c]sigset_t, __signo: c_int) c_int; +pub extern fn sigdelset(__set: [*c]sigset_t, __signo: c_int) c_int; +pub extern fn sigismember(__set: [*c]const sigset_t, __signo: c_int) c_int; +const union_unnamed_21 = extern union { + sa_handler: __sighandler_t, + sa_sigaction: ?*const fn (c_int, [*c]siginfo_t, ?*anyopaque) callconv(.c) void, +}; +pub const struct_sigaction = extern struct { + __sigaction_handler: union_unnamed_21 = @import("std").mem.zeroes(union_unnamed_21), + sa_mask: __sigset_t = @import("std").mem.zeroes(__sigset_t), + sa_flags: c_int = @import("std").mem.zeroes(c_int), + sa_restorer: ?*const fn () callconv(.c) void = @import("std").mem.zeroes(?*const fn () callconv(.c) void), +}; +pub extern fn sigprocmask(__how: c_int, noalias __set: [*c]const sigset_t, noalias __oset: [*c]sigset_t) c_int; +pub extern fn sigsuspend(__set: [*c]const sigset_t) c_int; +pub extern fn sigaction(__sig: c_int, noalias __act: [*c]const struct_sigaction, noalias __oact: [*c]struct_sigaction) c_int; +pub extern fn sigpending(__set: [*c]sigset_t) c_int; +pub extern fn sigwait(noalias __set: [*c]const sigset_t, noalias __sig: [*c]c_int) c_int; +pub extern fn sigwaitinfo(noalias __set: [*c]const sigset_t, noalias __info: [*c]siginfo_t) c_int; +pub extern fn sigtimedwait(noalias __set: [*c]const sigset_t, noalias __info: [*c]siginfo_t, noalias __timeout: [*c]const struct_timespec) c_int; +pub extern fn sigqueue(__pid: __pid_t, __sig: c_int, __val: union_sigval) c_int; +pub const struct__fpx_sw_bytes = extern struct { + magic1: __uint32_t = @import("std").mem.zeroes(__uint32_t), + extended_size: __uint32_t = @import("std").mem.zeroes(__uint32_t), + xstate_bv: __uint64_t = @import("std").mem.zeroes(__uint64_t), + xstate_size: __uint32_t = @import("std").mem.zeroes(__uint32_t), + __glibc_reserved1: [7]__uint32_t = @import("std").mem.zeroes([7]__uint32_t), +}; +pub const struct__fpreg = extern struct { + significand: [4]c_ushort = @import("std").mem.zeroes([4]c_ushort), + exponent: c_ushort = @import("std").mem.zeroes(c_ushort), +}; +pub const struct__fpxreg = extern struct { + significand: [4]c_ushort = @import("std").mem.zeroes([4]c_ushort), + exponent: c_ushort = @import("std").mem.zeroes(c_ushort), + __glibc_reserved1: [3]c_ushort = @import("std").mem.zeroes([3]c_ushort), +}; +pub const struct__xmmreg = extern struct { + element: [4]__uint32_t = @import("std").mem.zeroes([4]__uint32_t), +}; +pub const struct__fpstate = extern struct { + cwd: __uint16_t = @import("std").mem.zeroes(__uint16_t), + swd: __uint16_t = @import("std").mem.zeroes(__uint16_t), + ftw: __uint16_t = @import("std").mem.zeroes(__uint16_t), + fop: __uint16_t = @import("std").mem.zeroes(__uint16_t), + rip: __uint64_t = @import("std").mem.zeroes(__uint64_t), + rdp: __uint64_t = @import("std").mem.zeroes(__uint64_t), + mxcsr: __uint32_t = @import("std").mem.zeroes(__uint32_t), + mxcr_mask: __uint32_t = @import("std").mem.zeroes(__uint32_t), + _st: [8]struct__fpxreg = @import("std").mem.zeroes([8]struct__fpxreg), + _xmm: [16]struct__xmmreg = @import("std").mem.zeroes([16]struct__xmmreg), + __glibc_reserved1: [24]__uint32_t = @import("std").mem.zeroes([24]__uint32_t), +}; +const union_unnamed_22 = extern union { + fpstate: [*c]struct__fpstate, + __fpstate_word: __uint64_t, +}; +pub const struct_sigcontext = extern struct { + r8: __uint64_t = @import("std").mem.zeroes(__uint64_t), + r9: __uint64_t = @import("std").mem.zeroes(__uint64_t), + r10: __uint64_t = @import("std").mem.zeroes(__uint64_t), + r11: __uint64_t = @import("std").mem.zeroes(__uint64_t), + r12: __uint64_t = @import("std").mem.zeroes(__uint64_t), + r13: __uint64_t = @import("std").mem.zeroes(__uint64_t), + r14: __uint64_t = @import("std").mem.zeroes(__uint64_t), + r15: __uint64_t = @import("std").mem.zeroes(__uint64_t), + rdi: __uint64_t = @import("std").mem.zeroes(__uint64_t), + rsi: __uint64_t = @import("std").mem.zeroes(__uint64_t), + rbp: __uint64_t = @import("std").mem.zeroes(__uint64_t), + rbx: __uint64_t = @import("std").mem.zeroes(__uint64_t), + rdx: __uint64_t = @import("std").mem.zeroes(__uint64_t), + rax: __uint64_t = @import("std").mem.zeroes(__uint64_t), + rcx: __uint64_t = @import("std").mem.zeroes(__uint64_t), + rsp: __uint64_t = @import("std").mem.zeroes(__uint64_t), + rip: __uint64_t = @import("std").mem.zeroes(__uint64_t), + eflags: __uint64_t = @import("std").mem.zeroes(__uint64_t), + cs: c_ushort = @import("std").mem.zeroes(c_ushort), + gs: c_ushort = @import("std").mem.zeroes(c_ushort), + fs: c_ushort = @import("std").mem.zeroes(c_ushort), + __pad0: c_ushort = @import("std").mem.zeroes(c_ushort), + err: __uint64_t = @import("std").mem.zeroes(__uint64_t), + trapno: __uint64_t = @import("std").mem.zeroes(__uint64_t), + oldmask: __uint64_t = @import("std").mem.zeroes(__uint64_t), + cr2: __uint64_t = @import("std").mem.zeroes(__uint64_t), + unnamed_0: union_unnamed_22 = @import("std").mem.zeroes(union_unnamed_22), + __reserved1: [8]__uint64_t = @import("std").mem.zeroes([8]__uint64_t), +}; +pub const struct__xsave_hdr = extern struct { + xstate_bv: __uint64_t = @import("std").mem.zeroes(__uint64_t), + __glibc_reserved1: [2]__uint64_t = @import("std").mem.zeroes([2]__uint64_t), + __glibc_reserved2: [5]__uint64_t = @import("std").mem.zeroes([5]__uint64_t), +}; +pub const struct__ymmh_state = extern struct { + ymmh_space: [64]__uint32_t = @import("std").mem.zeroes([64]__uint32_t), +}; +pub const struct__xstate = extern struct { + fpstate: struct__fpstate = @import("std").mem.zeroes(struct__fpstate), + xstate_hdr: struct__xsave_hdr = @import("std").mem.zeroes(struct__xsave_hdr), + ymmh: struct__ymmh_state = @import("std").mem.zeroes(struct__ymmh_state), +}; +pub extern fn sigreturn(__scp: [*c]struct_sigcontext) c_int; +pub const stack_t = extern struct { + ss_sp: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + ss_flags: c_int = @import("std").mem.zeroes(c_int), + ss_size: usize = @import("std").mem.zeroes(usize), +}; +pub const greg_t = c_longlong; +pub const gregset_t = [23]greg_t; +pub const struct__libc_fpxreg = extern struct { + significand: [4]c_ushort = @import("std").mem.zeroes([4]c_ushort), + exponent: c_ushort = @import("std").mem.zeroes(c_ushort), + __glibc_reserved1: [3]c_ushort = @import("std").mem.zeroes([3]c_ushort), +}; +pub const struct__libc_xmmreg = extern struct { + element: [4]__uint32_t = @import("std").mem.zeroes([4]__uint32_t), +}; +pub const struct__libc_fpstate = extern struct { + cwd: __uint16_t = @import("std").mem.zeroes(__uint16_t), + swd: __uint16_t = @import("std").mem.zeroes(__uint16_t), + ftw: __uint16_t = @import("std").mem.zeroes(__uint16_t), + fop: __uint16_t = @import("std").mem.zeroes(__uint16_t), + rip: __uint64_t = @import("std").mem.zeroes(__uint64_t), + rdp: __uint64_t = @import("std").mem.zeroes(__uint64_t), + mxcsr: __uint32_t = @import("std").mem.zeroes(__uint32_t), + mxcr_mask: __uint32_t = @import("std").mem.zeroes(__uint32_t), + _st: [8]struct__libc_fpxreg = @import("std").mem.zeroes([8]struct__libc_fpxreg), + _xmm: [16]struct__libc_xmmreg = @import("std").mem.zeroes([16]struct__libc_xmmreg), + __glibc_reserved1: [24]__uint32_t = @import("std").mem.zeroes([24]__uint32_t), +}; +pub const fpregset_t = [*c]struct__libc_fpstate; +pub const mcontext_t = extern struct { + gregs: gregset_t = @import("std").mem.zeroes(gregset_t), + fpregs: fpregset_t = @import("std").mem.zeroes(fpregset_t), + __reserved1: [8]c_ulonglong = @import("std").mem.zeroes([8]c_ulonglong), +}; +pub const struct_ucontext_t = extern struct { + uc_flags: c_ulong = @import("std").mem.zeroes(c_ulong), + uc_link: [*c]struct_ucontext_t = @import("std").mem.zeroes([*c]struct_ucontext_t), + uc_stack: stack_t = @import("std").mem.zeroes(stack_t), + uc_mcontext: mcontext_t = @import("std").mem.zeroes(mcontext_t), + uc_sigmask: sigset_t = @import("std").mem.zeroes(sigset_t), + __fpregs_mem: struct__libc_fpstate = @import("std").mem.zeroes(struct__libc_fpstate), + __ssp: [4]c_ulonglong = @import("std").mem.zeroes([4]c_ulonglong), +}; +pub const ucontext_t = struct_ucontext_t; +pub extern fn siginterrupt(__sig: c_int, __interrupt: c_int) c_int; +pub const SS_ONSTACK: c_int = 1; +pub const SS_DISABLE: c_int = 2; +const enum_unnamed_23 = c_uint; +pub extern fn sigaltstack(noalias __ss: [*c]const stack_t, noalias __oss: [*c]stack_t) c_int; +pub const struct_sigstack = extern struct { + ss_sp: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + ss_onstack: c_int = @import("std").mem.zeroes(c_int), +}; +pub extern fn sigstack(__ss: [*c]struct_sigstack, __oss: [*c]struct_sigstack) c_int; +const struct_unnamed_24 = extern struct { + __low: c_uint = @import("std").mem.zeroes(c_uint), + __high: c_uint = @import("std").mem.zeroes(c_uint), +}; +pub const __atomic_wide_counter = extern union { + __value64: c_ulonglong, + __value32: struct_unnamed_24, +}; +pub const struct___pthread_internal_list = extern struct { + __prev: [*c]struct___pthread_internal_list = @import("std").mem.zeroes([*c]struct___pthread_internal_list), + __next: [*c]struct___pthread_internal_list = @import("std").mem.zeroes([*c]struct___pthread_internal_list), +}; +pub const __pthread_list_t = struct___pthread_internal_list; +pub const struct___pthread_internal_slist = extern struct { + __next: [*c]struct___pthread_internal_slist = @import("std").mem.zeroes([*c]struct___pthread_internal_slist), +}; +pub const __pthread_slist_t = struct___pthread_internal_slist; +pub const struct___pthread_mutex_s = extern struct { + __lock: c_int = @import("std").mem.zeroes(c_int), + __count: c_uint = @import("std").mem.zeroes(c_uint), + __owner: c_int = @import("std").mem.zeroes(c_int), + __nusers: c_uint = @import("std").mem.zeroes(c_uint), + __kind: c_int = @import("std").mem.zeroes(c_int), + __spins: c_short = @import("std").mem.zeroes(c_short), + __elision: c_short = @import("std").mem.zeroes(c_short), + __list: __pthread_list_t = @import("std").mem.zeroes(__pthread_list_t), +}; +pub const struct___pthread_rwlock_arch_t = extern struct { + __readers: c_uint = @import("std").mem.zeroes(c_uint), + __writers: c_uint = @import("std").mem.zeroes(c_uint), + __wrphase_futex: c_uint = @import("std").mem.zeroes(c_uint), + __writers_futex: c_uint = @import("std").mem.zeroes(c_uint), + __pad3: c_uint = @import("std").mem.zeroes(c_uint), + __pad4: c_uint = @import("std").mem.zeroes(c_uint), + __cur_writer: c_int = @import("std").mem.zeroes(c_int), + __shared: c_int = @import("std").mem.zeroes(c_int), + __rwelision: i8 = @import("std").mem.zeroes(i8), + __pad1: [7]u8 = @import("std").mem.zeroes([7]u8), + __pad2: c_ulong = @import("std").mem.zeroes(c_ulong), + __flags: c_uint = @import("std").mem.zeroes(c_uint), +}; +pub const struct___pthread_cond_s = extern struct { + __wseq: __atomic_wide_counter = @import("std").mem.zeroes(__atomic_wide_counter), + __g1_start: __atomic_wide_counter = @import("std").mem.zeroes(__atomic_wide_counter), + __g_refs: [2]c_uint = @import("std").mem.zeroes([2]c_uint), + __g_size: [2]c_uint = @import("std").mem.zeroes([2]c_uint), + __g1_orig_size: c_uint = @import("std").mem.zeroes(c_uint), + __wrefs: c_uint = @import("std").mem.zeroes(c_uint), + __g_signals: [2]c_uint = @import("std").mem.zeroes([2]c_uint), +}; +pub const __tss_t = c_uint; +pub const __thrd_t = c_ulong; +pub const __once_flag = extern struct { + __data: c_int = @import("std").mem.zeroes(c_int), +}; +pub const pthread_t = c_ulong; +pub const pthread_mutexattr_t = extern union { + __size: [4]u8, + __align: c_int, +}; +pub const pthread_condattr_t = extern union { + __size: [4]u8, + __align: c_int, +}; +pub const pthread_key_t = c_uint; +pub const pthread_once_t = c_int; +pub const pthread_mutex_t = extern union { + __data: struct___pthread_mutex_s, + __size: [40]u8, + __align: c_long, +}; +pub const pthread_cond_t = extern union { + __data: struct___pthread_cond_s, + __size: [48]u8, + __align: c_longlong, +}; +pub const pthread_rwlock_t = extern union { + __data: struct___pthread_rwlock_arch_t, + __size: [56]u8, + __align: c_long, +}; +pub const pthread_rwlockattr_t = extern union { + __size: [8]u8, + __align: c_long, +}; +pub const pthread_spinlock_t = c_int; +pub const pthread_barrier_t = extern union { + __size: [32]u8, + __align: c_long, +}; +pub const pthread_barrierattr_t = extern union { + __size: [4]u8, + __align: c_int, +}; +pub extern fn pthread_sigmask(__how: c_int, noalias __newmask: [*c]const __sigset_t, noalias __oldmask: [*c]__sigset_t) c_int; +pub extern fn pthread_kill(__threadid: pthread_t, __signo: c_int) c_int; +pub extern fn __libc_current_sigrtmin() c_int; +pub extern fn __libc_current_sigrtmax() c_int; +pub const wchar_t = c_int; +pub const _Float32 = f32; +pub const _Float64 = f64; +pub const _Float32x = f64; +pub const _Float64x = c_longdouble; +pub const div_t = extern struct { + quot: c_int = @import("std").mem.zeroes(c_int), + rem: c_int = @import("std").mem.zeroes(c_int), +}; +pub const ldiv_t = extern struct { + quot: c_long = @import("std").mem.zeroes(c_long), + rem: c_long = @import("std").mem.zeroes(c_long), +}; +pub const lldiv_t = extern struct { + quot: c_longlong = @import("std").mem.zeroes(c_longlong), + rem: c_longlong = @import("std").mem.zeroes(c_longlong), +}; +pub extern fn __ctype_get_mb_cur_max() usize; +pub extern fn atof(__nptr: [*c]const u8) f64; +pub extern fn atoi(__nptr: [*c]const u8) c_int; +pub extern fn atol(__nptr: [*c]const u8) c_long; +pub extern fn atoll(__nptr: [*c]const u8) c_longlong; +pub extern fn strtod(__nptr: [*c]const u8, __endptr: [*c][*c]u8) f64; +pub extern fn strtof(__nptr: [*c]const u8, __endptr: [*c][*c]u8) f32; +pub extern fn strtold(__nptr: [*c]const u8, __endptr: [*c][*c]u8) c_longdouble; +pub extern fn strtol(__nptr: [*c]const u8, __endptr: [*c][*c]u8, __base: c_int) c_long; +pub extern fn strtoul(__nptr: [*c]const u8, __endptr: [*c][*c]u8, __base: c_int) c_ulong; +pub extern fn strtoq(noalias __nptr: [*c]const u8, noalias __endptr: [*c][*c]u8, __base: c_int) c_longlong; +pub extern fn strtouq(noalias __nptr: [*c]const u8, noalias __endptr: [*c][*c]u8, __base: c_int) c_ulonglong; +pub extern fn strtoll(__nptr: [*c]const u8, __endptr: [*c][*c]u8, __base: c_int) c_longlong; +pub extern fn strtoull(__nptr: [*c]const u8, __endptr: [*c][*c]u8, __base: c_int) c_ulonglong; +pub extern fn l64a(__n: c_long) [*c]u8; +pub extern fn a64l(__s: [*c]const u8) c_long; +pub const u_char = __u_char; +pub const u_short = __u_short; +pub const u_int = __u_int; +pub const u_long = __u_long; +pub const quad_t = __quad_t; +pub const u_quad_t = __u_quad_t; +pub const fsid_t = __fsid_t; +pub const loff_t = __loff_t; +pub const ino_t = __ino_t; +pub const dev_t = __dev_t; +pub const gid_t = __gid_t; +pub const mode_t = __mode_t; +pub const nlink_t = __nlink_t; +pub const off_t = __off_t; +pub const id_t = __id_t; +pub const daddr_t = __daddr_t; +pub const caddr_t = __caddr_t; +pub const key_t = __key_t; +pub const clock_t = __clock_t; +pub const clockid_t = __clockid_t; +pub const timer_t = __timer_t; +pub const ulong = c_ulong; +pub const ushort = c_ushort; +pub const uint = c_uint; +pub const u_int8_t = __uint8_t; +pub const u_int16_t = __uint16_t; +pub const u_int32_t = __uint32_t; +pub const u_int64_t = __uint64_t; +pub const register_t = c_long; +pub fn __bswap_16(arg___bsx: __uint16_t) callconv(.c) __uint16_t { + var __bsx = arg___bsx; + _ = &__bsx; + return @as(__uint16_t, @bitCast(@as(c_short, @truncate(((@as(c_int, @bitCast(@as(c_uint, __bsx))) >> @intCast(8)) & @as(c_int, 255)) | ((@as(c_int, @bitCast(@as(c_uint, __bsx))) & @as(c_int, 255)) << @intCast(8)))))); +} +pub fn __bswap_32(arg___bsx: __uint32_t) callconv(.c) __uint32_t { + var __bsx = arg___bsx; + _ = &__bsx; + return ((((__bsx & @as(c_uint, 4278190080)) >> @intCast(24)) | ((__bsx & @as(c_uint, 16711680)) >> @intCast(8))) | ((__bsx & @as(c_uint, 65280)) << @intCast(8))) | ((__bsx & @as(c_uint, 255)) << @intCast(24)); +} +pub fn __bswap_64(arg___bsx: __uint64_t) callconv(.c) __uint64_t { + var __bsx = arg___bsx; + _ = &__bsx; + return @as(__uint64_t, @bitCast(@as(c_ulong, @truncate(((((((((@as(c_ulonglong, @bitCast(@as(c_ulonglong, __bsx))) & @as(c_ulonglong, 18374686479671623680)) >> @intCast(56)) | ((@as(c_ulonglong, @bitCast(@as(c_ulonglong, __bsx))) & @as(c_ulonglong, 71776119061217280)) >> @intCast(40))) | ((@as(c_ulonglong, @bitCast(@as(c_ulonglong, __bsx))) & @as(c_ulonglong, 280375465082880)) >> @intCast(24))) | ((@as(c_ulonglong, @bitCast(@as(c_ulonglong, __bsx))) & @as(c_ulonglong, 1095216660480)) >> @intCast(8))) | ((@as(c_ulonglong, @bitCast(@as(c_ulonglong, __bsx))) & @as(c_ulonglong, 4278190080)) << @intCast(8))) | ((@as(c_ulonglong, @bitCast(@as(c_ulonglong, __bsx))) & @as(c_ulonglong, 16711680)) << @intCast(24))) | ((@as(c_ulonglong, @bitCast(@as(c_ulonglong, __bsx))) & @as(c_ulonglong, 65280)) << @intCast(40))) | ((@as(c_ulonglong, @bitCast(@as(c_ulonglong, __bsx))) & @as(c_ulonglong, 255)) << @intCast(56)))))); +} +pub fn __uint16_identity(arg___x: __uint16_t) callconv(.c) __uint16_t { + var __x = arg___x; + _ = &__x; + return __x; +} +pub fn __uint32_identity(arg___x: __uint32_t) callconv(.c) __uint32_t { + var __x = arg___x; + _ = &__x; + return __x; +} +pub fn __uint64_identity(arg___x: __uint64_t) callconv(.c) __uint64_t { + var __x = arg___x; + _ = &__x; + return __x; +} +pub const struct_timeval = extern struct { + tv_sec: __time_t = @import("std").mem.zeroes(__time_t), + tv_usec: __suseconds_t = @import("std").mem.zeroes(__suseconds_t), +}; +pub const suseconds_t = __suseconds_t; +pub const __fd_mask = c_long; +pub const fd_set = extern struct { + __fds_bits: [16]__fd_mask = @import("std").mem.zeroes([16]__fd_mask), +}; +pub const fd_mask = __fd_mask; +pub extern fn select(__nfds: c_int, noalias __readfds: [*c]fd_set, noalias __writefds: [*c]fd_set, noalias __exceptfds: [*c]fd_set, noalias __timeout: [*c]struct_timeval) c_int; +pub extern fn pselect(__nfds: c_int, noalias __readfds: [*c]fd_set, noalias __writefds: [*c]fd_set, noalias __exceptfds: [*c]fd_set, noalias __timeout: [*c]const struct_timespec, noalias __sigmask: [*c]const __sigset_t) c_int; +pub const blksize_t = __blksize_t; +pub const blkcnt_t = __blkcnt_t; +pub const fsblkcnt_t = __fsblkcnt_t; +pub const fsfilcnt_t = __fsfilcnt_t; +pub extern fn random() c_long; +pub extern fn srandom(__seed: c_uint) void; +pub extern fn initstate(__seed: c_uint, __statebuf: [*c]u8, __statelen: usize) [*c]u8; +pub extern fn setstate(__statebuf: [*c]u8) [*c]u8; +pub const struct_random_data = extern struct { + fptr: [*c]i32 = @import("std").mem.zeroes([*c]i32), + rptr: [*c]i32 = @import("std").mem.zeroes([*c]i32), + state: [*c]i32 = @import("std").mem.zeroes([*c]i32), + rand_type: c_int = @import("std").mem.zeroes(c_int), + rand_deg: c_int = @import("std").mem.zeroes(c_int), + rand_sep: c_int = @import("std").mem.zeroes(c_int), + end_ptr: [*c]i32 = @import("std").mem.zeroes([*c]i32), +}; +pub extern fn random_r(noalias __buf: [*c]struct_random_data, noalias __result: [*c]i32) c_int; +pub extern fn srandom_r(__seed: c_uint, __buf: [*c]struct_random_data) c_int; +pub extern fn initstate_r(__seed: c_uint, noalias __statebuf: [*c]u8, __statelen: usize, noalias __buf: [*c]struct_random_data) c_int; +pub extern fn setstate_r(noalias __statebuf: [*c]u8, noalias __buf: [*c]struct_random_data) c_int; +pub extern fn rand() c_int; +pub extern fn srand(__seed: c_uint) void; +pub extern fn rand_r(__seed: [*c]c_uint) c_int; +pub extern fn drand48() f64; +pub extern fn erand48(__xsubi: [*c]c_ushort) f64; +pub extern fn lrand48() c_long; +pub extern fn nrand48(__xsubi: [*c]c_ushort) c_long; +pub extern fn mrand48() c_long; +pub extern fn jrand48(__xsubi: [*c]c_ushort) c_long; +pub extern fn srand48(__seedval: c_long) void; +pub extern fn seed48(__seed16v: [*c]c_ushort) [*c]c_ushort; +pub extern fn lcong48(__param: [*c]c_ushort) void; +pub const struct_drand48_data = extern struct { + __x: [3]c_ushort = @import("std").mem.zeroes([3]c_ushort), + __old_x: [3]c_ushort = @import("std").mem.zeroes([3]c_ushort), + __c: c_ushort = @import("std").mem.zeroes(c_ushort), + __init: c_ushort = @import("std").mem.zeroes(c_ushort), + __a: c_ulonglong = @import("std").mem.zeroes(c_ulonglong), +}; +pub extern fn drand48_r(noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]f64) c_int; +pub extern fn erand48_r(__xsubi: [*c]c_ushort, noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]f64) c_int; +pub extern fn lrand48_r(noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]c_long) c_int; +pub extern fn nrand48_r(__xsubi: [*c]c_ushort, noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]c_long) c_int; +pub extern fn mrand48_r(noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]c_long) c_int; +pub extern fn jrand48_r(__xsubi: [*c]c_ushort, noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]c_long) c_int; +pub extern fn srand48_r(__seedval: c_long, __buffer: [*c]struct_drand48_data) c_int; +pub extern fn seed48_r(__seed16v: [*c]c_ushort, __buffer: [*c]struct_drand48_data) c_int; +pub extern fn lcong48_r(__param: [*c]c_ushort, __buffer: [*c]struct_drand48_data) c_int; +pub extern fn arc4random() __uint32_t; +pub extern fn arc4random_buf(__buf: ?*anyopaque, __size: usize) void; +pub extern fn arc4random_uniform(__upper_bound: __uint32_t) __uint32_t; +pub extern fn malloc(__size: c_ulong) ?*anyopaque; +pub extern fn calloc(__nmemb: c_ulong, __size: c_ulong) ?*anyopaque; +pub extern fn realloc(__ptr: ?*anyopaque, __size: c_ulong) ?*anyopaque; +pub extern fn free(__ptr: ?*anyopaque) void; +pub extern fn reallocarray(__ptr: ?*anyopaque, __nmemb: usize, __size: usize) ?*anyopaque; +pub extern fn alloca(__size: c_ulong) ?*anyopaque; +pub extern fn valloc(__size: usize) ?*anyopaque; +pub extern fn posix_memalign(__memptr: [*c]?*anyopaque, __alignment: usize, __size: usize) c_int; +pub extern fn aligned_alloc(__alignment: c_ulong, __size: c_ulong) ?*anyopaque; +pub extern fn abort() noreturn; +pub extern fn atexit(__func: ?*const fn () callconv(.c) void) c_int; +pub extern fn at_quick_exit(__func: ?*const fn () callconv(.c) void) c_int; +pub extern fn on_exit(__func: ?*const fn (c_int, ?*anyopaque) callconv(.c) void, __arg: ?*anyopaque) c_int; +pub extern fn exit(__status: c_int) noreturn; +pub extern fn quick_exit(__status: c_int) noreturn; +pub extern fn _Exit(__status: c_int) noreturn; +pub extern fn getenv(__name: [*c]const u8) [*c]u8; +pub extern fn putenv(__string: [*c]u8) c_int; +pub extern fn setenv(__name: [*c]const u8, __value: [*c]const u8, __replace: c_int) c_int; +pub extern fn unsetenv(__name: [*c]const u8) c_int; +pub extern fn clearenv() c_int; +pub extern fn mktemp(__template: [*c]u8) [*c]u8; +pub extern fn mkstemp(__template: [*c]u8) c_int; +pub extern fn mkstemps(__template: [*c]u8, __suffixlen: c_int) c_int; +pub extern fn mkdtemp(__template: [*c]u8) [*c]u8; +pub extern fn system(__command: [*c]const u8) c_int; +pub extern fn realpath(noalias __name: [*c]const u8, noalias __resolved: [*c]u8) [*c]u8; +pub const __compar_fn_t = ?*const fn (?*const anyopaque, ?*const anyopaque) callconv(.c) c_int; +pub extern fn bsearch(__key: ?*const anyopaque, __base: ?*const anyopaque, __nmemb: usize, __size: usize, __compar: __compar_fn_t) ?*anyopaque; +pub extern fn qsort(__base: ?*anyopaque, __nmemb: usize, __size: usize, __compar: __compar_fn_t) void; +pub extern fn abs(__x: c_int) c_int; +pub extern fn labs(__x: c_long) c_long; +pub extern fn llabs(__x: c_longlong) c_longlong; +pub extern fn div(__numer: c_int, __denom: c_int) div_t; +pub extern fn ldiv(__numer: c_long, __denom: c_long) ldiv_t; +pub extern fn lldiv(__numer: c_longlong, __denom: c_longlong) lldiv_t; +pub extern fn ecvt(__value: f64, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int) [*c]u8; +pub extern fn fcvt(__value: f64, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int) [*c]u8; +pub extern fn gcvt(__value: f64, __ndigit: c_int, __buf: [*c]u8) [*c]u8; +pub extern fn qecvt(__value: c_longdouble, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int) [*c]u8; +pub extern fn qfcvt(__value: c_longdouble, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int) [*c]u8; +pub extern fn qgcvt(__value: c_longdouble, __ndigit: c_int, __buf: [*c]u8) [*c]u8; +pub extern fn ecvt_r(__value: f64, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int, noalias __buf: [*c]u8, __len: usize) c_int; +pub extern fn fcvt_r(__value: f64, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int, noalias __buf: [*c]u8, __len: usize) c_int; +pub extern fn qecvt_r(__value: c_longdouble, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int, noalias __buf: [*c]u8, __len: usize) c_int; +pub extern fn qfcvt_r(__value: c_longdouble, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int, noalias __buf: [*c]u8, __len: usize) c_int; +pub extern fn mblen(__s: [*c]const u8, __n: usize) c_int; +pub extern fn mbtowc(noalias __pwc: [*c]wchar_t, noalias __s: [*c]const u8, __n: usize) c_int; +pub extern fn wctomb(__s: [*c]u8, __wchar: wchar_t) c_int; +pub extern fn mbstowcs(noalias __pwcs: [*c]wchar_t, noalias __s: [*c]const u8, __n: usize) usize; +pub extern fn wcstombs(noalias __s: [*c]u8, noalias __pwcs: [*c]const wchar_t, __n: usize) usize; +pub extern fn rpmatch(__response: [*c]const u8) c_int; +pub extern fn getsubopt(noalias __optionp: [*c][*c]u8, noalias __tokens: [*c]const [*c]u8, noalias __valuep: [*c][*c]u8) c_int; +pub extern fn getloadavg(__loadavg: [*c]f64, __nelem: c_int) c_int; +pub extern fn memcpy(__dest: ?*anyopaque, __src: ?*const anyopaque, __n: c_ulong) ?*anyopaque; +pub extern fn memmove(__dest: ?*anyopaque, __src: ?*const anyopaque, __n: c_ulong) ?*anyopaque; +pub extern fn memccpy(__dest: ?*anyopaque, __src: ?*const anyopaque, __c: c_int, __n: c_ulong) ?*anyopaque; +pub extern fn memset(__s: ?*anyopaque, __c: c_int, __n: c_ulong) ?*anyopaque; +pub extern fn memcmp(__s1: ?*const anyopaque, __s2: ?*const anyopaque, __n: c_ulong) c_int; +pub extern fn __memcmpeq(__s1: ?*const anyopaque, __s2: ?*const anyopaque, __n: usize) c_int; +pub extern fn memchr(__s: ?*const anyopaque, __c: c_int, __n: c_ulong) ?*anyopaque; +pub extern fn strcpy(__dest: [*c]u8, __src: [*c]const u8) [*c]u8; +pub extern fn strncpy(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) [*c]u8; +pub extern fn strcat(__dest: [*c]u8, __src: [*c]const u8) [*c]u8; +pub extern fn strncat(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) [*c]u8; +pub extern fn strcmp(__s1: [*c]const u8, __s2: [*c]const u8) c_int; +pub extern fn strncmp(__s1: [*c]const u8, __s2: [*c]const u8, __n: c_ulong) c_int; +pub extern fn strcoll(__s1: [*c]const u8, __s2: [*c]const u8) c_int; +pub extern fn strxfrm(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) c_ulong; +pub const struct___locale_data_25 = opaque {}; +pub const struct___locale_struct = extern struct { + __locales: [13]?*struct___locale_data_25 = @import("std").mem.zeroes([13]?*struct___locale_data_25), + __ctype_b: [*c]const c_ushort = @import("std").mem.zeroes([*c]const c_ushort), + __ctype_tolower: [*c]const c_int = @import("std").mem.zeroes([*c]const c_int), + __ctype_toupper: [*c]const c_int = @import("std").mem.zeroes([*c]const c_int), + __names: [13][*c]const u8 = @import("std").mem.zeroes([13][*c]const u8), +}; +pub const __locale_t = [*c]struct___locale_struct; +pub const locale_t = __locale_t; +pub extern fn strcoll_l(__s1: [*c]const u8, __s2: [*c]const u8, __l: locale_t) c_int; +pub extern fn strxfrm_l(__dest: [*c]u8, __src: [*c]const u8, __n: usize, __l: locale_t) usize; +pub extern fn strdup(__s: [*c]const u8) [*c]u8; +pub extern fn strndup(__string: [*c]const u8, __n: c_ulong) [*c]u8; +pub extern fn strchr(__s: [*c]const u8, __c: c_int) [*c]u8; +pub extern fn strrchr(__s: [*c]const u8, __c: c_int) [*c]u8; +pub extern fn strchrnul(__s: [*c]const u8, __c: c_int) [*c]u8; +pub extern fn strcspn(__s: [*c]const u8, __reject: [*c]const u8) c_ulong; +pub extern fn strspn(__s: [*c]const u8, __accept: [*c]const u8) c_ulong; +pub extern fn strpbrk(__s: [*c]const u8, __accept: [*c]const u8) [*c]u8; +pub extern fn strstr(__haystack: [*c]const u8, __needle: [*c]const u8) [*c]u8; +pub extern fn strtok(__s: [*c]u8, __delim: [*c]const u8) [*c]u8; +pub extern fn __strtok_r(noalias __s: [*c]u8, noalias __delim: [*c]const u8, noalias __save_ptr: [*c][*c]u8) [*c]u8; +pub extern fn strtok_r(noalias __s: [*c]u8, noalias __delim: [*c]const u8, noalias __save_ptr: [*c][*c]u8) [*c]u8; +pub extern fn strcasestr(__haystack: [*c]const u8, __needle: [*c]const u8) [*c]u8; +pub extern fn memmem(__haystack: ?*const anyopaque, __haystacklen: usize, __needle: ?*const anyopaque, __needlelen: usize) ?*anyopaque; +pub extern fn __mempcpy(noalias __dest: ?*anyopaque, noalias __src: ?*const anyopaque, __n: usize) ?*anyopaque; +pub extern fn mempcpy(__dest: ?*anyopaque, __src: ?*const anyopaque, __n: c_ulong) ?*anyopaque; +pub extern fn strlen(__s: [*c]const u8) c_ulong; +pub extern fn strnlen(__string: [*c]const u8, __maxlen: usize) usize; +pub extern fn strerror(__errnum: c_int) [*c]u8; +pub extern fn strerror_r(__errnum: c_int, __buf: [*c]u8, __buflen: usize) c_int; +pub extern fn strerror_l(__errnum: c_int, __l: locale_t) [*c]u8; +pub extern fn bcmp(__s1: ?*const anyopaque, __s2: ?*const anyopaque, __n: c_ulong) c_int; +pub extern fn bcopy(__src: ?*const anyopaque, __dest: ?*anyopaque, __n: c_ulong) void; +pub extern fn bzero(__s: ?*anyopaque, __n: c_ulong) void; +pub extern fn index(__s: [*c]const u8, __c: c_int) [*c]u8; +pub extern fn rindex(__s: [*c]const u8, __c: c_int) [*c]u8; +pub extern fn ffs(__i: c_int) c_int; +pub extern fn ffsl(__l: c_long) c_int; +pub extern fn ffsll(__ll: c_longlong) c_int; +pub extern fn strcasecmp(__s1: [*c]const u8, __s2: [*c]const u8) c_int; +pub extern fn strncasecmp(__s1: [*c]const u8, __s2: [*c]const u8, __n: c_ulong) c_int; +pub extern fn strcasecmp_l(__s1: [*c]const u8, __s2: [*c]const u8, __loc: locale_t) c_int; +pub extern fn strncasecmp_l(__s1: [*c]const u8, __s2: [*c]const u8, __n: usize, __loc: locale_t) c_int; +pub extern fn explicit_bzero(__s: ?*anyopaque, __n: usize) void; +pub extern fn strsep(noalias __stringp: [*c][*c]u8, noalias __delim: [*c]const u8) [*c]u8; +pub extern fn strsignal(__sig: c_int) [*c]u8; +pub extern fn __stpcpy(noalias __dest: [*c]u8, noalias __src: [*c]const u8) [*c]u8; +pub extern fn stpcpy(__dest: [*c]u8, __src: [*c]const u8) [*c]u8; +pub extern fn __stpncpy(noalias __dest: [*c]u8, noalias __src: [*c]const u8, __n: usize) [*c]u8; +pub extern fn stpncpy(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) [*c]u8; +pub extern fn strlcpy(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) c_ulong; +pub extern fn strlcat(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) c_ulong; +pub const ptrdiff_t = c_long; +pub const max_align_t = extern struct { + __clang_max_align_nonce1: c_longlong align(8) = @import("std").mem.zeroes(c_longlong), + __clang_max_align_nonce2: c_longdouble align(16) = @import("std").mem.zeroes(c_longdouble), +}; +pub const struct___va_list_tag_26 = extern struct { + gp_offset: c_uint = @import("std").mem.zeroes(c_uint), + fp_offset: c_uint = @import("std").mem.zeroes(c_uint), + overflow_arg_area: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + reg_save_area: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), +}; +pub const __builtin_va_list = [1]struct___va_list_tag_26; +pub const __gnuc_va_list = __builtin_va_list; +const union_unnamed_27 = extern union { + __wch: c_uint, + __wchb: [4]u8, +}; +pub const __mbstate_t = extern struct { + __count: c_int = @import("std").mem.zeroes(c_int), + __value: union_unnamed_27 = @import("std").mem.zeroes(union_unnamed_27), +}; +pub const struct__G_fpos_t = extern struct { + __pos: __off_t = @import("std").mem.zeroes(__off_t), + __state: __mbstate_t = @import("std").mem.zeroes(__mbstate_t), +}; +pub const __fpos_t = struct__G_fpos_t; +pub const struct__G_fpos64_t = extern struct { + __pos: __off64_t = @import("std").mem.zeroes(__off64_t), + __state: __mbstate_t = @import("std").mem.zeroes(__mbstate_t), +}; +pub const __fpos64_t = struct__G_fpos64_t; +pub const struct__IO_marker = opaque {}; +pub const _IO_lock_t = anyopaque; +pub const struct__IO_codecvt = opaque {}; +pub const struct__IO_wide_data = opaque {}; +pub const struct__IO_FILE = extern struct { + _flags: c_int = @import("std").mem.zeroes(c_int), + _IO_read_ptr: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_read_end: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_read_base: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_write_base: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_write_ptr: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_write_end: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_buf_base: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_buf_end: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_save_base: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_backup_base: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _IO_save_end: [*c]u8 = @import("std").mem.zeroes([*c]u8), + _markers: ?*struct__IO_marker = @import("std").mem.zeroes(?*struct__IO_marker), + _chain: [*c]struct__IO_FILE = @import("std").mem.zeroes([*c]struct__IO_FILE), + _fileno: c_int = @import("std").mem.zeroes(c_int), + _flags2: c_int = @import("std").mem.zeroes(c_int), + _old_offset: __off_t = @import("std").mem.zeroes(__off_t), + _cur_column: c_ushort = @import("std").mem.zeroes(c_ushort), + _vtable_offset: i8 = @import("std").mem.zeroes(i8), + _shortbuf: [1]u8 = @import("std").mem.zeroes([1]u8), + _lock: ?*_IO_lock_t = @import("std").mem.zeroes(?*_IO_lock_t), + _offset: __off64_t = @import("std").mem.zeroes(__off64_t), + _codecvt: ?*struct__IO_codecvt = @import("std").mem.zeroes(?*struct__IO_codecvt), + _wide_data: ?*struct__IO_wide_data = @import("std").mem.zeroes(?*struct__IO_wide_data), + _freeres_list: [*c]struct__IO_FILE = @import("std").mem.zeroes([*c]struct__IO_FILE), + _freeres_buf: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + _prevchain: [*c][*c]struct__IO_FILE = @import("std").mem.zeroes([*c][*c]struct__IO_FILE), + _mode: c_int = @import("std").mem.zeroes(c_int), + _unused2: [20]u8 = @import("std").mem.zeroes([20]u8), +}; +pub const __FILE = struct__IO_FILE; +pub const FILE = struct__IO_FILE; +pub const cookie_read_function_t = fn (?*anyopaque, [*c]u8, usize) callconv(.c) __ssize_t; +pub const cookie_write_function_t = fn (?*anyopaque, [*c]const u8, usize) callconv(.c) __ssize_t; +pub const cookie_seek_function_t = fn (?*anyopaque, [*c]__off64_t, c_int) callconv(.c) c_int; +pub const cookie_close_function_t = fn (?*anyopaque) callconv(.c) c_int; +pub const struct__IO_cookie_io_functions_t = extern struct { + read: ?*const cookie_read_function_t = @import("std").mem.zeroes(?*const cookie_read_function_t), + write: ?*const cookie_write_function_t = @import("std").mem.zeroes(?*const cookie_write_function_t), + seek: ?*const cookie_seek_function_t = @import("std").mem.zeroes(?*const cookie_seek_function_t), + close: ?*const cookie_close_function_t = @import("std").mem.zeroes(?*const cookie_close_function_t), +}; +pub const cookie_io_functions_t = struct__IO_cookie_io_functions_t; +pub const va_list = __gnuc_va_list; +pub const fpos_t = __fpos_t; +pub extern var stdin: [*c]FILE; +pub extern var stdout: [*c]FILE; +pub extern var stderr: [*c]FILE; +pub extern fn remove(__filename: [*c]const u8) c_int; +pub extern fn rename(__old: [*c]const u8, __new: [*c]const u8) c_int; +pub extern fn renameat(__oldfd: c_int, __old: [*c]const u8, __newfd: c_int, __new: [*c]const u8) c_int; +pub extern fn fclose(__stream: [*c]FILE) c_int; +pub extern fn tmpfile() [*c]FILE; +pub extern fn tmpnam([*c]u8) [*c]u8; +pub extern fn tmpnam_r(__s: [*c]u8) [*c]u8; +pub extern fn tempnam(__dir: [*c]const u8, __pfx: [*c]const u8) [*c]u8; +pub extern fn fflush(__stream: [*c]FILE) c_int; +pub extern fn fflush_unlocked(__stream: [*c]FILE) c_int; +pub extern fn fopen(__filename: [*c]const u8, __modes: [*c]const u8) [*c]FILE; +pub extern fn freopen(noalias __filename: [*c]const u8, noalias __modes: [*c]const u8, noalias __stream: [*c]FILE) [*c]FILE; +pub extern fn fdopen(__fd: c_int, __modes: [*c]const u8) [*c]FILE; +pub extern fn fopencookie(noalias __magic_cookie: ?*anyopaque, noalias __modes: [*c]const u8, __io_funcs: cookie_io_functions_t) [*c]FILE; +pub extern fn fmemopen(__s: ?*anyopaque, __len: usize, __modes: [*c]const u8) [*c]FILE; +pub extern fn open_memstream(__bufloc: [*c][*c]u8, __sizeloc: [*c]usize) [*c]FILE; +pub extern fn setbuf(noalias __stream: [*c]FILE, noalias __buf: [*c]u8) void; +pub extern fn setvbuf(noalias __stream: [*c]FILE, noalias __buf: [*c]u8, __modes: c_int, __n: usize) c_int; +pub extern fn setbuffer(noalias __stream: [*c]FILE, noalias __buf: [*c]u8, __size: usize) void; +pub extern fn setlinebuf(__stream: [*c]FILE) void; +pub extern fn fprintf(noalias __stream: [*c]FILE, noalias __format: [*c]const u8, ...) c_int; +pub extern fn printf(__format: [*c]const u8, ...) c_int; +pub extern fn sprintf(noalias __s: [*c]u8, noalias __format: [*c]const u8, ...) c_int; +pub extern fn vfprintf(noalias __s: [*c]FILE, noalias __format: [*c]const u8, __arg: [*c]struct___va_list_tag_26) c_int; +pub extern fn vprintf(noalias __format: [*c]const u8, __arg: [*c]struct___va_list_tag_26) c_int; +pub extern fn vsprintf(noalias __s: [*c]u8, noalias __format: [*c]const u8, __arg: [*c]struct___va_list_tag_26) c_int; +pub extern fn snprintf(noalias __s: [*c]u8, __maxlen: c_ulong, noalias __format: [*c]const u8, ...) c_int; +pub extern fn vsnprintf(noalias __s: [*c]u8, __maxlen: c_ulong, noalias __format: [*c]const u8, __arg: [*c]struct___va_list_tag_26) c_int; +pub extern fn vasprintf(noalias __ptr: [*c][*c]u8, noalias __f: [*c]const u8, __arg: [*c]struct___va_list_tag_26) c_int; +pub extern fn __asprintf(noalias __ptr: [*c][*c]u8, noalias __fmt: [*c]const u8, ...) c_int; +pub extern fn asprintf(noalias __ptr: [*c][*c]u8, noalias __fmt: [*c]const u8, ...) c_int; +pub extern fn vdprintf(__fd: c_int, noalias __fmt: [*c]const u8, __arg: [*c]struct___va_list_tag_26) c_int; +pub extern fn dprintf(__fd: c_int, noalias __fmt: [*c]const u8, ...) c_int; +pub extern fn fscanf(noalias __stream: [*c]FILE, noalias __format: [*c]const u8, ...) c_int; +pub extern fn scanf(noalias __format: [*c]const u8, ...) c_int; +pub extern fn sscanf(noalias __s: [*c]const u8, noalias __format: [*c]const u8, ...) c_int; +pub extern fn vfscanf(noalias __s: [*c]FILE, noalias __format: [*c]const u8, __arg: [*c]struct___va_list_tag_26) c_int; +pub extern fn vscanf(noalias __format: [*c]const u8, __arg: [*c]struct___va_list_tag_26) c_int; +pub extern fn vsscanf(noalias __s: [*c]const u8, noalias __format: [*c]const u8, __arg: [*c]struct___va_list_tag_26) c_int; +pub extern fn fgetc(__stream: [*c]FILE) c_int; +pub extern fn getc(__stream: [*c]FILE) c_int; +pub extern fn getchar() c_int; +pub extern fn getc_unlocked(__stream: [*c]FILE) c_int; +pub extern fn getchar_unlocked() c_int; +pub extern fn fgetc_unlocked(__stream: [*c]FILE) c_int; +pub extern fn fputc(__c: c_int, __stream: [*c]FILE) c_int; +pub extern fn putc(__c: c_int, __stream: [*c]FILE) c_int; +pub extern fn putchar(__c: c_int) c_int; +pub extern fn fputc_unlocked(__c: c_int, __stream: [*c]FILE) c_int; +pub extern fn putc_unlocked(__c: c_int, __stream: [*c]FILE) c_int; +pub extern fn putchar_unlocked(__c: c_int) c_int; +pub extern fn getw(__stream: [*c]FILE) c_int; +pub extern fn putw(__w: c_int, __stream: [*c]FILE) c_int; +pub extern fn fgets(noalias __s: [*c]u8, __n: c_int, noalias __stream: [*c]FILE) [*c]u8; +pub extern fn __getdelim(noalias __lineptr: [*c][*c]u8, noalias __n: [*c]usize, __delimiter: c_int, noalias __stream: [*c]FILE) __ssize_t; +pub extern fn getdelim(noalias __lineptr: [*c][*c]u8, noalias __n: [*c]usize, __delimiter: c_int, noalias __stream: [*c]FILE) __ssize_t; +pub extern fn getline(noalias __lineptr: [*c][*c]u8, noalias __n: [*c]usize, noalias __stream: [*c]FILE) __ssize_t; +pub extern fn fputs(noalias __s: [*c]const u8, noalias __stream: [*c]FILE) c_int; +pub extern fn puts(__s: [*c]const u8) c_int; +pub extern fn ungetc(__c: c_int, __stream: [*c]FILE) c_int; +pub extern fn fread(__ptr: ?*anyopaque, __size: c_ulong, __n: c_ulong, __stream: [*c]FILE) c_ulong; +pub extern fn fwrite(__ptr: ?*const anyopaque, __size: c_ulong, __n: c_ulong, __s: [*c]FILE) c_ulong; +pub extern fn fread_unlocked(noalias __ptr: ?*anyopaque, __size: usize, __n: usize, noalias __stream: [*c]FILE) usize; +pub extern fn fwrite_unlocked(noalias __ptr: ?*const anyopaque, __size: usize, __n: usize, noalias __stream: [*c]FILE) usize; +pub extern fn fseek(__stream: [*c]FILE, __off: c_long, __whence: c_int) c_int; +pub extern fn ftell(__stream: [*c]FILE) c_long; +pub extern fn rewind(__stream: [*c]FILE) void; +pub extern fn fseeko(__stream: [*c]FILE, __off: __off_t, __whence: c_int) c_int; +pub extern fn ftello(__stream: [*c]FILE) __off_t; +pub extern fn fgetpos(noalias __stream: [*c]FILE, noalias __pos: [*c]fpos_t) c_int; +pub extern fn fsetpos(__stream: [*c]FILE, __pos: [*c]const fpos_t) c_int; +pub extern fn clearerr(__stream: [*c]FILE) void; +pub extern fn feof(__stream: [*c]FILE) c_int; +pub extern fn ferror(__stream: [*c]FILE) c_int; +pub extern fn clearerr_unlocked(__stream: [*c]FILE) void; +pub extern fn feof_unlocked(__stream: [*c]FILE) c_int; +pub extern fn ferror_unlocked(__stream: [*c]FILE) c_int; +pub extern fn perror(__s: [*c]const u8) void; +pub extern fn fileno(__stream: [*c]FILE) c_int; +pub extern fn fileno_unlocked(__stream: [*c]FILE) c_int; +pub extern fn pclose(__stream: [*c]FILE) c_int; +pub extern fn popen(__command: [*c]const u8, __modes: [*c]const u8) [*c]FILE; +pub extern fn ctermid(__s: [*c]u8) [*c]u8; +pub extern fn flockfile(__stream: [*c]FILE) void; +pub extern fn ftrylockfile(__stream: [*c]FILE) c_int; +pub extern fn funlockfile(__stream: [*c]FILE) void; +pub extern fn __uflow([*c]FILE) c_int; +pub extern fn __overflow([*c]FILE, c_int) c_int; +pub const SPA_DIRECTION_INPUT: c_int = 0; +pub const SPA_DIRECTION_OUTPUT: c_int = 1; +pub const enum_spa_direction = c_uint; +pub const struct_spa_rectangle = extern struct { + width: u32 = @import("std").mem.zeroes(u32), + height: u32 = @import("std").mem.zeroes(u32), +}; +pub const struct_spa_point = extern struct { + x: i32 = @import("std").mem.zeroes(i32), + y: i32 = @import("std").mem.zeroes(i32), +}; +pub const struct_spa_region = extern struct { + position: struct_spa_point = @import("std").mem.zeroes(struct_spa_point), + size: struct_spa_rectangle = @import("std").mem.zeroes(struct_spa_rectangle), +}; +pub const struct_spa_fraction = extern struct { + num: u32 = @import("std").mem.zeroes(u32), + denom: u32 = @import("std").mem.zeroes(u32), +}; +pub fn spa_ptrinside(arg_p1: ?*const anyopaque, arg_s1: usize, arg_p2: ?*const anyopaque, arg_s2: usize, arg_remaining: [*c]usize) callconv(.c) bool { + var p1 = arg_p1; + _ = &p1; + var s1 = arg_s1; + _ = &s1; + var p2 = arg_p2; + _ = &p2; + var s2 = arg_s2; + _ = &s2; + var remaining = arg_remaining; + _ = &remaining; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((@as(usize, @intCast(@intFromPtr(p1))) <= @as(usize, @intCast(@intFromPtr(p2)))) and (s2 <= s1)) and ((@as(usize, @intCast(@intFromPtr(p2))) -% @as(usize, @intCast(@intFromPtr(p1)))) <= (s1 -% s2))))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + if (remaining != @as([*c]usize, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + remaining.* = (@as(usize, @intCast(@intFromPtr(p1))) +% s1) -% (@as(usize, @intCast(@intFromPtr(p2))) +% s2); + } + return @as(c_int, 1) != 0; + } else { + if (remaining != @as([*c]usize, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + remaining.* = 0; + } + return @as(c_int, 0) != 0; + } + return false; +} +pub fn spa_ptr_inside_and_aligned(arg_p1: ?*const anyopaque, arg_s1: usize, arg_p2: ?*const anyopaque, arg_s2: usize, arg_align: usize, arg_remaining: [*c]usize) callconv(.c) bool { + var p1 = arg_p1; + _ = &p1; + var s1 = arg_s1; + _ = &s1; + var p2 = arg_p2; + _ = &p2; + var s2 = arg_s2; + _ = &s2; + var @"align" = arg_align; + _ = &@"align"; + var remaining = arg_remaining; + _ = &remaining; + if ((@as(usize, @intCast(@intFromPtr(p2))) & (@"align" -% @as(usize, @bitCast(@as(c_long, @as(c_int, 1)))))) == @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 0))))) { + return spa_ptrinside(p1, s1, p2, s2, remaining); + } else { + if (remaining != @as([*c]usize, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + remaining.* = 0; + } + return @as(c_int, 0) != 0; + } + return false; +} +pub const struct_spa_error_location = extern struct { + line: c_int = @import("std").mem.zeroes(c_int), + col: c_int = @import("std").mem.zeroes(c_int), + len: usize = @import("std").mem.zeroes(usize), + location: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + reason: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), +}; +pub extern fn __errno_location() [*c]c_int; +pub const struct_spa_list = extern struct { + next: [*c]struct_spa_list = @import("std").mem.zeroes([*c]struct_spa_list), + prev: [*c]struct_spa_list = @import("std").mem.zeroes([*c]struct_spa_list), +}; +pub fn spa_list_init(arg_list: [*c]struct_spa_list) callconv(.c) void { + var list = arg_list; + _ = &list; + list.* = struct_spa_list{ + .next = list, + .prev = list, + }; +} +pub fn spa_list_is_initialized(arg_list: [*c]struct_spa_list) callconv(.c) c_int { + var list = arg_list; + _ = &list; + return @intFromBool(!!(list.*.prev != null)); +} +pub fn spa_list_insert(arg_list: [*c]struct_spa_list, arg_elem: [*c]struct_spa_list) callconv(.c) void { + var list = arg_list; + _ = &list; + var elem = arg_elem; + _ = &elem; + elem.*.prev = list; + elem.*.next = list.*.next; + list.*.next = elem; + elem.*.next.*.prev = elem; +} +pub fn spa_list_insert_list(arg_list: [*c]struct_spa_list, arg_other: [*c]struct_spa_list) callconv(.c) void { + var list = arg_list; + _ = &list; + var other = arg_other; + _ = &other; + if (other.*.next == other) return; + other.*.next.*.prev = list; + other.*.prev.*.next = list.*.next; + list.*.next.*.prev = other.*.prev; + list.*.next = other.*.next; +} +pub fn spa_list_remove(arg_elem: [*c]struct_spa_list) callconv(.c) void { + var elem = arg_elem; + _ = &elem; + elem.*.prev.*.next = elem.*.next; + elem.*.next.*.prev = elem.*.prev; +} +pub const struct_spa_callbacks = extern struct { + funcs: ?*const anyopaque = @import("std").mem.zeroes(?*const anyopaque), + data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), +}; +pub const struct_spa_interface = extern struct { + type: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + version: u32 = @import("std").mem.zeroes(u32), + cb: struct_spa_callbacks = @import("std").mem.zeroes(struct_spa_callbacks), +}; +pub const struct_spa_hook_list = extern struct { + list: struct_spa_list = @import("std").mem.zeroes(struct_spa_list), +}; +pub const struct_spa_hook = extern struct { + link: struct_spa_list = @import("std").mem.zeroes(struct_spa_list), + cb: struct_spa_callbacks = @import("std").mem.zeroes(struct_spa_callbacks), + removed: ?*const fn ([*c]struct_spa_hook) callconv(.c) void = @import("std").mem.zeroes(?*const fn ([*c]struct_spa_hook) callconv(.c) void), + priv: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), +}; +pub fn spa_hook_list_init(arg_list: [*c]struct_spa_hook_list) callconv(.c) void { + var list = arg_list; + _ = &list; + spa_list_init(&list.*.list); +} +pub fn spa_hook_list_is_empty(arg_list: [*c]struct_spa_hook_list) callconv(.c) bool { + var list = arg_list; + _ = &list; + return (&list.*.list).*.next == (&list.*.list); +} +pub fn spa_hook_list_append(arg_list: [*c]struct_spa_hook_list, arg_hook: [*c]struct_spa_hook, arg_funcs: ?*const anyopaque, arg_data: ?*anyopaque) callconv(.c) void { + var list = arg_list; + _ = &list; + var hook = arg_hook; + _ = &hook; + var funcs = arg_funcs; + _ = &funcs; + var data = arg_data; + _ = &data; + _ = memset(@as(?*anyopaque, @ptrCast(&hook.*)), @as(c_int, 0), @sizeOf(struct_spa_hook)); + hook.*.cb = struct_spa_callbacks{ + .funcs = funcs, + .data = data, + }; + spa_list_insert((&list.*.list).*.prev, &hook.*.link); +} +pub fn spa_hook_list_prepend(arg_list: [*c]struct_spa_hook_list, arg_hook: [*c]struct_spa_hook, arg_funcs: ?*const anyopaque, arg_data: ?*anyopaque) callconv(.c) void { + var list = arg_list; + _ = &list; + var hook = arg_hook; + _ = &hook; + var funcs = arg_funcs; + _ = &funcs; + var data = arg_data; + _ = &data; + _ = memset(@as(?*anyopaque, @ptrCast(&hook.*)), @as(c_int, 0), @sizeOf(struct_spa_hook)); + hook.*.cb = struct_spa_callbacks{ + .funcs = funcs, + .data = data, + }; + spa_list_insert(&list.*.list, &hook.*.link); +} +pub fn spa_hook_remove(arg_hook: [*c]struct_spa_hook) callconv(.c) void { + var hook = arg_hook; + _ = &hook; + if (spa_list_is_initialized(&hook.*.link) != 0) { + spa_list_remove(&hook.*.link); + } + if (hook.*.removed != null) { + hook.*.removed.?(hook); + } +} +pub fn spa_hook_list_clean(arg_list: [*c]struct_spa_hook_list) callconv(.c) void { + var list = arg_list; + _ = &list; + var h: [*c]struct_spa_hook = undefined; + _ = &h; + { + h = @as([*c]@TypeOf(h.*), @ptrFromInt(@as(usize, @intCast(@intFromPtr((&list.*.list).*.next))) -% @offsetOf(struct_spa_hook, "link"))); + while (!((&list.*.list).*.next == (&list.*.list))) : (h = @as([*c]@TypeOf(h.*), @ptrFromInt(@as(usize, @intCast(@intFromPtr((&list.*.list).*.next))) -% @offsetOf(struct_spa_hook, "link")))) { + spa_hook_remove(h); + } + } +} +pub fn spa_hook_list_isolate(arg_list: [*c]struct_spa_hook_list, arg_save: [*c]struct_spa_hook_list, arg_hook: [*c]struct_spa_hook, arg_funcs: ?*const anyopaque, arg_data: ?*anyopaque) callconv(.c) void { + var list = arg_list; + _ = &list; + var save = arg_save; + _ = &save; + var hook = arg_hook; + _ = &hook; + var funcs = arg_funcs; + _ = &funcs; + var data = arg_data; + _ = &data; + spa_hook_list_init(save); + spa_list_insert_list(&save.*.list, &list.*.list); + spa_hook_list_init(list); + spa_hook_list_append(list, hook, funcs, data); +} +pub fn spa_hook_list_join(arg_list: [*c]struct_spa_hook_list, arg_save: [*c]struct_spa_hook_list) callconv(.c) void { + var list = arg_list; + _ = &list; + var save = arg_save; + _ = &save; + spa_list_insert_list(&list.*.list, &save.*.list); +} +pub const struct_spa_dict_item = extern struct { + key: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + value: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), +}; +pub const struct_spa_dict = extern struct { + flags: u32 = @import("std").mem.zeroes(u32), + n_items: u32 = @import("std").mem.zeroes(u32), + items: [*c]const struct_spa_dict_item = @import("std").mem.zeroes([*c]const struct_spa_dict_item), +}; +pub fn spa_dict_item_compare(arg_i1: ?*const anyopaque, arg_i2: ?*const anyopaque) callconv(.c) c_int { + var @"i1" = arg_i1; + _ = &@"i1"; + var @"i2" = arg_i2; + _ = &@"i2"; + var it1: [*c]const struct_spa_dict_item = @as([*c]const struct_spa_dict_item, @ptrCast(@alignCast(@"i1"))); + _ = &it1; + var it2: [*c]const struct_spa_dict_item = @as([*c]const struct_spa_dict_item, @ptrCast(@alignCast(@"i2"))); + _ = &it2; + return strcmp(it1.*.key, it2.*.key); +} +pub fn spa_dict_qsort(arg_dict: [*c]struct_spa_dict) callconv(.c) void { + var dict = arg_dict; + _ = &dict; + if (dict.*.n_items > @as(u32, @bitCast(@as(c_int, 0)))) { + qsort(@as(?*anyopaque, @ptrCast(@constCast(@volatileCast(dict.*.items)))), @as(usize, @bitCast(@as(c_ulong, dict.*.n_items))), @sizeOf(struct_spa_dict_item), &spa_dict_item_compare); + } + _ = blk: { + const ref = &dict.*.flags; + ref.* |= @as(u32, @bitCast(@as(c_int, 1) << @intCast(0))); + break :blk ref.*; + }; +} +pub fn spa_dict_lookup_item(arg_dict: [*c]const struct_spa_dict, arg_key: [*c]const u8) callconv(.c) [*c]const struct_spa_dict_item { + var dict = arg_dict; + _ = &dict; + var key = arg_key; + _ = &key; + var item: [*c]const struct_spa_dict_item = undefined; + _ = &item; + if (((dict.*.flags & @as(u32, @bitCast(@as(c_int, 1) << @intCast(0)))) == @as(u32, @bitCast(@as(c_int, 1) << @intCast(0)))) and (dict.*.n_items > @as(u32, @bitCast(@as(c_int, 0))))) { + var k: struct_spa_dict_item = struct_spa_dict_item{ + .key = key, + .value = null, + }; + _ = &k; + item = @as([*c]const struct_spa_dict_item, @ptrCast(@alignCast(bsearch(@as(?*const anyopaque, @ptrCast(&k)), @as(?*const anyopaque, @ptrCast(dict.*.items)), @as(usize, @bitCast(@as(c_ulong, dict.*.n_items))), @sizeOf(struct_spa_dict_item), &spa_dict_item_compare)))); + if (item != @as([*c]const struct_spa_dict_item, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return item; + } else { + { + item = dict.*.items; + while (item < (&dict.*.items[dict.*.n_items])) : (item += 1) { + if (!(strcmp(item.*.key, key) != 0)) return item; + } + } + } + return null; +} +pub fn spa_dict_lookup(arg_dict: [*c]const struct_spa_dict, arg_key: [*c]const u8) callconv(.c) [*c]const u8 { + var dict = arg_dict; + _ = &dict; + var key = arg_key; + _ = &key; + var item: [*c]const struct_spa_dict_item = spa_dict_lookup_item(dict, key); + _ = &item; + return if (item != null) item.*.value else null; +} +pub const struct_spa_handle = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + get_interface: ?*const fn ([*c]struct_spa_handle, [*c]const u8, [*c]?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn ([*c]struct_spa_handle, [*c]const u8, [*c]?*anyopaque) callconv(.c) c_int), + clear: ?*const fn ([*c]struct_spa_handle) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn ([*c]struct_spa_handle) callconv(.c) c_int), +}; +pub fn spa_handle_get_interface(arg_object: [*c]struct_spa_handle, arg_type: [*c]const u8, arg_iface: [*c]?*anyopaque) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var @"type" = arg_type; + _ = &@"type"; + var iface = arg_iface; + _ = &iface; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((object != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (object.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (object.*.get_interface != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = object.*.get_interface.?(object, @"type", iface); + } + break :blk _res; + }; +} +pub fn spa_handle_clear(arg_object: [*c]struct_spa_handle) callconv(.c) c_int { + var object = arg_object; + _ = &object; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((object != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (object.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (object.*.clear != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = object.*.clear.?(object); + } + break :blk _res; + }; +} +pub const struct_spa_interface_info = extern struct { + type: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), +}; +pub const struct_spa_support = extern struct { + type: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), +}; +pub fn spa_support_find(arg_support: [*c]const struct_spa_support, arg_n_support: u32, arg_type: [*c]const u8) callconv(.c) ?*anyopaque { + var support = arg_support; + _ = &support; + var n_support = arg_n_support; + _ = &n_support; + var @"type" = arg_type; + _ = &@"type"; + var i: u32 = undefined; + _ = &i; + { + i = 0; + while (i < n_support) : (i +%= 1) { + if (strcmp(support[i].type, @"type") == @as(c_int, 0)) return support[i].data; + } + } + return @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); +} +pub const struct_spa_handle_factory = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + name: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + info: [*c]const struct_spa_dict = @import("std").mem.zeroes([*c]const struct_spa_dict), + get_size: ?*const fn ([*c]const struct_spa_handle_factory, [*c]const struct_spa_dict) callconv(.c) usize = @import("std").mem.zeroes(?*const fn ([*c]const struct_spa_handle_factory, [*c]const struct_spa_dict) callconv(.c) usize), + init: ?*const fn ([*c]const struct_spa_handle_factory, [*c]struct_spa_handle, [*c]const struct_spa_dict, [*c]const struct_spa_support, u32) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn ([*c]const struct_spa_handle_factory, [*c]struct_spa_handle, [*c]const struct_spa_dict, [*c]const struct_spa_support, u32) callconv(.c) c_int), + enum_interface_info: ?*const fn ([*c]const struct_spa_handle_factory, [*c][*c]const struct_spa_interface_info, [*c]u32) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn ([*c]const struct_spa_handle_factory, [*c][*c]const struct_spa_interface_info, [*c]u32) callconv(.c) c_int), +}; +pub fn spa_handle_factory_get_size(arg_object: [*c]const struct_spa_handle_factory, arg_params: [*c]const struct_spa_dict) callconv(.c) usize { + var object = arg_object; + _ = &object; + var params = arg_params; + _ = ¶ms; + return blk: { + var _res: usize = 0; + _ = &_res; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((object != null) and ((@as(c_int, 1) == @as(c_int, 0)) or (object.*.version > @as(u32, @bitCast(@as(c_int, 1) - @as(c_int, 1)))))) and (object.*.get_size != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = object.*.get_size.?(object, params); + } + break :blk _res; + }; +} +pub fn spa_handle_factory_init(arg_object: [*c]const struct_spa_handle_factory, arg_handle: [*c]struct_spa_handle, arg_info: [*c]const struct_spa_dict, arg_support: [*c]const struct_spa_support, arg_n_support: u32) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var handle = arg_handle; + _ = &handle; + var info = arg_info; + _ = &info; + var support = arg_support; + _ = &support; + var n_support = arg_n_support; + _ = &n_support; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((object != null) and ((@as(c_int, 1) == @as(c_int, 0)) or (object.*.version > @as(u32, @bitCast(@as(c_int, 1) - @as(c_int, 1)))))) and (object.*.init != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = object.*.init.?(object, handle, info, support, n_support); + } + break :blk _res; + }; +} +pub fn spa_handle_factory_enum_interface_info(arg_object: [*c]const struct_spa_handle_factory, arg_info: [*c][*c]const struct_spa_interface_info, arg_index_1: [*c]u32) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var info = arg_info; + _ = &info; + var index_1 = arg_index_1; + _ = &index_1; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((object != null) and ((@as(c_int, 1) == @as(c_int, 0)) or (object.*.version > @as(u32, @bitCast(@as(c_int, 1) - @as(c_int, 1)))))) and (object.*.enum_interface_info != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = object.*.enum_interface_info.?(object, info, index_1); + } + break :blk _res; + }; +} +pub const spa_handle_factory_enum_func_t = ?*const fn ([*c][*c]const struct_spa_handle_factory, [*c]u32) callconv(.c) c_int; +pub extern fn spa_handle_factory_enum(factory: [*c][*c]const struct_spa_handle_factory, index: [*c]u32) c_int; +pub const struct_pw_array = extern struct { + data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + size: usize = @import("std").mem.zeroes(usize), + alloc: usize = @import("std").mem.zeroes(usize), + extend: usize = @import("std").mem.zeroes(usize), +}; +pub fn pw_array_init(arg_arr: [*c]struct_pw_array, arg_extend: usize) callconv(.c) void { + var arr = arg_arr; + _ = &arr; + var extend = arg_extend; + _ = &extend; + arr.*.data = @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); + arr.*.size = blk: { + const tmp = @as(usize, @bitCast(@as(c_long, @as(c_int, 0)))); + arr.*.alloc = tmp; + break :blk tmp; + }; + arr.*.extend = extend; +} +pub fn pw_array_clear(arg_arr: [*c]struct_pw_array) callconv(.c) void { + var arr = arg_arr; + _ = &arr; + if (arr.*.extend > @as(usize, @bitCast(@as(c_long, @as(c_int, 0))))) { + free(arr.*.data); + } + pw_array_init(arr, arr.*.extend); +} +pub fn pw_array_init_static(arg_arr: [*c]struct_pw_array, arg_data: ?*anyopaque, arg_size: usize) callconv(.c) void { + var arr = arg_arr; + _ = &arr; + var data = arg_data; + _ = &data; + var size = arg_size; + _ = &size; + arr.*.data = data; + arr.*.alloc = size; + arr.*.size = blk: { + const tmp = @as(usize, @bitCast(@as(c_long, @as(c_int, 0)))); + arr.*.extend = tmp; + break :blk tmp; + }; +} +pub fn pw_array_reset(arg_arr: [*c]struct_pw_array) callconv(.c) void { + var arr = arg_arr; + _ = &arr; + arr.*.size = 0; +} +pub fn pw_array_ensure_size(arg_arr: [*c]struct_pw_array, arg_size: usize) callconv(.c) c_int { + var arr = arg_arr; + _ = &arr; + var size = arg_size; + _ = &size; + var alloc: usize = undefined; + _ = &alloc; + var need: usize = undefined; + _ = &need; + alloc = arr.*.alloc; + need = arr.*.size +% size; + if (__builtin_expect(@as(c_long, @intFromBool(!!(alloc < need))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 0))))) != 0) { + var data: ?*anyopaque = undefined; + _ = &data; + if (arr.*.extend == @as(usize, @bitCast(@as(c_long, @as(c_int, 0))))) return -@as(c_int, 28); + alloc = blk: { + var _v: @TypeOf(arr.*.extend) = arr.*.extend; + _ = &_v; + break :blk (((need +% _v) -% @as(usize, @bitCast(@as(c_long, @as(c_int, 1))))) / _v) *% _v; + }; + if (__builtin_expect(@as(c_long, @intFromBool(!!((blk: { + const tmp = realloc(arr.*.data, alloc); + data = tmp; + break :blk tmp; + }) == @as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 0))))) != 0) return -__errno_location().*; + arr.*.data = data; + arr.*.alloc = alloc; + } + return 0; +} +pub fn pw_array_add(arg_arr: [*c]struct_pw_array, arg_size: usize) callconv(.c) ?*anyopaque { + var arr = arg_arr; + _ = &arr; + var size = arg_size; + _ = &size; + var p: ?*anyopaque = undefined; + _ = &p; + if (pw_array_ensure_size(arr, size) < @as(c_int, 0)) return @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); + p = @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(arr.*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(arr.*.size)))))); + arr.*.size +%= size; + return p; +} +pub fn pw_array_add_ptr(arg_arr: [*c]struct_pw_array, arg_ptr: ?*anyopaque) callconv(.c) c_int { + var arr = arg_arr; + _ = &arr; + var ptr = arg_ptr; + _ = &ptr; + var p: [*c]?*anyopaque = @as([*c]?*anyopaque, @ptrCast(@alignCast(pw_array_add(arr, @sizeOf(?*anyopaque))))); + _ = &p; + if (p == @as([*c]?*anyopaque, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return -__errno_location().*; + p.* = ptr; + return 0; +} +pub const SPA_PARAM_Invalid: c_int = 0; +pub const SPA_PARAM_PropInfo: c_int = 1; +pub const SPA_PARAM_Props: c_int = 2; +pub const SPA_PARAM_EnumFormat: c_int = 3; +pub const SPA_PARAM_Format: c_int = 4; +pub const SPA_PARAM_Buffers: c_int = 5; +pub const SPA_PARAM_Meta: c_int = 6; +pub const SPA_PARAM_IO: c_int = 7; +pub const SPA_PARAM_EnumProfile: c_int = 8; +pub const SPA_PARAM_Profile: c_int = 9; +pub const SPA_PARAM_EnumPortConfig: c_int = 10; +pub const SPA_PARAM_PortConfig: c_int = 11; +pub const SPA_PARAM_EnumRoute: c_int = 12; +pub const SPA_PARAM_Route: c_int = 13; +pub const SPA_PARAM_Control: c_int = 14; +pub const SPA_PARAM_Latency: c_int = 15; +pub const SPA_PARAM_ProcessLatency: c_int = 16; +pub const SPA_PARAM_Tag: c_int = 17; +pub const SPA_PARAM_PeerFormats: c_int = 18; +pub const enum_spa_param_type = c_uint; +pub const struct_spa_param_info = extern struct { + id: u32 = @import("std").mem.zeroes(u32), + flags: u32 = @import("std").mem.zeroes(u32), + user: u32 = @import("std").mem.zeroes(u32), + seq: i32 = @import("std").mem.zeroes(i32), + padding: [4]u32 = @import("std").mem.zeroes([4]u32), +}; +pub const SPA_PARAM_BITORDER_unknown: c_int = 0; +pub const SPA_PARAM_BITORDER_msb: c_int = 1; +pub const SPA_PARAM_BITORDER_lsb: c_int = 2; +pub const enum_spa_param_bitorder = c_uint; +pub const SPA_PARAM_AVAILABILITY_unknown: c_int = 0; +pub const SPA_PARAM_AVAILABILITY_no: c_int = 1; +pub const SPA_PARAM_AVAILABILITY_yes: c_int = 2; +pub const enum_spa_param_availability = c_uint; +pub const SPA_PARAM_BUFFERS_START: c_int = 0; +pub const SPA_PARAM_BUFFERS_buffers: c_int = 1; +pub const SPA_PARAM_BUFFERS_blocks: c_int = 2; +pub const SPA_PARAM_BUFFERS_size: c_int = 3; +pub const SPA_PARAM_BUFFERS_stride: c_int = 4; +pub const SPA_PARAM_BUFFERS_align: c_int = 5; +pub const SPA_PARAM_BUFFERS_dataType: c_int = 6; +pub const SPA_PARAM_BUFFERS_metaType: c_int = 7; +pub const enum_spa_param_buffers = c_uint; +pub const SPA_PARAM_META_START: c_int = 0; +pub const SPA_PARAM_META_type: c_int = 1; +pub const SPA_PARAM_META_size: c_int = 2; +pub const SPA_PARAM_META_features: c_int = 3; +pub const enum_spa_param_meta = c_uint; +pub const SPA_PARAM_IO_START: c_int = 0; +pub const SPA_PARAM_IO_id: c_int = 1; +pub const SPA_PARAM_IO_size: c_int = 2; +pub const enum_spa_param_io = c_uint; +pub const SPA_PARAM_PROFILE_START: c_int = 0; +pub const SPA_PARAM_PROFILE_index: c_int = 1; +pub const SPA_PARAM_PROFILE_name: c_int = 2; +pub const SPA_PARAM_PROFILE_description: c_int = 3; +pub const SPA_PARAM_PROFILE_priority: c_int = 4; +pub const SPA_PARAM_PROFILE_available: c_int = 5; +pub const SPA_PARAM_PROFILE_info: c_int = 6; +pub const SPA_PARAM_PROFILE_classes: c_int = 7; +pub const SPA_PARAM_PROFILE_save: c_int = 8; +pub const enum_spa_param_profile = c_uint; +pub const SPA_PARAM_PORT_CONFIG_MODE_none: c_int = 0; +pub const SPA_PARAM_PORT_CONFIG_MODE_passthrough: c_int = 1; +pub const SPA_PARAM_PORT_CONFIG_MODE_convert: c_int = 2; +pub const SPA_PARAM_PORT_CONFIG_MODE_dsp: c_int = 3; +pub const enum_spa_param_port_config_mode = c_uint; +pub const SPA_PARAM_PORT_CONFIG_START: c_int = 0; +pub const SPA_PARAM_PORT_CONFIG_direction: c_int = 1; +pub const SPA_PARAM_PORT_CONFIG_mode: c_int = 2; +pub const SPA_PARAM_PORT_CONFIG_monitor: c_int = 3; +pub const SPA_PARAM_PORT_CONFIG_control: c_int = 4; +pub const SPA_PARAM_PORT_CONFIG_format: c_int = 5; +pub const enum_spa_param_port_config = c_uint; +pub const SPA_PARAM_ROUTE_START: c_int = 0; +pub const SPA_PARAM_ROUTE_index: c_int = 1; +pub const SPA_PARAM_ROUTE_direction: c_int = 2; +pub const SPA_PARAM_ROUTE_device: c_int = 3; +pub const SPA_PARAM_ROUTE_name: c_int = 4; +pub const SPA_PARAM_ROUTE_description: c_int = 5; +pub const SPA_PARAM_ROUTE_priority: c_int = 6; +pub const SPA_PARAM_ROUTE_available: c_int = 7; +pub const SPA_PARAM_ROUTE_info: c_int = 8; +pub const SPA_PARAM_ROUTE_profiles: c_int = 9; +pub const SPA_PARAM_ROUTE_props: c_int = 10; +pub const SPA_PARAM_ROUTE_devices: c_int = 11; +pub const SPA_PARAM_ROUTE_profile: c_int = 12; +pub const SPA_PARAM_ROUTE_save: c_int = 13; +pub const enum_spa_param_route = c_uint; +pub const struct_lconv = extern struct { + decimal_point: [*c]u8 = @import("std").mem.zeroes([*c]u8), + thousands_sep: [*c]u8 = @import("std").mem.zeroes([*c]u8), + grouping: [*c]u8 = @import("std").mem.zeroes([*c]u8), + int_curr_symbol: [*c]u8 = @import("std").mem.zeroes([*c]u8), + currency_symbol: [*c]u8 = @import("std").mem.zeroes([*c]u8), + mon_decimal_point: [*c]u8 = @import("std").mem.zeroes([*c]u8), + mon_thousands_sep: [*c]u8 = @import("std").mem.zeroes([*c]u8), + mon_grouping: [*c]u8 = @import("std").mem.zeroes([*c]u8), + positive_sign: [*c]u8 = @import("std").mem.zeroes([*c]u8), + negative_sign: [*c]u8 = @import("std").mem.zeroes([*c]u8), + int_frac_digits: u8 = @import("std").mem.zeroes(u8), + frac_digits: u8 = @import("std").mem.zeroes(u8), + p_cs_precedes: u8 = @import("std").mem.zeroes(u8), + p_sep_by_space: u8 = @import("std").mem.zeroes(u8), + n_cs_precedes: u8 = @import("std").mem.zeroes(u8), + n_sep_by_space: u8 = @import("std").mem.zeroes(u8), + p_sign_posn: u8 = @import("std").mem.zeroes(u8), + n_sign_posn: u8 = @import("std").mem.zeroes(u8), + int_p_cs_precedes: u8 = @import("std").mem.zeroes(u8), + int_p_sep_by_space: u8 = @import("std").mem.zeroes(u8), + int_n_cs_precedes: u8 = @import("std").mem.zeroes(u8), + int_n_sep_by_space: u8 = @import("std").mem.zeroes(u8), + int_p_sign_posn: u8 = @import("std").mem.zeroes(u8), + int_n_sign_posn: u8 = @import("std").mem.zeroes(u8), +}; +pub extern fn setlocale(__category: c_int, __locale: [*c]const u8) [*c]u8; +pub extern fn localeconv() [*c]struct_lconv; +pub extern fn newlocale(__category_mask: c_int, __locale: [*c]const u8, __base: locale_t) locale_t; +pub extern fn duplocale(__dataset: locale_t) locale_t; +pub extern fn freelocale(__dataset: locale_t) void; +pub extern fn uselocale(__dataset: locale_t) locale_t; +pub fn spa_streq(arg_s1: [*c]const u8, arg_s2: [*c]const u8) callconv(.c) bool { + var s1 = arg_s1; + _ = &s1; + var s2 = arg_s2; + _ = &s2; + return (if (__builtin_expect(@as(c_long, @intFromBool(!!((s1 != null) and (s2 != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) @intFromBool(strcmp(s1, s2) == @as(c_int, 0)) else @intFromBool(s1 == s2)) != 0; +} +pub fn spa_strneq(arg_s1: [*c]const u8, arg_s2: [*c]const u8, arg_len: usize) callconv(.c) bool { + var s1 = arg_s1; + _ = &s1; + var s2 = arg_s2; + _ = &s2; + var len = arg_len; + _ = &len; + return (if (__builtin_expect(@as(c_long, @intFromBool(!!((s1 != null) and (s2 != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) @intFromBool(strncmp(s1, s2, len) == @as(c_int, 0)) else @intFromBool(s1 == s2)) != 0; +} +pub fn spa_strstartswith(arg_s: [*c]const u8, arg_prefix: [*c]const u8) callconv(.c) bool { + var s = arg_s; + _ = &s; + var prefix = arg_prefix; + _ = &prefix; + if (__builtin_expect(@as(c_long, @intFromBool(!!(s == @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 0))))) != 0) return @as(c_int, 0) != 0; + while (true) { + if (__builtin_expect(@as(c_long, @intFromBool(!!!(prefix != null))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 0))))) != 0) { + _ = fprintf(stderr, "'%s' failed at %s:%u %s()\n", "prefix", ".zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/string.h", @as(c_int, 70), "spa_strstartswith"); + abort(); + } + if (!false) break; + } + return strncmp(s, prefix, strlen(prefix)) == @as(c_int, 0); +} +pub fn spa_strendswith(arg_s: [*c]const u8, arg_suffix: [*c]const u8) callconv(.c) bool { + var s = arg_s; + _ = &s; + var suffix = arg_suffix; + _ = &suffix; + var l1: usize = undefined; + _ = &l1; + var l2: usize = undefined; + _ = &l2; + if (__builtin_expect(@as(c_long, @intFromBool(!!(s == @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 0))))) != 0) return @as(c_int, 0) != 0; + while (true) { + if (__builtin_expect(@as(c_long, @intFromBool(!!!(suffix != null))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 0))))) != 0) { + _ = fprintf(stderr, "'%s' failed at %s:%u %s()\n", "suffix", ".zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/string.h", @as(c_int, 88), "spa_strendswith"); + abort(); + } + if (!false) break; + } + l1 = strlen(s); + l2 = strlen(suffix); + return (l1 >= l2) and (@as(c_int, @intFromBool(spa_streq((s + l1) - l2, suffix))) != 0); +} +pub fn spa_atoi32(arg_str: [*c]const u8, arg_val: [*c]i32, arg_base: c_int) callconv(.c) bool { + var str = arg_str; + _ = &str; + var val = arg_val; + _ = &val; + var base = arg_base; + _ = &base; + var endptr: [*c]u8 = undefined; + _ = &endptr; + var v: c_long = undefined; + _ = &v; + if (!(str != null) or (@as(c_int, @bitCast(@as(c_uint, str.*))) == @as(c_int, '\x00'))) return @as(c_int, 0) != 0; + __errno_location().* = 0; + v = strtol(str, &endptr, base); + if ((__errno_location().* != @as(c_int, 0)) or (@as(c_int, @bitCast(@as(c_uint, endptr.*))) != @as(c_int, '\x00'))) return @as(c_int, 0) != 0; + if (v != @as(c_long, @bitCast(@as(c_long, @as(i32, @bitCast(@as(c_int, @truncate(v)))))))) return @as(c_int, 0) != 0; + val.* = @as(i32, @bitCast(@as(c_int, @truncate(v)))); + return @as(c_int, 1) != 0; +} +pub fn spa_atou32(arg_str: [*c]const u8, arg_val: [*c]u32, arg_base: c_int) callconv(.c) bool { + var str = arg_str; + _ = &str; + var val = arg_val; + _ = &val; + var base = arg_base; + _ = &base; + var endptr: [*c]u8 = undefined; + _ = &endptr; + var v: c_ulonglong = undefined; + _ = &v; + if (!(str != null) or (@as(c_int, @bitCast(@as(c_uint, str.*))) == @as(c_int, '\x00'))) return @as(c_int, 0) != 0; + __errno_location().* = 0; + v = strtoull(str, &endptr, base); + if ((__errno_location().* != @as(c_int, 0)) or (@as(c_int, @bitCast(@as(c_uint, endptr.*))) != @as(c_int, '\x00'))) return @as(c_int, 0) != 0; + if (v != @as(c_ulonglong, @bitCast(@as(c_ulonglong, @as(u32, @bitCast(@as(c_uint, @truncate(v)))))))) return @as(c_int, 0) != 0; + val.* = @as(u32, @bitCast(@as(c_uint, @truncate(v)))); + return @as(c_int, 1) != 0; +} +pub fn spa_atoi64(arg_str: [*c]const u8, arg_val: [*c]i64, arg_base: c_int) callconv(.c) bool { + var str = arg_str; + _ = &str; + var val = arg_val; + _ = &val; + var base = arg_base; + _ = &base; + var endptr: [*c]u8 = undefined; + _ = &endptr; + var v: c_longlong = undefined; + _ = &v; + if (!(str != null) or (@as(c_int, @bitCast(@as(c_uint, str.*))) == @as(c_int, '\x00'))) return @as(c_int, 0) != 0; + __errno_location().* = 0; + v = strtoll(str, &endptr, base); + if ((__errno_location().* != @as(c_int, 0)) or (@as(c_int, @bitCast(@as(c_uint, endptr.*))) != @as(c_int, '\x00'))) return @as(c_int, 0) != 0; + val.* = @as(i64, @bitCast(@as(c_long, @truncate(v)))); + return @as(c_int, 1) != 0; +} +pub fn spa_atou64(arg_str: [*c]const u8, arg_val: [*c]u64, arg_base: c_int) callconv(.c) bool { + var str = arg_str; + _ = &str; + var val = arg_val; + _ = &val; + var base = arg_base; + _ = &base; + var endptr: [*c]u8 = undefined; + _ = &endptr; + var v: c_ulonglong = undefined; + _ = &v; + if (!(str != null) or (@as(c_int, @bitCast(@as(c_uint, str.*))) == @as(c_int, '\x00'))) return @as(c_int, 0) != 0; + __errno_location().* = 0; + v = strtoull(str, &endptr, base); + if ((__errno_location().* != @as(c_int, 0)) or (@as(c_int, @bitCast(@as(c_uint, endptr.*))) != @as(c_int, '\x00'))) return @as(c_int, 0) != 0; + val.* = @as(u64, @bitCast(@as(c_ulong, @truncate(v)))); + return @as(c_int, 1) != 0; +} +pub fn spa_atob(arg_str: [*c]const u8) callconv(.c) bool { + var str = arg_str; + _ = &str; + return (@as(c_int, @intFromBool(spa_streq(str, "true"))) != 0) or (@as(c_int, @intFromBool(spa_streq(str, "1"))) != 0); +} +pub fn spa_vscnprintf(arg_buffer: [*c]u8, arg_size: usize, arg_format: [*c]const u8, arg_args: [*c]struct___va_list_tag_26) callconv(.c) c_int { + var buffer = arg_buffer; + _ = &buffer; + var size = arg_size; + _ = &size; + var format = arg_format; + _ = &format; + var args = arg_args; + _ = &args; + var r: c_int = undefined; + _ = &r; + while (true) { + if (__builtin_expect(@as(c_long, @intFromBool(!!!(@as(isize, @bitCast(size)) > @as(isize, @bitCast(@as(c_long, @as(c_int, 0))))))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 0))))) != 0) { + _ = fprintf(stderr, "'%s' failed at %s:%u %s()\n", "(ssize_t)size > 0", ".zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/string.h", @as(c_int, 225), "spa_vscnprintf"); + abort(); + } + if (!false) break; + } + r = vsnprintf(buffer, size, format, args); + if (__builtin_expect(@as(c_long, @intFromBool(!!(r < @as(c_int, 0)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 0))))) != 0) { + buffer[@as(c_uint, @intCast(@as(c_int, 0)))] = '\x00'; + } + if (__builtin_expect(@as(c_long, @intFromBool(!!(@as(isize, @bitCast(@as(c_long, r))) < @as(isize, @bitCast(size))))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) return r; + return @as(c_int, @bitCast(@as(c_uint, @truncate(size -% @as(usize, @bitCast(@as(c_long, @as(c_int, 1)))))))); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/string.h:244:20: warning: TODO unable to translate variadic function, demoted to extern +pub extern fn spa_scnprintf(buffer: [*c]u8, size: usize, format: [*c]const u8, ...) c_int; +pub fn spa_strtof(arg_str: [*c]const u8, arg_endptr: [*c][*c]u8) callconv(.c) f32 { + var str = arg_str; + _ = &str; + var endptr = arg_endptr; + _ = &endptr; + const locale = struct { + var static: locale_t = null; + }; + _ = &locale; + var prev: locale_t = undefined; + _ = &prev; + var v: f32 = undefined; + _ = &v; + if (__builtin_expect(@as(c_long, @intFromBool(!!(locale.static == @as(locale_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 0))))) != 0) { + locale.static = newlocale((((((((((((@as(c_int, 1) << @intCast(0)) | (@as(c_int, 1) << @intCast(1))) | (@as(c_int, 1) << @intCast(2))) | (@as(c_int, 1) << @intCast(3))) | (@as(c_int, 1) << @intCast(4))) | (@as(c_int, 1) << @intCast(5))) | (@as(c_int, 1) << @intCast(7))) | (@as(c_int, 1) << @intCast(8))) | (@as(c_int, 1) << @intCast(9))) | (@as(c_int, 1) << @intCast(10))) | (@as(c_int, 1) << @intCast(11))) | (@as(c_int, 1) << @intCast(12)), "C", null); + } + prev = uselocale(locale.static); + v = strtof(str, endptr); + _ = uselocale(prev); + return v; +} +pub fn spa_atof(arg_str: [*c]const u8, arg_val: [*c]f32) callconv(.c) bool { + var str = arg_str; + _ = &str; + var val = arg_val; + _ = &val; + var endptr: [*c]u8 = undefined; + _ = &endptr; + var v: f32 = undefined; + _ = &v; + if (!(str != null) or (@as(c_int, @bitCast(@as(c_uint, str.*))) == @as(c_int, '\x00'))) return @as(c_int, 0) != 0; + __errno_location().* = 0; + v = spa_strtof(str, &endptr); + if ((__errno_location().* != @as(c_int, 0)) or (@as(c_int, @bitCast(@as(c_uint, endptr.*))) != @as(c_int, '\x00'))) return @as(c_int, 0) != 0; + val.* = v; + return @as(c_int, 1) != 0; +} +pub fn spa_strtod(arg_str: [*c]const u8, arg_endptr: [*c][*c]u8) callconv(.c) f64 { + var str = arg_str; + _ = &str; + var endptr = arg_endptr; + _ = &endptr; + const locale = struct { + var static: locale_t = null; + }; + _ = &locale; + var prev: locale_t = undefined; + _ = &prev; + var v: f64 = undefined; + _ = &v; + if (__builtin_expect(@as(c_long, @intFromBool(!!(locale.static == @as(locale_t, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 0))))) != 0) { + locale.static = newlocale((((((((((((@as(c_int, 1) << @intCast(0)) | (@as(c_int, 1) << @intCast(1))) | (@as(c_int, 1) << @intCast(2))) | (@as(c_int, 1) << @intCast(3))) | (@as(c_int, 1) << @intCast(4))) | (@as(c_int, 1) << @intCast(5))) | (@as(c_int, 1) << @intCast(7))) | (@as(c_int, 1) << @intCast(8))) | (@as(c_int, 1) << @intCast(9))) | (@as(c_int, 1) << @intCast(10))) | (@as(c_int, 1) << @intCast(11))) | (@as(c_int, 1) << @intCast(12)), "C", null); + } + prev = uselocale(locale.static); + v = strtod(str, endptr); + _ = uselocale(prev); + return v; +} +pub fn spa_atod(arg_str: [*c]const u8, arg_val: [*c]f64) callconv(.c) bool { + var str = arg_str; + _ = &str; + var val = arg_val; + _ = &val; + var endptr: [*c]u8 = undefined; + _ = &endptr; + var v: f64 = undefined; + _ = &v; + if (!(str != null) or (@as(c_int, @bitCast(@as(c_uint, str.*))) == @as(c_int, '\x00'))) return @as(c_int, 0) != 0; + __errno_location().* = 0; + v = spa_strtod(str, &endptr); + if ((__errno_location().* != @as(c_int, 0)) or (@as(c_int, @bitCast(@as(c_uint, endptr.*))) != @as(c_int, '\x00'))) return @as(c_int, 0) != 0; + val.* = v; + return @as(c_int, 1) != 0; +} +pub fn spa_dtoa(arg_str: [*c]u8, arg_size: usize, arg_val: f64) callconv(.c) [*c]u8 { + var str = arg_str; + _ = &str; + var size = arg_size; + _ = &size; + var val = arg_val; + _ = &val; + var i: c_int = undefined; + _ = &i; + var l: c_int = undefined; + _ = &l; + l = spa_scnprintf(str, size, "%f", val); + { + i = 0; + while (i < l) : (i += 1) if (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = i; + if (tmp >= 0) break :blk str + @as(usize, @intCast(tmp)) else break :blk str - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) == @as(c_int, ',')) { + (blk: { + const tmp = i; + if (tmp >= 0) break :blk str + @as(usize, @intCast(tmp)) else break :blk str - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).* = '.'; + }; + } + return str; +} +pub const struct_spa_strbuf = extern struct { + buffer: [*c]u8 = @import("std").mem.zeroes([*c]u8), + maxsize: usize = @import("std").mem.zeroes(usize), + pos: usize = @import("std").mem.zeroes(usize), +}; +pub fn spa_strbuf_init(arg_buf: [*c]struct_spa_strbuf, arg_buffer: [*c]u8, arg_maxsize: usize) callconv(.c) void { + var buf = arg_buf; + _ = &buf; + var buffer = arg_buffer; + _ = &buffer; + var maxsize = arg_maxsize; + _ = &maxsize; + buf.*.buffer = buffer; + buf.*.maxsize = maxsize; + buf.*.pos = 0; + if (maxsize > @as(usize, @bitCast(@as(c_long, @as(c_int, 0))))) { + buf.*.buffer[@as(c_uint, @intCast(@as(c_int, 0)))] = '\x00'; + } +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/string.h:383:20: warning: TODO unable to translate variadic function, demoted to extern +pub extern fn spa_strbuf_append(buf: [*c]struct_spa_strbuf, fmt: [*c]const u8, ...) c_int; +pub const SPA_TYPE_START: c_int = 0; +pub const SPA_TYPE_None: c_int = 1; +pub const SPA_TYPE_Bool: c_int = 2; +pub const SPA_TYPE_Id: c_int = 3; +pub const SPA_TYPE_Int: c_int = 4; +pub const SPA_TYPE_Long: c_int = 5; +pub const SPA_TYPE_Float: c_int = 6; +pub const SPA_TYPE_Double: c_int = 7; +pub const SPA_TYPE_String: c_int = 8; +pub const SPA_TYPE_Bytes: c_int = 9; +pub const SPA_TYPE_Rectangle: c_int = 10; +pub const SPA_TYPE_Fraction: c_int = 11; +pub const SPA_TYPE_Bitmap: c_int = 12; +pub const SPA_TYPE_Array: c_int = 13; +pub const SPA_TYPE_Struct: c_int = 14; +pub const SPA_TYPE_Object: c_int = 15; +pub const SPA_TYPE_Sequence: c_int = 16; +pub const SPA_TYPE_Pointer: c_int = 17; +pub const SPA_TYPE_Fd: c_int = 18; +pub const SPA_TYPE_Choice: c_int = 19; +pub const SPA_TYPE_Pod: c_int = 20; +pub const _SPA_TYPE_LAST: c_int = 21; +pub const SPA_TYPE_POINTER_START: c_int = 65536; +pub const SPA_TYPE_POINTER_Buffer: c_int = 65537; +pub const SPA_TYPE_POINTER_Meta: c_int = 65538; +pub const SPA_TYPE_POINTER_Dict: c_int = 65539; +pub const _SPA_TYPE_POINTER_LAST: c_int = 65540; +pub const SPA_TYPE_EVENT_START: c_int = 131072; +pub const SPA_TYPE_EVENT_Device: c_int = 131073; +pub const SPA_TYPE_EVENT_Node: c_int = 131074; +pub const _SPA_TYPE_EVENT_LAST: c_int = 131075; +pub const SPA_TYPE_COMMAND_START: c_int = 196608; +pub const SPA_TYPE_COMMAND_Device: c_int = 196609; +pub const SPA_TYPE_COMMAND_Node: c_int = 196610; +pub const _SPA_TYPE_COMMAND_LAST: c_int = 196611; +pub const SPA_TYPE_OBJECT_START: c_int = 262144; +pub const SPA_TYPE_OBJECT_PropInfo: c_int = 262145; +pub const SPA_TYPE_OBJECT_Props: c_int = 262146; +pub const SPA_TYPE_OBJECT_Format: c_int = 262147; +pub const SPA_TYPE_OBJECT_ParamBuffers: c_int = 262148; +pub const SPA_TYPE_OBJECT_ParamMeta: c_int = 262149; +pub const SPA_TYPE_OBJECT_ParamIO: c_int = 262150; +pub const SPA_TYPE_OBJECT_ParamProfile: c_int = 262151; +pub const SPA_TYPE_OBJECT_ParamPortConfig: c_int = 262152; +pub const SPA_TYPE_OBJECT_ParamRoute: c_int = 262153; +pub const SPA_TYPE_OBJECT_Profiler: c_int = 262154; +pub const SPA_TYPE_OBJECT_ParamLatency: c_int = 262155; +pub const SPA_TYPE_OBJECT_ParamProcessLatency: c_int = 262156; +pub const SPA_TYPE_OBJECT_ParamTag: c_int = 262157; +pub const _SPA_TYPE_OBJECT_LAST: c_int = 262158; +pub const SPA_TYPE_VENDOR_PipeWire: c_int = 33554432; +pub const SPA_TYPE_VENDOR_Other: c_int = 2130706432; +const enum_unnamed_28 = c_uint; +pub const struct_spa_type_info = extern struct { + type: u32 = @import("std").mem.zeroes(u32), + parent: u32 = @import("std").mem.zeroes(u32), + name: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + values: [*c]const struct_spa_type_info = @import("std").mem.zeroes([*c]const struct_spa_type_info), +}; +pub fn spa_type_is_a(arg_type: [*c]const u8, arg_parent: [*c]const u8) callconv(.c) bool { + var @"type" = arg_type; + _ = &@"type"; + var parent = arg_parent; + _ = &parent; + return ((@"type" != @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) and (parent != @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))))) and (strncmp(@"type", parent, strlen(parent)) == @as(c_int, 0)); +} +pub fn spa_type_short_name(arg_name: [*c]const u8) callconv(.c) [*c]const u8 { + var name = arg_name; + _ = &name; + var h: [*c]const u8 = undefined; + _ = &h; + if ((blk: { + const tmp = strrchr(name, @as(c_int, ':')); + h = tmp; + break :blk tmp; + }) != @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + name = h + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + } + return name; +} +pub fn spa_type_from_short_name(arg_name: [*c]const u8, arg_info: [*c]const struct_spa_type_info, arg_unknown: u32) callconv(.c) u32 { + var name = arg_name; + _ = &name; + var info = arg_info; + _ = &info; + var unknown = arg_unknown; + _ = &unknown; + var i: c_int = undefined; + _ = &i; + { + i = 0; + while ((blk: { + const tmp = i; + if (tmp >= 0) break :blk info + @as(usize, @intCast(tmp)) else break :blk info - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.name != null) : (i += 1) { + if (spa_streq(name, spa_type_short_name((blk: { + const tmp = i; + if (tmp >= 0) break :blk info + @as(usize, @intCast(tmp)) else break :blk info - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.name))) return (blk: { + const tmp = i; + if (tmp >= 0) break :blk info + @as(usize, @intCast(tmp)) else break :blk info - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type; + } + } + return unknown; +} +pub fn spa_type_to_name(arg_type: u32, arg_info: [*c]const struct_spa_type_info, arg_unknown: [*c]const u8) callconv(.c) [*c]const u8 { + var @"type" = arg_type; + _ = &@"type"; + var info = arg_info; + _ = &info; + var unknown = arg_unknown; + _ = &unknown; + var i: c_int = undefined; + _ = &i; + { + i = 0; + while ((blk: { + const tmp = i; + if (tmp >= 0) break :blk info + @as(usize, @intCast(tmp)) else break :blk info - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.name != null) : (i += 1) { + if ((blk: { + const tmp = i; + if (tmp >= 0) break :blk info + @as(usize, @intCast(tmp)) else break :blk info - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.type == @"type") return (blk: { + const tmp = i; + if (tmp >= 0) break :blk info + @as(usize, @intCast(tmp)) else break :blk info - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*.name; + } + } + return unknown; +} +pub fn spa_type_to_short_name(arg_type: u32, arg_info: [*c]const struct_spa_type_info, arg_unknown: [*c]const u8) callconv(.c) [*c]const u8 { + var @"type" = arg_type; + _ = &@"type"; + var info = arg_info; + _ = &info; + var unknown = arg_unknown; + _ = &unknown; + var n: [*c]const u8 = spa_type_to_name(@"type", info, unknown); + _ = &n; + return if (n != null) spa_type_short_name(n) else null; +} +pub const PW_TYPE_FIRST: c_int = 33554432; +const enum_unnamed_29 = c_uint; +pub extern fn pw_type_info() [*c]const struct_spa_type_info; +pub const struct_pw_proxy = opaque {}; +pub const struct_pw_protocol = opaque {}; +pub const struct_pw_context = opaque {}; +pub const struct_pw_global = opaque {}; +pub const struct_pw_impl_client = opaque {}; +pub const struct_pw_impl_node = opaque {}; +pub const struct_pw_core = opaque {}; +pub const struct_pw_registry = opaque {}; +pub const struct_pw_core_info = extern struct { + id: u32 = @import("std").mem.zeroes(u32), + cookie: u32 = @import("std").mem.zeroes(u32), + user_name: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + host_name: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + version: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + name: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + change_mask: u64 = @import("std").mem.zeroes(u64), + props: [*c]struct_spa_dict = @import("std").mem.zeroes([*c]struct_spa_dict), +}; +pub const useconds_t = __useconds_t; +pub const socklen_t = __socklen_t; +pub extern fn access(__name: [*c]const u8, __type: c_int) c_int; +pub extern fn faccessat(__fd: c_int, __file: [*c]const u8, __type: c_int, __flag: c_int) c_int; +pub extern fn lseek(__fd: c_int, __offset: __off_t, __whence: c_int) __off_t; +pub extern fn close(__fd: c_int) c_int; +pub extern fn closefrom(__lowfd: c_int) void; +pub extern fn read(__fd: c_int, __buf: ?*anyopaque, __nbytes: usize) isize; +pub extern fn write(__fd: c_int, __buf: ?*const anyopaque, __n: usize) isize; +pub extern fn pread(__fd: c_int, __buf: ?*anyopaque, __nbytes: usize, __offset: __off_t) isize; +pub extern fn pwrite(__fd: c_int, __buf: ?*const anyopaque, __n: usize, __offset: __off_t) isize; +pub extern fn pipe(__pipedes: [*c]c_int) c_int; +pub extern fn alarm(__seconds: c_uint) c_uint; +pub extern fn sleep(__seconds: c_uint) c_uint; +pub extern fn ualarm(__value: __useconds_t, __interval: __useconds_t) __useconds_t; +pub extern fn usleep(__useconds: __useconds_t) c_int; +pub extern fn pause() c_int; +pub extern fn chown(__file: [*c]const u8, __owner: __uid_t, __group: __gid_t) c_int; +pub extern fn fchown(__fd: c_int, __owner: __uid_t, __group: __gid_t) c_int; +pub extern fn lchown(__file: [*c]const u8, __owner: __uid_t, __group: __gid_t) c_int; +pub extern fn fchownat(__fd: c_int, __file: [*c]const u8, __owner: __uid_t, __group: __gid_t, __flag: c_int) c_int; +pub extern fn chdir(__path: [*c]const u8) c_int; +pub extern fn fchdir(__fd: c_int) c_int; +pub extern fn getcwd(__buf: [*c]u8, __size: usize) [*c]u8; +pub extern fn getwd(__buf: [*c]u8) [*c]u8; +pub extern fn dup(__fd: c_int) c_int; +pub extern fn dup2(__fd: c_int, __fd2: c_int) c_int; +pub extern var __environ: [*c][*c]u8; +pub extern fn execve(__path: [*c]const u8, __argv: [*c]const [*c]u8, __envp: [*c]const [*c]u8) c_int; +pub extern fn fexecve(__fd: c_int, __argv: [*c]const [*c]u8, __envp: [*c]const [*c]u8) c_int; +pub extern fn execv(__path: [*c]const u8, __argv: [*c]const [*c]u8) c_int; +pub extern fn execle(__path: [*c]const u8, __arg: [*c]const u8, ...) c_int; +pub extern fn execl(__path: [*c]const u8, __arg: [*c]const u8, ...) c_int; +pub extern fn execvp(__file: [*c]const u8, __argv: [*c]const [*c]u8) c_int; +pub extern fn execlp(__file: [*c]const u8, __arg: [*c]const u8, ...) c_int; +pub extern fn nice(__inc: c_int) c_int; +pub extern fn _exit(__status: c_int) noreturn; +pub const _PC_LINK_MAX: c_int = 0; +pub const _PC_MAX_CANON: c_int = 1; +pub const _PC_MAX_INPUT: c_int = 2; +pub const _PC_NAME_MAX: c_int = 3; +pub const _PC_PATH_MAX: c_int = 4; +pub const _PC_PIPE_BUF: c_int = 5; +pub const _PC_CHOWN_RESTRICTED: c_int = 6; +pub const _PC_NO_TRUNC: c_int = 7; +pub const _PC_VDISABLE: c_int = 8; +pub const _PC_SYNC_IO: c_int = 9; +pub const _PC_ASYNC_IO: c_int = 10; +pub const _PC_PRIO_IO: c_int = 11; +pub const _PC_SOCK_MAXBUF: c_int = 12; +pub const _PC_FILESIZEBITS: c_int = 13; +pub const _PC_REC_INCR_XFER_SIZE: c_int = 14; +pub const _PC_REC_MAX_XFER_SIZE: c_int = 15; +pub const _PC_REC_MIN_XFER_SIZE: c_int = 16; +pub const _PC_REC_XFER_ALIGN: c_int = 17; +pub const _PC_ALLOC_SIZE_MIN: c_int = 18; +pub const _PC_SYMLINK_MAX: c_int = 19; +pub const _PC_2_SYMLINKS: c_int = 20; +const enum_unnamed_30 = c_uint; +pub const _SC_ARG_MAX: c_int = 0; +pub const _SC_CHILD_MAX: c_int = 1; +pub const _SC_CLK_TCK: c_int = 2; +pub const _SC_NGROUPS_MAX: c_int = 3; +pub const _SC_OPEN_MAX: c_int = 4; +pub const _SC_STREAM_MAX: c_int = 5; +pub const _SC_TZNAME_MAX: c_int = 6; +pub const _SC_JOB_CONTROL: c_int = 7; +pub const _SC_SAVED_IDS: c_int = 8; +pub const _SC_REALTIME_SIGNALS: c_int = 9; +pub const _SC_PRIORITY_SCHEDULING: c_int = 10; +pub const _SC_TIMERS: c_int = 11; +pub const _SC_ASYNCHRONOUS_IO: c_int = 12; +pub const _SC_PRIORITIZED_IO: c_int = 13; +pub const _SC_SYNCHRONIZED_IO: c_int = 14; +pub const _SC_FSYNC: c_int = 15; +pub const _SC_MAPPED_FILES: c_int = 16; +pub const _SC_MEMLOCK: c_int = 17; +pub const _SC_MEMLOCK_RANGE: c_int = 18; +pub const _SC_MEMORY_PROTECTION: c_int = 19; +pub const _SC_MESSAGE_PASSING: c_int = 20; +pub const _SC_SEMAPHORES: c_int = 21; +pub const _SC_SHARED_MEMORY_OBJECTS: c_int = 22; +pub const _SC_AIO_LISTIO_MAX: c_int = 23; +pub const _SC_AIO_MAX: c_int = 24; +pub const _SC_AIO_PRIO_DELTA_MAX: c_int = 25; +pub const _SC_DELAYTIMER_MAX: c_int = 26; +pub const _SC_MQ_OPEN_MAX: c_int = 27; +pub const _SC_MQ_PRIO_MAX: c_int = 28; +pub const _SC_VERSION: c_int = 29; +pub const _SC_PAGESIZE: c_int = 30; +pub const _SC_RTSIG_MAX: c_int = 31; +pub const _SC_SEM_NSEMS_MAX: c_int = 32; +pub const _SC_SEM_VALUE_MAX: c_int = 33; +pub const _SC_SIGQUEUE_MAX: c_int = 34; +pub const _SC_TIMER_MAX: c_int = 35; +pub const _SC_BC_BASE_MAX: c_int = 36; +pub const _SC_BC_DIM_MAX: c_int = 37; +pub const _SC_BC_SCALE_MAX: c_int = 38; +pub const _SC_BC_STRING_MAX: c_int = 39; +pub const _SC_COLL_WEIGHTS_MAX: c_int = 40; +pub const _SC_EQUIV_CLASS_MAX: c_int = 41; +pub const _SC_EXPR_NEST_MAX: c_int = 42; +pub const _SC_LINE_MAX: c_int = 43; +pub const _SC_RE_DUP_MAX: c_int = 44; +pub const _SC_CHARCLASS_NAME_MAX: c_int = 45; +pub const _SC_2_VERSION: c_int = 46; +pub const _SC_2_C_BIND: c_int = 47; +pub const _SC_2_C_DEV: c_int = 48; +pub const _SC_2_FORT_DEV: c_int = 49; +pub const _SC_2_FORT_RUN: c_int = 50; +pub const _SC_2_SW_DEV: c_int = 51; +pub const _SC_2_LOCALEDEF: c_int = 52; +pub const _SC_PII: c_int = 53; +pub const _SC_PII_XTI: c_int = 54; +pub const _SC_PII_SOCKET: c_int = 55; +pub const _SC_PII_INTERNET: c_int = 56; +pub const _SC_PII_OSI: c_int = 57; +pub const _SC_POLL: c_int = 58; +pub const _SC_SELECT: c_int = 59; +pub const _SC_UIO_MAXIOV: c_int = 60; +pub const _SC_IOV_MAX: c_int = 60; +pub const _SC_PII_INTERNET_STREAM: c_int = 61; +pub const _SC_PII_INTERNET_DGRAM: c_int = 62; +pub const _SC_PII_OSI_COTS: c_int = 63; +pub const _SC_PII_OSI_CLTS: c_int = 64; +pub const _SC_PII_OSI_M: c_int = 65; +pub const _SC_T_IOV_MAX: c_int = 66; +pub const _SC_THREADS: c_int = 67; +pub const _SC_THREAD_SAFE_FUNCTIONS: c_int = 68; +pub const _SC_GETGR_R_SIZE_MAX: c_int = 69; +pub const _SC_GETPW_R_SIZE_MAX: c_int = 70; +pub const _SC_LOGIN_NAME_MAX: c_int = 71; +pub const _SC_TTY_NAME_MAX: c_int = 72; +pub const _SC_THREAD_DESTRUCTOR_ITERATIONS: c_int = 73; +pub const _SC_THREAD_KEYS_MAX: c_int = 74; +pub const _SC_THREAD_STACK_MIN: c_int = 75; +pub const _SC_THREAD_THREADS_MAX: c_int = 76; +pub const _SC_THREAD_ATTR_STACKADDR: c_int = 77; +pub const _SC_THREAD_ATTR_STACKSIZE: c_int = 78; +pub const _SC_THREAD_PRIORITY_SCHEDULING: c_int = 79; +pub const _SC_THREAD_PRIO_INHERIT: c_int = 80; +pub const _SC_THREAD_PRIO_PROTECT: c_int = 81; +pub const _SC_THREAD_PROCESS_SHARED: c_int = 82; +pub const _SC_NPROCESSORS_CONF: c_int = 83; +pub const _SC_NPROCESSORS_ONLN: c_int = 84; +pub const _SC_PHYS_PAGES: c_int = 85; +pub const _SC_AVPHYS_PAGES: c_int = 86; +pub const _SC_ATEXIT_MAX: c_int = 87; +pub const _SC_PASS_MAX: c_int = 88; +pub const _SC_XOPEN_VERSION: c_int = 89; +pub const _SC_XOPEN_XCU_VERSION: c_int = 90; +pub const _SC_XOPEN_UNIX: c_int = 91; +pub const _SC_XOPEN_CRYPT: c_int = 92; +pub const _SC_XOPEN_ENH_I18N: c_int = 93; +pub const _SC_XOPEN_SHM: c_int = 94; +pub const _SC_2_CHAR_TERM: c_int = 95; +pub const _SC_2_C_VERSION: c_int = 96; +pub const _SC_2_UPE: c_int = 97; +pub const _SC_XOPEN_XPG2: c_int = 98; +pub const _SC_XOPEN_XPG3: c_int = 99; +pub const _SC_XOPEN_XPG4: c_int = 100; +pub const _SC_CHAR_BIT: c_int = 101; +pub const _SC_CHAR_MAX: c_int = 102; +pub const _SC_CHAR_MIN: c_int = 103; +pub const _SC_INT_MAX: c_int = 104; +pub const _SC_INT_MIN: c_int = 105; +pub const _SC_LONG_BIT: c_int = 106; +pub const _SC_WORD_BIT: c_int = 107; +pub const _SC_MB_LEN_MAX: c_int = 108; +pub const _SC_NZERO: c_int = 109; +pub const _SC_SSIZE_MAX: c_int = 110; +pub const _SC_SCHAR_MAX: c_int = 111; +pub const _SC_SCHAR_MIN: c_int = 112; +pub const _SC_SHRT_MAX: c_int = 113; +pub const _SC_SHRT_MIN: c_int = 114; +pub const _SC_UCHAR_MAX: c_int = 115; +pub const _SC_UINT_MAX: c_int = 116; +pub const _SC_ULONG_MAX: c_int = 117; +pub const _SC_USHRT_MAX: c_int = 118; +pub const _SC_NL_ARGMAX: c_int = 119; +pub const _SC_NL_LANGMAX: c_int = 120; +pub const _SC_NL_MSGMAX: c_int = 121; +pub const _SC_NL_NMAX: c_int = 122; +pub const _SC_NL_SETMAX: c_int = 123; +pub const _SC_NL_TEXTMAX: c_int = 124; +pub const _SC_XBS5_ILP32_OFF32: c_int = 125; +pub const _SC_XBS5_ILP32_OFFBIG: c_int = 126; +pub const _SC_XBS5_LP64_OFF64: c_int = 127; +pub const _SC_XBS5_LPBIG_OFFBIG: c_int = 128; +pub const _SC_XOPEN_LEGACY: c_int = 129; +pub const _SC_XOPEN_REALTIME: c_int = 130; +pub const _SC_XOPEN_REALTIME_THREADS: c_int = 131; +pub const _SC_ADVISORY_INFO: c_int = 132; +pub const _SC_BARRIERS: c_int = 133; +pub const _SC_BASE: c_int = 134; +pub const _SC_C_LANG_SUPPORT: c_int = 135; +pub const _SC_C_LANG_SUPPORT_R: c_int = 136; +pub const _SC_CLOCK_SELECTION: c_int = 137; +pub const _SC_CPUTIME: c_int = 138; +pub const _SC_THREAD_CPUTIME: c_int = 139; +pub const _SC_DEVICE_IO: c_int = 140; +pub const _SC_DEVICE_SPECIFIC: c_int = 141; +pub const _SC_DEVICE_SPECIFIC_R: c_int = 142; +pub const _SC_FD_MGMT: c_int = 143; +pub const _SC_FIFO: c_int = 144; +pub const _SC_PIPE: c_int = 145; +pub const _SC_FILE_ATTRIBUTES: c_int = 146; +pub const _SC_FILE_LOCKING: c_int = 147; +pub const _SC_FILE_SYSTEM: c_int = 148; +pub const _SC_MONOTONIC_CLOCK: c_int = 149; +pub const _SC_MULTI_PROCESS: c_int = 150; +pub const _SC_SINGLE_PROCESS: c_int = 151; +pub const _SC_NETWORKING: c_int = 152; +pub const _SC_READER_WRITER_LOCKS: c_int = 153; +pub const _SC_SPIN_LOCKS: c_int = 154; +pub const _SC_REGEXP: c_int = 155; +pub const _SC_REGEX_VERSION: c_int = 156; +pub const _SC_SHELL: c_int = 157; +pub const _SC_SIGNALS: c_int = 158; +pub const _SC_SPAWN: c_int = 159; +pub const _SC_SPORADIC_SERVER: c_int = 160; +pub const _SC_THREAD_SPORADIC_SERVER: c_int = 161; +pub const _SC_SYSTEM_DATABASE: c_int = 162; +pub const _SC_SYSTEM_DATABASE_R: c_int = 163; +pub const _SC_TIMEOUTS: c_int = 164; +pub const _SC_TYPED_MEMORY_OBJECTS: c_int = 165; +pub const _SC_USER_GROUPS: c_int = 166; +pub const _SC_USER_GROUPS_R: c_int = 167; +pub const _SC_2_PBS: c_int = 168; +pub const _SC_2_PBS_ACCOUNTING: c_int = 169; +pub const _SC_2_PBS_LOCATE: c_int = 170; +pub const _SC_2_PBS_MESSAGE: c_int = 171; +pub const _SC_2_PBS_TRACK: c_int = 172; +pub const _SC_SYMLOOP_MAX: c_int = 173; +pub const _SC_STREAMS: c_int = 174; +pub const _SC_2_PBS_CHECKPOINT: c_int = 175; +pub const _SC_V6_ILP32_OFF32: c_int = 176; +pub const _SC_V6_ILP32_OFFBIG: c_int = 177; +pub const _SC_V6_LP64_OFF64: c_int = 178; +pub const _SC_V6_LPBIG_OFFBIG: c_int = 179; +pub const _SC_HOST_NAME_MAX: c_int = 180; +pub const _SC_TRACE: c_int = 181; +pub const _SC_TRACE_EVENT_FILTER: c_int = 182; +pub const _SC_TRACE_INHERIT: c_int = 183; +pub const _SC_TRACE_LOG: c_int = 184; +pub const _SC_LEVEL1_ICACHE_SIZE: c_int = 185; +pub const _SC_LEVEL1_ICACHE_ASSOC: c_int = 186; +pub const _SC_LEVEL1_ICACHE_LINESIZE: c_int = 187; +pub const _SC_LEVEL1_DCACHE_SIZE: c_int = 188; +pub const _SC_LEVEL1_DCACHE_ASSOC: c_int = 189; +pub const _SC_LEVEL1_DCACHE_LINESIZE: c_int = 190; +pub const _SC_LEVEL2_CACHE_SIZE: c_int = 191; +pub const _SC_LEVEL2_CACHE_ASSOC: c_int = 192; +pub const _SC_LEVEL2_CACHE_LINESIZE: c_int = 193; +pub const _SC_LEVEL3_CACHE_SIZE: c_int = 194; +pub const _SC_LEVEL3_CACHE_ASSOC: c_int = 195; +pub const _SC_LEVEL3_CACHE_LINESIZE: c_int = 196; +pub const _SC_LEVEL4_CACHE_SIZE: c_int = 197; +pub const _SC_LEVEL4_CACHE_ASSOC: c_int = 198; +pub const _SC_LEVEL4_CACHE_LINESIZE: c_int = 199; +pub const _SC_IPV6: c_int = 235; +pub const _SC_RAW_SOCKETS: c_int = 236; +pub const _SC_V7_ILP32_OFF32: c_int = 237; +pub const _SC_V7_ILP32_OFFBIG: c_int = 238; +pub const _SC_V7_LP64_OFF64: c_int = 239; +pub const _SC_V7_LPBIG_OFFBIG: c_int = 240; +pub const _SC_SS_REPL_MAX: c_int = 241; +pub const _SC_TRACE_EVENT_NAME_MAX: c_int = 242; +pub const _SC_TRACE_NAME_MAX: c_int = 243; +pub const _SC_TRACE_SYS_MAX: c_int = 244; +pub const _SC_TRACE_USER_EVENT_MAX: c_int = 245; +pub const _SC_XOPEN_STREAMS: c_int = 246; +pub const _SC_THREAD_ROBUST_PRIO_INHERIT: c_int = 247; +pub const _SC_THREAD_ROBUST_PRIO_PROTECT: c_int = 248; +pub const _SC_MINSIGSTKSZ: c_int = 249; +pub const _SC_SIGSTKSZ: c_int = 250; +const enum_unnamed_31 = c_uint; +pub const _CS_PATH: c_int = 0; +pub const _CS_V6_WIDTH_RESTRICTED_ENVS: c_int = 1; +pub const _CS_GNU_LIBC_VERSION: c_int = 2; +pub const _CS_GNU_LIBPTHREAD_VERSION: c_int = 3; +pub const _CS_V5_WIDTH_RESTRICTED_ENVS: c_int = 4; +pub const _CS_V7_WIDTH_RESTRICTED_ENVS: c_int = 5; +pub const _CS_LFS_CFLAGS: c_int = 1000; +pub const _CS_LFS_LDFLAGS: c_int = 1001; +pub const _CS_LFS_LIBS: c_int = 1002; +pub const _CS_LFS_LINTFLAGS: c_int = 1003; +pub const _CS_LFS64_CFLAGS: c_int = 1004; +pub const _CS_LFS64_LDFLAGS: c_int = 1005; +pub const _CS_LFS64_LIBS: c_int = 1006; +pub const _CS_LFS64_LINTFLAGS: c_int = 1007; +pub const _CS_XBS5_ILP32_OFF32_CFLAGS: c_int = 1100; +pub const _CS_XBS5_ILP32_OFF32_LDFLAGS: c_int = 1101; +pub const _CS_XBS5_ILP32_OFF32_LIBS: c_int = 1102; +pub const _CS_XBS5_ILP32_OFF32_LINTFLAGS: c_int = 1103; +pub const _CS_XBS5_ILP32_OFFBIG_CFLAGS: c_int = 1104; +pub const _CS_XBS5_ILP32_OFFBIG_LDFLAGS: c_int = 1105; +pub const _CS_XBS5_ILP32_OFFBIG_LIBS: c_int = 1106; +pub const _CS_XBS5_ILP32_OFFBIG_LINTFLAGS: c_int = 1107; +pub const _CS_XBS5_LP64_OFF64_CFLAGS: c_int = 1108; +pub const _CS_XBS5_LP64_OFF64_LDFLAGS: c_int = 1109; +pub const _CS_XBS5_LP64_OFF64_LIBS: c_int = 1110; +pub const _CS_XBS5_LP64_OFF64_LINTFLAGS: c_int = 1111; +pub const _CS_XBS5_LPBIG_OFFBIG_CFLAGS: c_int = 1112; +pub const _CS_XBS5_LPBIG_OFFBIG_LDFLAGS: c_int = 1113; +pub const _CS_XBS5_LPBIG_OFFBIG_LIBS: c_int = 1114; +pub const _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS: c_int = 1115; +pub const _CS_POSIX_V6_ILP32_OFF32_CFLAGS: c_int = 1116; +pub const _CS_POSIX_V6_ILP32_OFF32_LDFLAGS: c_int = 1117; +pub const _CS_POSIX_V6_ILP32_OFF32_LIBS: c_int = 1118; +pub const _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS: c_int = 1119; +pub const _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS: c_int = 1120; +pub const _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS: c_int = 1121; +pub const _CS_POSIX_V6_ILP32_OFFBIG_LIBS: c_int = 1122; +pub const _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS: c_int = 1123; +pub const _CS_POSIX_V6_LP64_OFF64_CFLAGS: c_int = 1124; +pub const _CS_POSIX_V6_LP64_OFF64_LDFLAGS: c_int = 1125; +pub const _CS_POSIX_V6_LP64_OFF64_LIBS: c_int = 1126; +pub const _CS_POSIX_V6_LP64_OFF64_LINTFLAGS: c_int = 1127; +pub const _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS: c_int = 1128; +pub const _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS: c_int = 1129; +pub const _CS_POSIX_V6_LPBIG_OFFBIG_LIBS: c_int = 1130; +pub const _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS: c_int = 1131; +pub const _CS_POSIX_V7_ILP32_OFF32_CFLAGS: c_int = 1132; +pub const _CS_POSIX_V7_ILP32_OFF32_LDFLAGS: c_int = 1133; +pub const _CS_POSIX_V7_ILP32_OFF32_LIBS: c_int = 1134; +pub const _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS: c_int = 1135; +pub const _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS: c_int = 1136; +pub const _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS: c_int = 1137; +pub const _CS_POSIX_V7_ILP32_OFFBIG_LIBS: c_int = 1138; +pub const _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS: c_int = 1139; +pub const _CS_POSIX_V7_LP64_OFF64_CFLAGS: c_int = 1140; +pub const _CS_POSIX_V7_LP64_OFF64_LDFLAGS: c_int = 1141; +pub const _CS_POSIX_V7_LP64_OFF64_LIBS: c_int = 1142; +pub const _CS_POSIX_V7_LP64_OFF64_LINTFLAGS: c_int = 1143; +pub const _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS: c_int = 1144; +pub const _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS: c_int = 1145; +pub const _CS_POSIX_V7_LPBIG_OFFBIG_LIBS: c_int = 1146; +pub const _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS: c_int = 1147; +pub const _CS_V6_ENV: c_int = 1148; +pub const _CS_V7_ENV: c_int = 1149; +const enum_unnamed_32 = c_uint; +pub extern fn pathconf(__path: [*c]const u8, __name: c_int) c_long; +pub extern fn fpathconf(__fd: c_int, __name: c_int) c_long; +pub extern fn sysconf(__name: c_int) c_long; +pub extern fn confstr(__name: c_int, __buf: [*c]u8, __len: usize) usize; +pub extern fn getpid() __pid_t; +pub extern fn getppid() __pid_t; +pub extern fn getpgrp() __pid_t; +pub extern fn __getpgid(__pid: __pid_t) __pid_t; +pub extern fn getpgid(__pid: __pid_t) __pid_t; +pub extern fn setpgid(__pid: __pid_t, __pgid: __pid_t) c_int; +pub extern fn setpgrp() c_int; +pub extern fn setsid() __pid_t; +pub extern fn getsid(__pid: __pid_t) __pid_t; +pub extern fn getuid() __uid_t; +pub extern fn geteuid() __uid_t; +pub extern fn getgid() __gid_t; +pub extern fn getegid() __gid_t; +pub extern fn getgroups(__size: c_int, __list: [*c]__gid_t) c_int; +pub extern fn setuid(__uid: __uid_t) c_int; +pub extern fn setreuid(__ruid: __uid_t, __euid: __uid_t) c_int; +pub extern fn seteuid(__uid: __uid_t) c_int; +pub extern fn setgid(__gid: __gid_t) c_int; +pub extern fn setregid(__rgid: __gid_t, __egid: __gid_t) c_int; +pub extern fn setegid(__gid: __gid_t) c_int; +pub extern fn fork() __pid_t; +pub extern fn vfork() c_int; +pub extern fn ttyname(__fd: c_int) [*c]u8; +pub extern fn ttyname_r(__fd: c_int, __buf: [*c]u8, __buflen: usize) c_int; +pub extern fn isatty(__fd: c_int) c_int; +pub extern fn ttyslot() c_int; +pub extern fn link(__from: [*c]const u8, __to: [*c]const u8) c_int; +pub extern fn linkat(__fromfd: c_int, __from: [*c]const u8, __tofd: c_int, __to: [*c]const u8, __flags: c_int) c_int; +pub extern fn symlink(__from: [*c]const u8, __to: [*c]const u8) c_int; +pub extern fn readlink(noalias __path: [*c]const u8, noalias __buf: [*c]u8, __len: usize) isize; +pub extern fn symlinkat(__from: [*c]const u8, __tofd: c_int, __to: [*c]const u8) c_int; +pub extern fn readlinkat(__fd: c_int, noalias __path: [*c]const u8, noalias __buf: [*c]u8, __len: usize) isize; +pub extern fn unlink(__name: [*c]const u8) c_int; +pub extern fn unlinkat(__fd: c_int, __name: [*c]const u8, __flag: c_int) c_int; +pub extern fn rmdir(__path: [*c]const u8) c_int; +pub extern fn tcgetpgrp(__fd: c_int) __pid_t; +pub extern fn tcsetpgrp(__fd: c_int, __pgrp_id: __pid_t) c_int; +pub extern fn getlogin() [*c]u8; +pub extern fn getlogin_r(__name: [*c]u8, __name_len: usize) c_int; +pub extern fn setlogin(__name: [*c]const u8) c_int; +pub extern var optarg: [*c]u8; +pub extern var optind: c_int; +pub extern var opterr: c_int; +pub extern var optopt: c_int; +pub extern fn getopt(___argc: c_int, ___argv: [*c]const [*c]u8, __shortopts: [*c]const u8) c_int; +pub extern fn gethostname(__name: [*c]u8, __len: usize) c_int; +pub extern fn sethostname(__name: [*c]const u8, __len: usize) c_int; +pub extern fn sethostid(__id: c_long) c_int; +pub extern fn getdomainname(__name: [*c]u8, __len: usize) c_int; +pub extern fn setdomainname(__name: [*c]const u8, __len: usize) c_int; +pub extern fn vhangup() c_int; +pub extern fn revoke(__file: [*c]const u8) c_int; +pub extern fn profil(__sample_buffer: [*c]c_ushort, __size: usize, __offset: usize, __scale: c_uint) c_int; +pub extern fn acct(__name: [*c]const u8) c_int; +pub extern fn getusershell() [*c]u8; +pub extern fn endusershell() void; +pub extern fn setusershell() void; +pub extern fn daemon(__nochdir: c_int, __noclose: c_int) c_int; +pub extern fn chroot(__path: [*c]const u8) c_int; +pub extern fn getpass(__prompt: [*c]const u8) [*c]u8; +pub extern fn fsync(__fd: c_int) c_int; +pub extern fn gethostid() c_long; +pub extern fn sync() void; +pub extern fn getpagesize() c_int; +pub extern fn getdtablesize() c_int; +pub extern fn truncate(__file: [*c]const u8, __length: __off_t) c_int; +pub extern fn ftruncate(__fd: c_int, __length: __off_t) c_int; +pub extern fn brk(__addr: ?*anyopaque) c_int; +pub extern fn sbrk(__delta: isize) ?*anyopaque; +pub extern fn syscall(__sysno: c_long, ...) c_long; +pub extern fn lockf(__fd: c_int, __cmd: c_int, __len: __off_t) c_int; +pub extern fn fdatasync(__fildes: c_int) c_int; +pub extern fn crypt(__key: [*c]const u8, __salt: [*c]const u8) [*c]u8; +pub extern fn getentropy(__buffer: ?*anyopaque, __length: usize) c_int; +pub fn _spa_autofree_cleanup_func(arg_p: ?*anyopaque) callconv(.c) void { + var p = arg_p; + _ = &p; + var save_errno: c_int = __errno_location().*; + _ = &save_errno; + free(@as([*c]?*anyopaque, @ptrCast(@alignCast(p))).*); + __errno_location().* = save_errno; +} +pub fn _spa_autoclose_cleanup_func(arg_fd: [*c]c_int) callconv(.c) void { + var fd = arg_fd; + _ = &fd; + var save_errno: c_int = __errno_location().*; + _ = &save_errno; + { + var _old_value: c_int = blk: { + var _ptr_: [*c]@TypeOf(fd.*) = &fd.*; + _ = &_ptr_; + var _old_value_: @TypeOf(fd.*) = _ptr_.*; + _ = &_old_value_; + _ptr_.* = -@as(c_int, 1); + break :blk _old_value_; + }; + _ = &_old_value; + var _res: c_int = 0; + _ = &_res; + if (_old_value >= @as(c_int, 0)) { + _res = close(_old_value); + } + _ = &_res; + } + __errno_location().* = save_errno; +} +pub const _spa_autoptr_cleanup_type_FILE = [*c]FILE; +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/cleanup.h:27:6: warning: unsupported bool expression type + +// (no file):157:1: warning: unable to translate function, demoted to extern +pub extern fn _spa_autoptr_cleanup_func_FILE(arg_thing: [*c][*c]FILE) callconv(.c) void; +pub const struct_dirent = extern struct { + d_ino: __ino_t = @import("std").mem.zeroes(__ino_t), + d_off: __off_t = @import("std").mem.zeroes(__off_t), + d_reclen: c_ushort = @import("std").mem.zeroes(c_ushort), + d_type: u8 = @import("std").mem.zeroes(u8), + d_name: [256]u8 = @import("std").mem.zeroes([256]u8), +}; +pub const DT_UNKNOWN: c_int = 0; +pub const DT_FIFO: c_int = 1; +pub const DT_CHR: c_int = 2; +pub const DT_DIR: c_int = 4; +pub const DT_BLK: c_int = 6; +pub const DT_REG: c_int = 8; +pub const DT_LNK: c_int = 10; +pub const DT_SOCK: c_int = 12; +pub const DT_WHT: c_int = 14; +const enum_unnamed_33 = c_uint; +pub const struct___dirstream = opaque {}; +pub const DIR = struct___dirstream; +pub extern fn closedir(__dirp: ?*DIR) c_int; +pub extern fn opendir(__name: [*c]const u8) ?*DIR; +pub extern fn fdopendir(__fd: c_int) ?*DIR; +pub extern fn readdir(__dirp: ?*DIR) [*c]struct_dirent; +pub extern fn readdir_r(noalias __dirp: ?*DIR, noalias __entry: [*c]struct_dirent, noalias __result: [*c][*c]struct_dirent) c_int; +pub extern fn rewinddir(__dirp: ?*DIR) void; +pub extern fn seekdir(__dirp: ?*DIR, __pos: c_long) void; +pub extern fn telldir(__dirp: ?*DIR) c_long; +pub extern fn dirfd(__dirp: ?*DIR) c_int; +pub extern fn scandir(noalias __dir: [*c]const u8, noalias __namelist: [*c][*c][*c]struct_dirent, __selector: ?*const fn ([*c]const struct_dirent) callconv(.c) c_int, __cmp: ?*const fn ([*c][*c]const struct_dirent, [*c][*c]const struct_dirent) callconv(.c) c_int) c_int; +pub extern fn alphasort(__e1: [*c][*c]const struct_dirent, __e2: [*c][*c]const struct_dirent) c_int; +pub extern fn getdirentries(__fd: c_int, noalias __buf: [*c]u8, __nbytes: usize, noalias __basep: [*c]__off_t) __ssize_t; +pub const _spa_autoptr_cleanup_type_DIR = [*c]DIR; +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/cleanup.h:27:6: warning: unsupported bool expression type + +// (no file):162:1: warning: unable to translate function, demoted to extern +pub extern fn _spa_autoptr_cleanup_func_DIR(arg_thing: [*c][*c]DIR) callconv(.c) void; +pub const struct_pw_properties = extern struct { + dict: struct_spa_dict = @import("std").mem.zeroes(struct_spa_dict), + flags: u32 = @import("std").mem.zeroes(u32), +}; +pub extern fn pw_properties_new(key: [*c]const u8, ...) [*c]struct_pw_properties; +pub extern fn pw_properties_new_dict(dict: [*c]const struct_spa_dict) [*c]struct_pw_properties; +pub extern fn pw_properties_new_string(args: [*c]const u8) [*c]struct_pw_properties; +pub extern fn pw_properties_new_string_checked(args: [*c]const u8, size: usize, loc: [*c]struct_spa_error_location) [*c]struct_pw_properties; +pub extern fn pw_properties_copy(properties: [*c]const struct_pw_properties) [*c]struct_pw_properties; +pub extern fn pw_properties_update_keys(props: [*c]struct_pw_properties, dict: [*c]const struct_spa_dict, keys: [*c]const [*c]const u8) c_int; +pub extern fn pw_properties_update_ignore(props: [*c]struct_pw_properties, dict: [*c]const struct_spa_dict, ignore: [*c]const [*c]const u8) c_int; +pub extern fn pw_properties_update(props: [*c]struct_pw_properties, dict: [*c]const struct_spa_dict) c_int; +pub extern fn pw_properties_update_string(props: [*c]struct_pw_properties, str: [*c]const u8, size: usize) c_int; +pub extern fn pw_properties_update_string_checked(props: [*c]struct_pw_properties, str: [*c]const u8, size: usize, loc: [*c]struct_spa_error_location) c_int; +pub extern fn pw_properties_add(oldprops: [*c]struct_pw_properties, dict: [*c]const struct_spa_dict) c_int; +pub extern fn pw_properties_add_keys(oldprops: [*c]struct_pw_properties, dict: [*c]const struct_spa_dict, keys: [*c]const [*c]const u8) c_int; +pub extern fn pw_properties_clear(properties: [*c]struct_pw_properties) void; +pub extern fn pw_properties_free(properties: [*c]struct_pw_properties) void; +pub extern fn pw_properties_set(properties: [*c]struct_pw_properties, key: [*c]const u8, value: [*c]const u8) c_int; +pub extern fn pw_properties_setf(properties: [*c]struct_pw_properties, key: [*c]const u8, format: [*c]const u8, ...) c_int; +pub extern fn pw_properties_setva(properties: [*c]struct_pw_properties, key: [*c]const u8, format: [*c]const u8, args: [*c]struct___va_list_tag_26) c_int; +pub extern fn pw_properties_get(properties: [*c]const struct_pw_properties, key: [*c]const u8) [*c]const u8; +pub extern fn pw_properties_fetch_uint32(properties: [*c]const struct_pw_properties, key: [*c]const u8, value: [*c]u32) c_int; +pub extern fn pw_properties_fetch_int32(properties: [*c]const struct_pw_properties, key: [*c]const u8, value: [*c]i32) c_int; +pub extern fn pw_properties_fetch_uint64(properties: [*c]const struct_pw_properties, key: [*c]const u8, value: [*c]u64) c_int; +pub extern fn pw_properties_fetch_int64(properties: [*c]const struct_pw_properties, key: [*c]const u8, value: [*c]i64) c_int; +pub extern fn pw_properties_fetch_bool(properties: [*c]const struct_pw_properties, key: [*c]const u8, value: [*c]bool) c_int; +pub fn pw_properties_get_uint32(arg_properties: [*c]const struct_pw_properties, arg_key: [*c]const u8, arg_deflt: u32) callconv(.c) u32 { + var properties = arg_properties; + _ = &properties; + var key = arg_key; + _ = &key; + var deflt = arg_deflt; + _ = &deflt; + var val: u32 = deflt; + _ = &val; + _ = pw_properties_fetch_uint32(properties, key, &val); + return val; +} +pub fn pw_properties_get_int32(arg_properties: [*c]const struct_pw_properties, arg_key: [*c]const u8, arg_deflt: i32) callconv(.c) i32 { + var properties = arg_properties; + _ = &properties; + var key = arg_key; + _ = &key; + var deflt = arg_deflt; + _ = &deflt; + var val: i32 = deflt; + _ = &val; + _ = pw_properties_fetch_int32(properties, key, &val); + return val; +} +pub fn pw_properties_get_uint64(arg_properties: [*c]const struct_pw_properties, arg_key: [*c]const u8, arg_deflt: u64) callconv(.c) u64 { + var properties = arg_properties; + _ = &properties; + var key = arg_key; + _ = &key; + var deflt = arg_deflt; + _ = &deflt; + var val: u64 = deflt; + _ = &val; + _ = pw_properties_fetch_uint64(properties, key, &val); + return val; +} +pub fn pw_properties_get_int64(arg_properties: [*c]const struct_pw_properties, arg_key: [*c]const u8, arg_deflt: i64) callconv(.c) i64 { + var properties = arg_properties; + _ = &properties; + var key = arg_key; + _ = &key; + var deflt = arg_deflt; + _ = &deflt; + var val: i64 = deflt; + _ = &val; + _ = pw_properties_fetch_int64(properties, key, &val); + return val; +} +pub fn pw_properties_get_bool(arg_properties: [*c]const struct_pw_properties, arg_key: [*c]const u8, arg_deflt: bool) callconv(.c) bool { + var properties = arg_properties; + _ = &properties; + var key = arg_key; + _ = &key; + var deflt = arg_deflt; + _ = &deflt; + var val: bool = deflt; + _ = &val; + _ = pw_properties_fetch_bool(properties, key, &val); + return val; +} +pub extern fn pw_properties_iterate(properties: [*c]const struct_pw_properties, state: [*c]?*anyopaque) [*c]const u8; +pub extern fn pw_properties_serialize_dict(f: [*c]FILE, dict: [*c]const struct_spa_dict, flags: u32) c_int; +pub fn pw_properties_parse_bool(arg_value: [*c]const u8) callconv(.c) bool { + var value = arg_value; + _ = &value; + return spa_atob(value); +} +pub fn pw_properties_parse_int(arg_value: [*c]const u8) callconv(.c) c_int { + var value = arg_value; + _ = &value; + var v: c_int = undefined; + _ = &v; + return if (@as(c_int, @intFromBool(spa_atoi32(value, &v, @as(c_int, 0)))) != 0) v else @as(c_int, 0); +} +pub fn pw_properties_parse_int64(arg_value: [*c]const u8) callconv(.c) i64 { + var value = arg_value; + _ = &value; + var v: i64 = undefined; + _ = &v; + return if (@as(c_int, @intFromBool(spa_atoi64(value, &v, @as(c_int, 0)))) != 0) v else @as(i64, @bitCast(@as(c_long, @as(c_int, 0)))); +} +pub fn pw_properties_parse_uint64(arg_value: [*c]const u8) callconv(.c) u64 { + var value = arg_value; + _ = &value; + var v: u64 = undefined; + _ = &v; + return if (@as(c_int, @intFromBool(spa_atou64(value, &v, @as(c_int, 0)))) != 0) v else @as(u64, @bitCast(@as(c_long, @as(c_int, 0)))); +} +pub fn pw_properties_parse_float(arg_value: [*c]const u8) callconv(.c) f32 { + var value = arg_value; + _ = &value; + var v: f32 = undefined; + _ = &v; + return if (@as(c_int, @intFromBool(spa_atof(value, &v))) != 0) v else 0.0; +} +pub fn pw_properties_parse_double(arg_value: [*c]const u8) callconv(.c) f64 { + var value = arg_value; + _ = &value; + var v: f64 = undefined; + _ = &v; + return if (@as(c_int, @intFromBool(spa_atod(value, &v))) != 0) v else 0.0; +} +pub const _spa_autoptr_cleanup_type_pw_properties = [*c]struct_pw_properties; +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/cleanup.h:27:6: warning: unsupported bool expression type + +// (no file):164:1: warning: unable to translate function, demoted to extern +pub extern fn _spa_autoptr_cleanup_func_pw_properties(arg_thing: [*c][*c]struct_pw_properties) callconv(.c) void; +pub extern fn pw_core_info_update(info: [*c]struct_pw_core_info, update: [*c]const struct_pw_core_info) [*c]struct_pw_core_info; +pub extern fn pw_core_info_merge(info: [*c]struct_pw_core_info, update: [*c]const struct_pw_core_info, reset: bool) [*c]struct_pw_core_info; +pub extern fn pw_core_info_free(info: [*c]struct_pw_core_info) void; +pub const struct_pw_core_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + info: ?*const fn (?*anyopaque, [*c]const struct_pw_core_info) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_pw_core_info) callconv(.c) void), + done: ?*const fn (?*anyopaque, u32, c_int) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, c_int) callconv(.c) void), + ping: ?*const fn (?*anyopaque, u32, c_int) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, c_int) callconv(.c) void), + @"error": ?*const fn (?*anyopaque, u32, c_int, c_int, [*c]const u8) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, c_int, c_int, [*c]const u8) callconv(.c) void), + remove_id: ?*const fn (?*anyopaque, u32) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32) callconv(.c) void), + bound_id: ?*const fn (?*anyopaque, u32, u32) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, u32) callconv(.c) void), + add_mem: ?*const fn (?*anyopaque, u32, u32, c_int, u32) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, u32, c_int, u32) callconv(.c) void), + remove_mem: ?*const fn (?*anyopaque, u32) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32) callconv(.c) void), + bound_props: ?*const fn (?*anyopaque, u32, u32, [*c]const struct_spa_dict) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, u32, [*c]const struct_spa_dict) callconv(.c) void), +}; +pub const struct_pw_core_methods = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + add_listener: ?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_core_events, ?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_core_events, ?*anyopaque) callconv(.c) c_int), + hello: ?*const fn (?*anyopaque, u32) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32) callconv(.c) c_int), + sync: ?*const fn (?*anyopaque, u32, c_int) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, c_int) callconv(.c) c_int), + pong: ?*const fn (?*anyopaque, u32, c_int) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, c_int) callconv(.c) c_int), + @"error": ?*const fn (?*anyopaque, u32, c_int, c_int, [*c]const u8) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, c_int, c_int, [*c]const u8) callconv(.c) c_int), + get_registry: ?*const fn (?*anyopaque, u32, usize) callconv(.c) ?*struct_pw_registry = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, usize) callconv(.c) ?*struct_pw_registry), + create_object: ?*const fn (?*anyopaque, [*c]const u8, [*c]const u8, u32, [*c]const struct_spa_dict, usize) callconv(.c) ?*anyopaque = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const u8, [*c]const u8, u32, [*c]const struct_spa_dict, usize) callconv(.c) ?*anyopaque), + destroy: ?*const fn (?*anyopaque, ?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, ?*anyopaque) callconv(.c) c_int), +}; +pub fn pw_core_add_listener(arg_object: ?*struct_pw_core, arg_listener: [*c]struct_spa_hook, arg_events: [*c]const struct_pw_core_events, arg_data: ?*anyopaque) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var listener = arg_listener; + _ = &listener; + var events = arg_events; + _ = &events; + var data = arg_data; + _ = &data; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_core_methods = @as([*c]const struct_pw_core_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_listener != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.add_listener.?((&_i.*.cb).*.data, listener, events, data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_core_hello(arg_object: ?*struct_pw_core, arg_version: u32) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var version = arg_version; + _ = &version; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_core_methods = @as([*c]const struct_pw_core_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.hello != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.hello.?((&_i.*.cb).*.data, version); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_core_sync(arg_object: ?*struct_pw_core, arg_id: u32, arg_seq: c_int) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var id = arg_id; + _ = &id; + var seq = arg_seq; + _ = &seq; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_core_methods = @as([*c]const struct_pw_core_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.sync != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.sync.?((&_i.*.cb).*.data, id, seq); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_core_pong(arg_object: ?*struct_pw_core, arg_id: u32, arg_seq: c_int) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var id = arg_id; + _ = &id; + var seq = arg_seq; + _ = &seq; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_core_methods = @as([*c]const struct_pw_core_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.pong != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.pong.?((&_i.*.cb).*.data, id, seq); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_core_error(arg_object: ?*struct_pw_core, arg_id: u32, arg_seq: c_int, arg_res: c_int, arg_message: [*c]const u8) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var id = arg_id; + _ = &id; + var seq = arg_seq; + _ = &seq; + var res = arg_res; + _ = &res; + var message = arg_message; + _ = &message; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_core_methods = @as([*c]const struct_pw_core_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.@"error" != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.@"error".?((&_i.*.cb).*.data, id, seq, res, message); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_core_errorv(arg_core: ?*struct_pw_core, arg_id: u32, arg_seq: c_int, arg_res: c_int, arg_message: [*c]const u8, arg_args: [*c]struct___va_list_tag_26) callconv(.c) c_int { + var core = arg_core; + _ = &core; + var id = arg_id; + _ = &id; + var seq = arg_seq; + _ = &seq; + var res = arg_res; + _ = &res; + var message = arg_message; + _ = &message; + var args = arg_args; + _ = &args; + var buffer: [1024]u8 = undefined; + _ = &buffer; + _ = vsnprintf(@as([*c]u8, @ptrCast(@alignCast(&buffer[@as(usize, @intCast(0))]))), @sizeOf([1024]u8), message, args); + buffer[@as(c_uint, @intCast(@as(c_int, 1023)))] = '\x00'; + return pw_core_error(core, id, seq, res, @as([*c]u8, @ptrCast(@alignCast(&buffer[@as(usize, @intCast(0))])))); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/core.h:403:1: warning: TODO unable to translate variadic function, demoted to extern +pub extern fn pw_core_errorf(core: ?*struct_pw_core, id: u32, seq: c_int, res: c_int, message: [*c]const u8, ...) c_int; +pub fn pw_core_get_registry(arg_core: ?*struct_pw_core, arg_version: u32, arg_user_data_size: usize) callconv(.c) ?*struct_pw_registry { + var core = arg_core; + _ = &core; + var version = arg_version; + _ = &version; + var user_data_size = arg_user_data_size; + _ = &user_data_size; + return blk: { + var _res: ?*struct_pw_registry = null; + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(core))); + _ = &_i; + { + var _f: [*c]const struct_pw_core_methods = @as([*c]const struct_pw_core_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.get_registry != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.get_registry.?((&_i.*.cb).*.data, version, user_data_size); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_core_create_object(arg_core: ?*struct_pw_core, arg_factory_name: [*c]const u8, arg_type: [*c]const u8, arg_version: u32, arg_props: [*c]const struct_spa_dict, arg_user_data_size: usize) callconv(.c) ?*anyopaque { + var core = arg_core; + _ = &core; + var factory_name = arg_factory_name; + _ = &factory_name; + var @"type" = arg_type; + _ = &@"type"; + var version = arg_version; + _ = &version; + var props = arg_props; + _ = &props; + var user_data_size = arg_user_data_size; + _ = &user_data_size; + return blk: { + var _res: ?*anyopaque = @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(core))); + _ = &_i; + { + var _f: [*c]const struct_pw_core_methods = @as([*c]const struct_pw_core_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.create_object != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.create_object.?((&_i.*.cb).*.data, factory_name, @"type", version, props, user_data_size); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_core_destroy(arg_core: ?*struct_pw_core, arg_proxy: ?*anyopaque) callconv(.c) void { + var core = arg_core; + _ = &core; + var proxy = arg_proxy; + _ = &proxy; + { + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(core))); + _ = &_i; + { + var _f: [*c]const struct_pw_core_methods = @as([*c]const struct_pw_core_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + var _res: bool = ((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.destroy != null); + _ = &_res; + if (__builtin_expect(@as(c_long, @intFromBool(!!_res)), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _ = _f.*.destroy.?((&_i.*.cb).*.data, proxy); + } + _ = &_res; + } + } +} +pub const struct_pw_registry_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + global: ?*const fn (?*anyopaque, u32, u32, [*c]const u8, u32, [*c]const struct_spa_dict) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, u32, [*c]const u8, u32, [*c]const struct_spa_dict) callconv(.c) void), + global_remove: ?*const fn (?*anyopaque, u32) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32) callconv(.c) void), +}; +pub const struct_pw_registry_methods = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + add_listener: ?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_registry_events, ?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_registry_events, ?*anyopaque) callconv(.c) c_int), + bind: ?*const fn (?*anyopaque, u32, [*c]const u8, u32, usize) callconv(.c) ?*anyopaque = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, [*c]const u8, u32, usize) callconv(.c) ?*anyopaque), + destroy: ?*const fn (?*anyopaque, u32) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32) callconv(.c) c_int), +}; +pub fn pw_registry_add_listener(arg_registry: ?*struct_pw_registry, arg_listener: [*c]struct_spa_hook, arg_events: [*c]const struct_pw_registry_events, arg_data: ?*anyopaque) callconv(.c) c_int { + var registry = arg_registry; + _ = ®istry; + var listener = arg_listener; + _ = &listener; + var events = arg_events; + _ = &events; + var data = arg_data; + _ = &data; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(registry))); + _ = &_i; + { + var _f: [*c]const struct_pw_registry_methods = @as([*c]const struct_pw_registry_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_listener != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.add_listener.?((&_i.*.cb).*.data, listener, events, data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_registry_bind(arg_registry: ?*struct_pw_registry, arg_id: u32, arg_type: [*c]const u8, arg_version: u32, arg_user_data_size: usize) callconv(.c) ?*anyopaque { + var registry = arg_registry; + _ = ®istry; + var id = arg_id; + _ = &id; + var @"type" = arg_type; + _ = &@"type"; + var version = arg_version; + _ = &version; + var user_data_size = arg_user_data_size; + _ = &user_data_size; + return blk: { + var _res: ?*anyopaque = @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(registry))); + _ = &_i; + { + var _f: [*c]const struct_pw_registry_methods = @as([*c]const struct_pw_registry_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.bind != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.bind.?((&_i.*.cb).*.data, id, @"type", version, user_data_size); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_registry_destroy(arg_registry: ?*struct_pw_registry, arg_id: u32) callconv(.c) c_int { + var registry = arg_registry; + _ = ®istry; + var id = arg_id; + _ = &id; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(registry))); + _ = &_i; + { + var _f: [*c]const struct_pw_registry_methods = @as([*c]const struct_pw_registry_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.destroy != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.destroy.?((&_i.*.cb).*.data, id); + } + _ = &_res; + } + break :blk _res; + }; +} +pub extern fn pw_context_connect(context: ?*struct_pw_context, properties: [*c]struct_pw_properties, user_data_size: usize) ?*struct_pw_core; +pub extern fn pw_context_connect_fd(context: ?*struct_pw_context, fd: c_int, properties: [*c]struct_pw_properties, user_data_size: usize) ?*struct_pw_core; +pub extern fn pw_context_connect_self(context: ?*struct_pw_context, properties: [*c]struct_pw_properties, user_data_size: usize) ?*struct_pw_core; +pub extern fn pw_core_steal_fd(core: ?*struct_pw_core) c_int; +pub extern fn pw_core_set_paused(core: ?*struct_pw_core, paused: bool) c_int; +pub extern fn pw_core_disconnect(core: ?*struct_pw_core) c_int; +pub extern fn pw_core_get_user_data(core: ?*struct_pw_core) ?*anyopaque; +pub const struct_pw_client = opaque {}; +pub extern fn pw_core_get_client(core: ?*struct_pw_core) ?*struct_pw_client; +pub extern fn pw_core_get_context(core: ?*struct_pw_core) ?*struct_pw_context; +pub extern fn pw_core_get_properties(core: ?*struct_pw_core) [*c]const struct_pw_properties; +pub extern fn pw_core_update_properties(core: ?*struct_pw_core, dict: [*c]const struct_spa_dict) c_int; +pub const struct_pw_mempool = extern struct { + props: [*c]struct_pw_properties = @import("std").mem.zeroes([*c]struct_pw_properties), +}; +pub extern fn pw_core_get_mempool(core: ?*struct_pw_core) [*c]struct_pw_mempool; +pub extern fn pw_core_find_proxy(core: ?*struct_pw_core, id: u32) ?*struct_pw_proxy; +pub extern fn pw_core_export(core: ?*struct_pw_core, @"type": [*c]const u8, props: [*c]const struct_spa_dict, object: ?*anyopaque, user_data_size: usize) ?*struct_pw_proxy; +pub const struct_tm = extern struct { + tm_sec: c_int = @import("std").mem.zeroes(c_int), + tm_min: c_int = @import("std").mem.zeroes(c_int), + tm_hour: c_int = @import("std").mem.zeroes(c_int), + tm_mday: c_int = @import("std").mem.zeroes(c_int), + tm_mon: c_int = @import("std").mem.zeroes(c_int), + tm_year: c_int = @import("std").mem.zeroes(c_int), + tm_wday: c_int = @import("std").mem.zeroes(c_int), + tm_yday: c_int = @import("std").mem.zeroes(c_int), + tm_isdst: c_int = @import("std").mem.zeroes(c_int), + tm_gmtoff: c_long = @import("std").mem.zeroes(c_long), + tm_zone: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), +}; +pub const struct_itimerspec = extern struct { + it_interval: struct_timespec = @import("std").mem.zeroes(struct_timespec), + it_value: struct_timespec = @import("std").mem.zeroes(struct_timespec), +}; +pub extern fn clock() clock_t; +pub extern fn time(__timer: [*c]time_t) time_t; +pub extern fn difftime(__time1: time_t, __time0: time_t) f64; +pub extern fn mktime(__tp: [*c]struct_tm) time_t; +pub extern fn strftime(noalias __s: [*c]u8, __maxsize: usize, noalias __format: [*c]const u8, noalias __tp: [*c]const struct_tm) usize; +pub extern fn strftime_l(noalias __s: [*c]u8, __maxsize: usize, noalias __format: [*c]const u8, noalias __tp: [*c]const struct_tm, __loc: locale_t) usize; +pub extern fn gmtime(__timer: [*c]const time_t) [*c]struct_tm; +pub extern fn localtime(__timer: [*c]const time_t) [*c]struct_tm; +pub extern fn gmtime_r(noalias __timer: [*c]const time_t, noalias __tp: [*c]struct_tm) [*c]struct_tm; +pub extern fn localtime_r(noalias __timer: [*c]const time_t, noalias __tp: [*c]struct_tm) [*c]struct_tm; +pub extern fn asctime(__tp: [*c]const struct_tm) [*c]u8; +pub extern fn ctime(__timer: [*c]const time_t) [*c]u8; +pub extern fn asctime_r(noalias __tp: [*c]const struct_tm, noalias __buf: [*c]u8) [*c]u8; +pub extern fn ctime_r(noalias __timer: [*c]const time_t, noalias __buf: [*c]u8) [*c]u8; +pub extern var __tzname: [2][*c]u8; +pub extern var __daylight: c_int; +pub extern var __timezone: c_long; +pub extern var tzname: [2][*c]u8; +pub extern fn tzset() void; +pub extern var daylight: c_int; +pub extern var timezone: c_long; +pub extern fn timegm(__tp: [*c]struct_tm) time_t; +pub extern fn timelocal(__tp: [*c]struct_tm) time_t; +pub extern fn dysize(__year: c_int) c_int; +pub extern fn nanosleep(__requested_time: [*c]const struct_timespec, __remaining: [*c]struct_timespec) c_int; +pub extern fn clock_getres(__clock_id: clockid_t, __res: [*c]struct_timespec) c_int; +pub extern fn clock_gettime(__clock_id: clockid_t, __tp: [*c]struct_timespec) c_int; +pub extern fn clock_settime(__clock_id: clockid_t, __tp: [*c]const struct_timespec) c_int; +pub extern fn clock_nanosleep(__clock_id: clockid_t, __flags: c_int, __req: [*c]const struct_timespec, __rem: [*c]struct_timespec) c_int; +pub extern fn clock_getcpuclockid(__pid: pid_t, __clock_id: [*c]clockid_t) c_int; +pub extern fn timer_create(__clock_id: clockid_t, noalias __evp: [*c]struct_sigevent, noalias __timerid: [*c]timer_t) c_int; +pub extern fn timer_delete(__timerid: timer_t) c_int; +pub extern fn timer_settime(__timerid: timer_t, __flags: c_int, noalias __value: [*c]const struct_itimerspec, noalias __ovalue: [*c]struct_itimerspec) c_int; +pub extern fn timer_gettime(__timerid: timer_t, __value: [*c]struct_itimerspec) c_int; +pub extern fn timer_getoverrun(__timerid: timer_t) c_int; +pub extern fn timespec_get(__ts: [*c]struct_timespec, __base: c_int) c_int; +pub const struct_spa_system = extern struct { + iface: struct_spa_interface = @import("std").mem.zeroes(struct_spa_interface), +}; +pub const struct_spa_poll_event = extern struct { + events: u32 = @import("std").mem.zeroes(u32), + data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), +}; +pub const struct_spa_system_methods = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + read: ?*const fn (?*anyopaque, c_int, ?*anyopaque, usize) callconv(.c) isize = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, ?*anyopaque, usize) callconv(.c) isize), + write: ?*const fn (?*anyopaque, c_int, ?*const anyopaque, usize) callconv(.c) isize = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, ?*const anyopaque, usize) callconv(.c) isize), + ioctl: ?*const fn (?*anyopaque, c_int, c_ulong, ...) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, c_ulong, ...) callconv(.c) c_int), + close: ?*const fn (?*anyopaque, c_int) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int) callconv(.c) c_int), + clock_gettime: ?*const fn (?*anyopaque, c_int, [*c]struct_timespec) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, [*c]struct_timespec) callconv(.c) c_int), + clock_getres: ?*const fn (?*anyopaque, c_int, [*c]struct_timespec) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, [*c]struct_timespec) callconv(.c) c_int), + pollfd_create: ?*const fn (?*anyopaque, c_int) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int) callconv(.c) c_int), + pollfd_add: ?*const fn (?*anyopaque, c_int, c_int, u32, ?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, c_int, u32, ?*anyopaque) callconv(.c) c_int), + pollfd_mod: ?*const fn (?*anyopaque, c_int, c_int, u32, ?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, c_int, u32, ?*anyopaque) callconv(.c) c_int), + pollfd_del: ?*const fn (?*anyopaque, c_int, c_int) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, c_int) callconv(.c) c_int), + pollfd_wait: ?*const fn (?*anyopaque, c_int, [*c]struct_spa_poll_event, c_int, c_int) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, [*c]struct_spa_poll_event, c_int, c_int) callconv(.c) c_int), + timerfd_create: ?*const fn (?*anyopaque, c_int, c_int) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, c_int) callconv(.c) c_int), + timerfd_settime: ?*const fn (?*anyopaque, c_int, c_int, [*c]const struct_itimerspec, [*c]struct_itimerspec) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, c_int, [*c]const struct_itimerspec, [*c]struct_itimerspec) callconv(.c) c_int), + timerfd_gettime: ?*const fn (?*anyopaque, c_int, [*c]struct_itimerspec) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, [*c]struct_itimerspec) callconv(.c) c_int), + timerfd_read: ?*const fn (?*anyopaque, c_int, [*c]u64) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, [*c]u64) callconv(.c) c_int), + eventfd_create: ?*const fn (?*anyopaque, c_int) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int) callconv(.c) c_int), + eventfd_write: ?*const fn (?*anyopaque, c_int, u64) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, u64) callconv(.c) c_int), + eventfd_read: ?*const fn (?*anyopaque, c_int, [*c]u64) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, [*c]u64) callconv(.c) c_int), + signalfd_create: ?*const fn (?*anyopaque, c_int, c_int) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, c_int) callconv(.c) c_int), + signalfd_read: ?*const fn (?*anyopaque, c_int, [*c]c_int) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, [*c]c_int) callconv(.c) c_int), +}; +pub fn spa_system_read(arg_object: [*c]struct_spa_system, arg_fd: c_int, arg_buf: ?*anyopaque, arg_count: usize) callconv(.c) isize { + var object = arg_object; + _ = &object; + var fd = arg_fd; + _ = &fd; + var buf = arg_buf; + _ = &buf; + var count = arg_count; + _ = &count; + return blk: { + var _res: isize = @as(isize, @bitCast(@as(c_long, -@as(c_int, 95)))); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.read.?((&_i.*.cb).*.data, fd, buf, count); + } + break :blk _res; + }; +} +pub fn spa_system_write(arg_object: [*c]struct_spa_system, arg_fd: c_int, arg_buf: ?*const anyopaque, arg_count: usize) callconv(.c) isize { + var object = arg_object; + _ = &object; + var fd = arg_fd; + _ = &fd; + var buf = arg_buf; + _ = &buf; + var count = arg_count; + _ = &count; + return blk: { + var _res: isize = @as(isize, @bitCast(@as(c_long, -@as(c_int, 95)))); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.write.?((&_i.*.cb).*.data, fd, buf, count); + } + break :blk _res; + }; +} +pub fn spa_system_close(arg_object: [*c]struct_spa_system, arg_fd: c_int) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var fd = arg_fd; + _ = &fd; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.close.?((&_i.*.cb).*.data, fd); + } + break :blk _res; + }; +} +pub fn spa_system_clock_gettime(arg_object: [*c]struct_spa_system, arg_clockid: c_int, arg_value: [*c]struct_timespec) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var clockid = arg_clockid; + _ = &clockid; + var value = arg_value; + _ = &value; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.clock_gettime.?((&_i.*.cb).*.data, clockid, value); + } + break :blk _res; + }; +} +pub fn spa_system_clock_getres(arg_object: [*c]struct_spa_system, arg_clockid: c_int, arg_res: [*c]struct_timespec) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var clockid = arg_clockid; + _ = &clockid; + var res = arg_res; + _ = &res; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.clock_getres.?((&_i.*.cb).*.data, clockid, res); + } + break :blk _res; + }; +} +pub fn spa_system_pollfd_create(arg_object: [*c]struct_spa_system, arg_flags: c_int) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var flags = arg_flags; + _ = &flags; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.pollfd_create.?((&_i.*.cb).*.data, flags); + } + break :blk _res; + }; +} +pub fn spa_system_pollfd_add(arg_object: [*c]struct_spa_system, arg_pfd: c_int, arg_fd: c_int, arg_events: u32, arg_data: ?*anyopaque) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var pfd = arg_pfd; + _ = &pfd; + var fd = arg_fd; + _ = &fd; + var events = arg_events; + _ = &events; + var data = arg_data; + _ = &data; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.pollfd_add.?((&_i.*.cb).*.data, pfd, fd, events, data); + } + break :blk _res; + }; +} +pub fn spa_system_pollfd_mod(arg_object: [*c]struct_spa_system, arg_pfd: c_int, arg_fd: c_int, arg_events: u32, arg_data: ?*anyopaque) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var pfd = arg_pfd; + _ = &pfd; + var fd = arg_fd; + _ = &fd; + var events = arg_events; + _ = &events; + var data = arg_data; + _ = &data; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.pollfd_mod.?((&_i.*.cb).*.data, pfd, fd, events, data); + } + break :blk _res; + }; +} +pub fn spa_system_pollfd_del(arg_object: [*c]struct_spa_system, arg_pfd: c_int, arg_fd: c_int) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var pfd = arg_pfd; + _ = &pfd; + var fd = arg_fd; + _ = &fd; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.pollfd_del.?((&_i.*.cb).*.data, pfd, fd); + } + break :blk _res; + }; +} +pub fn spa_system_pollfd_wait(arg_object: [*c]struct_spa_system, arg_pfd: c_int, arg_ev: [*c]struct_spa_poll_event, arg_n_ev: c_int, arg_timeout: c_int) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var pfd = arg_pfd; + _ = &pfd; + var ev = arg_ev; + _ = &ev; + var n_ev = arg_n_ev; + _ = &n_ev; + var timeout = arg_timeout; + _ = &timeout; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.pollfd_wait.?((&_i.*.cb).*.data, pfd, ev, n_ev, timeout); + } + break :blk _res; + }; +} +pub fn spa_system_timerfd_create(arg_object: [*c]struct_spa_system, arg_clockid: c_int, arg_flags: c_int) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var clockid = arg_clockid; + _ = &clockid; + var flags = arg_flags; + _ = &flags; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.timerfd_create.?((&_i.*.cb).*.data, clockid, flags); + } + break :blk _res; + }; +} +pub fn spa_system_timerfd_settime(arg_object: [*c]struct_spa_system, arg_fd: c_int, arg_flags: c_int, arg_new_value: [*c]const struct_itimerspec, arg_old_value: [*c]struct_itimerspec) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var fd = arg_fd; + _ = &fd; + var flags = arg_flags; + _ = &flags; + var new_value = arg_new_value; + _ = &new_value; + var old_value = arg_old_value; + _ = &old_value; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.timerfd_settime.?((&_i.*.cb).*.data, fd, flags, new_value, old_value); + } + break :blk _res; + }; +} +pub fn spa_system_timerfd_gettime(arg_object: [*c]struct_spa_system, arg_fd: c_int, arg_curr_value: [*c]struct_itimerspec) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var fd = arg_fd; + _ = &fd; + var curr_value = arg_curr_value; + _ = &curr_value; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.timerfd_gettime.?((&_i.*.cb).*.data, fd, curr_value); + } + break :blk _res; + }; +} +pub fn spa_system_timerfd_read(arg_object: [*c]struct_spa_system, arg_fd: c_int, arg_expirations: [*c]u64) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var fd = arg_fd; + _ = &fd; + var expirations = arg_expirations; + _ = &expirations; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.timerfd_read.?((&_i.*.cb).*.data, fd, expirations); + } + break :blk _res; + }; +} +pub fn spa_system_eventfd_create(arg_object: [*c]struct_spa_system, arg_flags: c_int) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var flags = arg_flags; + _ = &flags; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.eventfd_create.?((&_i.*.cb).*.data, flags); + } + break :blk _res; + }; +} +pub fn spa_system_eventfd_write(arg_object: [*c]struct_spa_system, arg_fd: c_int, arg_count: u64) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var fd = arg_fd; + _ = &fd; + var count = arg_count; + _ = &count; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.eventfd_write.?((&_i.*.cb).*.data, fd, count); + } + break :blk _res; + }; +} +pub fn spa_system_eventfd_read(arg_object: [*c]struct_spa_system, arg_fd: c_int, arg_count: [*c]u64) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var fd = arg_fd; + _ = &fd; + var count = arg_count; + _ = &count; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.eventfd_read.?((&_i.*.cb).*.data, fd, count); + } + break :blk _res; + }; +} +pub fn spa_system_signalfd_create(arg_object: [*c]struct_spa_system, arg_signal_1: c_int, arg_flags: c_int) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var signal_1 = arg_signal_1; + _ = &signal_1; + var flags = arg_flags; + _ = &flags; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.signalfd_create.?((&_i.*.cb).*.data, signal_1, flags); + } + break :blk _res; + }; +} +pub fn spa_system_signalfd_read(arg_object: [*c]struct_spa_system, arg_fd: c_int, arg_signal_1: [*c]c_int) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var fd = arg_fd; + _ = &fd; + var signal_1 = arg_signal_1; + _ = &signal_1; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_system_methods = @as([*c]const struct_spa_system_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.signalfd_read.?((&_i.*.cb).*.data, fd, signal_1); + } + break :blk _res; + }; +} +pub const struct_spa_loop = extern struct { + iface: struct_spa_interface = @import("std").mem.zeroes(struct_spa_interface), +}; +pub const struct_spa_loop_control = extern struct { + iface: struct_spa_interface = @import("std").mem.zeroes(struct_spa_interface), +}; +pub const struct_spa_loop_utils = extern struct { + iface: struct_spa_interface = @import("std").mem.zeroes(struct_spa_interface), +}; +pub const spa_source_func_t = ?*const fn ([*c]struct_spa_source) callconv(.c) void; +pub const struct_spa_source = extern struct { + loop: [*c]struct_spa_loop = @import("std").mem.zeroes([*c]struct_spa_loop), + func: spa_source_func_t = @import("std").mem.zeroes(spa_source_func_t), + data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + fd: c_int = @import("std").mem.zeroes(c_int), + mask: u32 = @import("std").mem.zeroes(u32), + rmask: u32 = @import("std").mem.zeroes(u32), + priv: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), +}; +pub const spa_invoke_func_t = ?*const fn ([*c]struct_spa_loop, bool, u32, ?*const anyopaque, usize, ?*anyopaque) callconv(.c) c_int; +pub const struct_spa_loop_methods = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + add_source: ?*const fn (?*anyopaque, [*c]struct_spa_source) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_source) callconv(.c) c_int), + update_source: ?*const fn (?*anyopaque, [*c]struct_spa_source) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_source) callconv(.c) c_int), + remove_source: ?*const fn (?*anyopaque, [*c]struct_spa_source) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_source) callconv(.c) c_int), + invoke: ?*const fn (?*anyopaque, spa_invoke_func_t, u32, ?*const anyopaque, usize, bool, ?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, spa_invoke_func_t, u32, ?*const anyopaque, usize, bool, ?*anyopaque) callconv(.c) c_int), + locked: ?*const fn (?*anyopaque, spa_invoke_func_t, u32, ?*const anyopaque, usize, ?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, spa_invoke_func_t, u32, ?*const anyopaque, usize, ?*anyopaque) callconv(.c) c_int), +}; +pub fn spa_loop_add_source(arg_object: [*c]struct_spa_loop, arg_source: [*c]struct_spa_source) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var source = arg_source; + _ = &source; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_methods = @as([*c]const struct_spa_loop_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_source != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.add_source.?((&_i.*.cb).*.data, source); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_update_source(arg_object: [*c]struct_spa_loop, arg_source: [*c]struct_spa_source) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var source = arg_source; + _ = &source; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_methods = @as([*c]const struct_spa_loop_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.update_source != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.update_source.?((&_i.*.cb).*.data, source); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_remove_source(arg_object: [*c]struct_spa_loop, arg_source: [*c]struct_spa_source) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var source = arg_source; + _ = &source; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_methods = @as([*c]const struct_spa_loop_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.remove_source != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.remove_source.?((&_i.*.cb).*.data, source); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_invoke(arg_object: [*c]struct_spa_loop, arg_func: spa_invoke_func_t, arg_seq: u32, arg_data: ?*const anyopaque, arg_size: usize, arg_block: bool, arg_user_data: ?*anyopaque) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var func = arg_func; + _ = &func; + var seq = arg_seq; + _ = &seq; + var data = arg_data; + _ = &data; + var size = arg_size; + _ = &size; + var block = arg_block; + _ = █ + var user_data = arg_user_data; + _ = &user_data; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_methods = @as([*c]const struct_spa_loop_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.invoke != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.invoke.?((&_i.*.cb).*.data, func, seq, data, size, block, user_data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_locked(arg_object: [*c]struct_spa_loop, arg_func: spa_invoke_func_t, arg_seq: u32, arg_data: ?*const anyopaque, arg_size: usize, arg_user_data: ?*anyopaque) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var func = arg_func; + _ = &func; + var seq = arg_seq; + _ = &seq; + var data = arg_data; + _ = &data; + var size = arg_size; + _ = &size; + var user_data = arg_user_data; + _ = &user_data; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_methods = @as([*c]const struct_spa_loop_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.locked != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.locked.?((&_i.*.cb).*.data, func, seq, data, size, user_data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub const struct_spa_loop_control_hooks = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + before: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), + after: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), +}; +pub fn spa_loop_control_hook_before(arg_l: [*c]struct_spa_hook_list) callconv(.c) void { + var l = arg_l; + _ = &l; + var h: [*c]struct_spa_hook = undefined; + _ = &h; + { + h = @as([*c]@TypeOf(h.*), @ptrFromInt(@as(usize, @intCast(@intFromPtr((&l.*.list).*.prev))) -% @offsetOf(struct_spa_hook, "link"))); + while (!((&h.*.link) == (&l.*.list))) : (h = @as([*c]@TypeOf(h.*), @ptrFromInt(@as(usize, @intCast(@intFromPtr(h.*.link.prev))) -% @offsetOf(struct_spa_hook, "link")))) { + { + var _f: [*c]const struct_spa_loop_control_hooks = @as([*c]const struct_spa_loop_control_hooks, @ptrCast(@alignCast((&h.*.cb).*.funcs))); + _ = &_f; + _f.*.before.?((&h.*.cb).*.data); + _ = @as(c_int, 1); + } + } + } +} +pub fn spa_loop_control_hook_after(arg_l: [*c]struct_spa_hook_list) callconv(.c) void { + var l = arg_l; + _ = &l; + var h: [*c]struct_spa_hook = undefined; + _ = &h; + { + h = @as([*c]@TypeOf(h.*), @ptrFromInt(@as(usize, @intCast(@intFromPtr((&l.*.list).*.next))) -% @offsetOf(struct_spa_hook, "link"))); + while (!((&h.*.link) == (&l.*.list))) : (h = @as([*c]@TypeOf(h.*), @ptrFromInt(@as(usize, @intCast(@intFromPtr(h.*.link.next))) -% @offsetOf(struct_spa_hook, "link")))) { + { + var _f: [*c]const struct_spa_loop_control_hooks = @as([*c]const struct_spa_loop_control_hooks, @ptrCast(@alignCast((&h.*.cb).*.funcs))); + _ = &_f; + _f.*.after.?((&h.*.cb).*.data); + _ = @as(c_int, 1); + } + } + } +} +pub const struct_spa_loop_control_methods = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + get_fd: ?*const fn (?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) c_int), + add_hook: ?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_spa_loop_control_hooks, ?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_spa_loop_control_hooks, ?*anyopaque) callconv(.c) void), + enter: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), + leave: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), + iterate: ?*const fn (?*anyopaque, c_int) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int) callconv(.c) c_int), + check: ?*const fn (?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) c_int), + lock: ?*const fn (?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) c_int), + unlock: ?*const fn (?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) c_int), + get_time: ?*const fn (?*anyopaque, [*c]struct_timespec, i64) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_timespec, i64) callconv(.c) c_int), + wait: ?*const fn (?*anyopaque, [*c]const struct_timespec) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_timespec) callconv(.c) c_int), + signal: ?*const fn (?*anyopaque, bool) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, bool) callconv(.c) c_int), + accept: ?*const fn (?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) c_int), +}; +pub fn spa_loop_control_get_fd(arg_object: [*c]struct_spa_loop_control) callconv(.c) c_int { + var object = arg_object; + _ = &object; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_control_methods = @as([*c]const struct_spa_loop_control_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.get_fd != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.get_fd.?((&_i.*.cb).*.data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_control_add_hook(arg_object: [*c]struct_spa_loop_control, arg_hook: [*c]struct_spa_hook, arg_hooks: [*c]const struct_spa_loop_control_hooks, arg_data: ?*anyopaque) callconv(.c) void { + var object = arg_object; + _ = &object; + var hook = arg_hook; + _ = &hook; + var hooks = arg_hooks; + _ = &hooks; + var data = arg_data; + _ = &data; + { + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_control_methods = @as([*c]const struct_spa_loop_control_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + var _res: bool = ((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_hook != null); + _ = &_res; + if (__builtin_expect(@as(c_long, @intFromBool(!!_res)), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _f.*.add_hook.?((&_i.*.cb).*.data, hook, hooks, data); + } + _ = &_res; + } + } +} +pub fn spa_loop_control_enter(arg_object: [*c]struct_spa_loop_control) callconv(.c) void { + var object = arg_object; + _ = &object; + { + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_control_methods = @as([*c]const struct_spa_loop_control_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + var _res: bool = ((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.enter != null); + _ = &_res; + if (__builtin_expect(@as(c_long, @intFromBool(!!_res)), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _f.*.enter.?((&_i.*.cb).*.data); + } + _ = &_res; + } + } +} +pub fn spa_loop_control_leave(arg_object: [*c]struct_spa_loop_control) callconv(.c) void { + var object = arg_object; + _ = &object; + { + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_control_methods = @as([*c]const struct_spa_loop_control_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + var _res: bool = ((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.leave != null); + _ = &_res; + if (__builtin_expect(@as(c_long, @intFromBool(!!_res)), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _f.*.leave.?((&_i.*.cb).*.data); + } + _ = &_res; + } + } +} +pub fn spa_loop_control_iterate(arg_object: [*c]struct_spa_loop_control, arg_timeout: c_int) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var timeout = arg_timeout; + _ = &timeout; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_control_methods = @as([*c]const struct_spa_loop_control_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.iterate != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.iterate.?((&_i.*.cb).*.data, timeout); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_control_iterate_fast(arg_object: [*c]struct_spa_loop_control, arg_timeout: c_int) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var timeout = arg_timeout; + _ = &timeout; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_control_methods = @as([*c]const struct_spa_loop_control_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.iterate.?((&_i.*.cb).*.data, timeout); + } + break :blk _res; + }; +} +pub fn spa_loop_control_check(arg_object: [*c]struct_spa_loop_control) callconv(.c) c_int { + var object = arg_object; + _ = &object; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_control_methods = @as([*c]const struct_spa_loop_control_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 1) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 1) - @as(c_int, 1)))))) and (_f.*.check != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.check.?((&_i.*.cb).*.data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_control_lock(arg_object: [*c]struct_spa_loop_control) callconv(.c) c_int { + var object = arg_object; + _ = &object; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_control_methods = @as([*c]const struct_spa_loop_control_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 2) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 2) - @as(c_int, 1)))))) and (_f.*.lock != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.lock.?((&_i.*.cb).*.data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_control_unlock(arg_object: [*c]struct_spa_loop_control) callconv(.c) c_int { + var object = arg_object; + _ = &object; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_control_methods = @as([*c]const struct_spa_loop_control_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 2) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 2) - @as(c_int, 1)))))) and (_f.*.unlock != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.unlock.?((&_i.*.cb).*.data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_control_get_time(arg_object: [*c]struct_spa_loop_control, arg_abstime: [*c]struct_timespec, arg_timeout: i64) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var abstime = arg_abstime; + _ = &abstime; + var timeout = arg_timeout; + _ = &timeout; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_control_methods = @as([*c]const struct_spa_loop_control_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 2) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 2) - @as(c_int, 1)))))) and (_f.*.get_time != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.get_time.?((&_i.*.cb).*.data, abstime, timeout); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_control_wait(arg_object: [*c]struct_spa_loop_control, arg_abstime: [*c]const struct_timespec) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var abstime = arg_abstime; + _ = &abstime; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_control_methods = @as([*c]const struct_spa_loop_control_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 2) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 2) - @as(c_int, 1)))))) and (_f.*.wait != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.wait.?((&_i.*.cb).*.data, abstime); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_control_signal(arg_object: [*c]struct_spa_loop_control, arg_wait_for_accept: bool) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var wait_for_accept = arg_wait_for_accept; + _ = &wait_for_accept; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_control_methods = @as([*c]const struct_spa_loop_control_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 2) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 2) - @as(c_int, 1)))))) and (_f.*.signal != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.signal.?((&_i.*.cb).*.data, wait_for_accept); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_control_accept(arg_object: [*c]struct_spa_loop_control) callconv(.c) c_int { + var object = arg_object; + _ = &object; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_control_methods = @as([*c]const struct_spa_loop_control_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 2) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 2) - @as(c_int, 1)))))) and (_f.*.accept != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.accept.?((&_i.*.cb).*.data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub const spa_source_io_func_t = ?*const fn (?*anyopaque, c_int, u32) callconv(.c) void; +pub const spa_source_idle_func_t = ?*const fn (?*anyopaque) callconv(.c) void; +pub const spa_source_event_func_t = ?*const fn (?*anyopaque, u64) callconv(.c) void; +pub const spa_source_timer_func_t = ?*const fn (?*anyopaque, u64) callconv(.c) void; +pub const spa_source_signal_func_t = ?*const fn (?*anyopaque, c_int) callconv(.c) void; +pub const struct_spa_loop_utils_methods = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + add_io: ?*const fn (?*anyopaque, c_int, u32, bool, spa_source_io_func_t, ?*anyopaque) callconv(.c) [*c]struct_spa_source = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, u32, bool, spa_source_io_func_t, ?*anyopaque) callconv(.c) [*c]struct_spa_source), + update_io: ?*const fn (?*anyopaque, [*c]struct_spa_source, u32) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_source, u32) callconv(.c) c_int), + add_idle: ?*const fn (?*anyopaque, bool, spa_source_idle_func_t, ?*anyopaque) callconv(.c) [*c]struct_spa_source = @import("std").mem.zeroes(?*const fn (?*anyopaque, bool, spa_source_idle_func_t, ?*anyopaque) callconv(.c) [*c]struct_spa_source), + enable_idle: ?*const fn (?*anyopaque, [*c]struct_spa_source, bool) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_source, bool) callconv(.c) c_int), + add_event: ?*const fn (?*anyopaque, spa_source_event_func_t, ?*anyopaque) callconv(.c) [*c]struct_spa_source = @import("std").mem.zeroes(?*const fn (?*anyopaque, spa_source_event_func_t, ?*anyopaque) callconv(.c) [*c]struct_spa_source), + signal_event: ?*const fn (?*anyopaque, [*c]struct_spa_source) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_source) callconv(.c) c_int), + add_timer: ?*const fn (?*anyopaque, spa_source_timer_func_t, ?*anyopaque) callconv(.c) [*c]struct_spa_source = @import("std").mem.zeroes(?*const fn (?*anyopaque, spa_source_timer_func_t, ?*anyopaque) callconv(.c) [*c]struct_spa_source), + update_timer: ?*const fn (?*anyopaque, [*c]struct_spa_source, [*c]struct_timespec, [*c]struct_timespec, bool) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_source, [*c]struct_timespec, [*c]struct_timespec, bool) callconv(.c) c_int), + add_signal: ?*const fn (?*anyopaque, c_int, spa_source_signal_func_t, ?*anyopaque) callconv(.c) [*c]struct_spa_source = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, spa_source_signal_func_t, ?*anyopaque) callconv(.c) [*c]struct_spa_source), + destroy_source: ?*const fn (?*anyopaque, [*c]struct_spa_source) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_source) callconv(.c) void), +}; +pub fn spa_loop_utils_add_io(arg_object: [*c]struct_spa_loop_utils, arg_fd: c_int, arg_mask: u32, arg_close_1: bool, arg_func: spa_source_io_func_t, arg_data: ?*anyopaque) callconv(.c) [*c]struct_spa_source { + var object = arg_object; + _ = &object; + var fd = arg_fd; + _ = &fd; + var mask = arg_mask; + _ = &mask; + var close_1 = arg_close_1; + _ = &close_1; + var func = arg_func; + _ = &func; + var data = arg_data; + _ = &data; + return blk: { + var _res: [*c]struct_spa_source = null; + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_utils_methods = @as([*c]const struct_spa_loop_utils_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_io != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.add_io.?((&_i.*.cb).*.data, fd, mask, close_1, func, data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_utils_update_io(arg_object: [*c]struct_spa_loop_utils, arg_source: [*c]struct_spa_source, arg_mask: u32) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var source = arg_source; + _ = &source; + var mask = arg_mask; + _ = &mask; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_utils_methods = @as([*c]const struct_spa_loop_utils_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.update_io != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.update_io.?((&_i.*.cb).*.data, source, mask); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_utils_add_idle(arg_object: [*c]struct_spa_loop_utils, arg_enabled: bool, arg_func: spa_source_idle_func_t, arg_data: ?*anyopaque) callconv(.c) [*c]struct_spa_source { + var object = arg_object; + _ = &object; + var enabled = arg_enabled; + _ = &enabled; + var func = arg_func; + _ = &func; + var data = arg_data; + _ = &data; + return blk: { + var _res: [*c]struct_spa_source = null; + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_utils_methods = @as([*c]const struct_spa_loop_utils_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_idle != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.add_idle.?((&_i.*.cb).*.data, enabled, func, data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_utils_enable_idle(arg_object: [*c]struct_spa_loop_utils, arg_source: [*c]struct_spa_source, arg_enabled: bool) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var source = arg_source; + _ = &source; + var enabled = arg_enabled; + _ = &enabled; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_utils_methods = @as([*c]const struct_spa_loop_utils_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.enable_idle != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.enable_idle.?((&_i.*.cb).*.data, source, enabled); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_utils_add_event(arg_object: [*c]struct_spa_loop_utils, arg_func: spa_source_event_func_t, arg_data: ?*anyopaque) callconv(.c) [*c]struct_spa_source { + var object = arg_object; + _ = &object; + var func = arg_func; + _ = &func; + var data = arg_data; + _ = &data; + return blk: { + var _res: [*c]struct_spa_source = null; + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_utils_methods = @as([*c]const struct_spa_loop_utils_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_event != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.add_event.?((&_i.*.cb).*.data, func, data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_utils_signal_event(arg_object: [*c]struct_spa_loop_utils, arg_source: [*c]struct_spa_source) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var source = arg_source; + _ = &source; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_utils_methods = @as([*c]const struct_spa_loop_utils_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.signal_event != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.signal_event.?((&_i.*.cb).*.data, source); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_utils_add_timer(arg_object: [*c]struct_spa_loop_utils, arg_func: spa_source_timer_func_t, arg_data: ?*anyopaque) callconv(.c) [*c]struct_spa_source { + var object = arg_object; + _ = &object; + var func = arg_func; + _ = &func; + var data = arg_data; + _ = &data; + return blk: { + var _res: [*c]struct_spa_source = null; + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_utils_methods = @as([*c]const struct_spa_loop_utils_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_timer != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.add_timer.?((&_i.*.cb).*.data, func, data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_utils_update_timer(arg_object: [*c]struct_spa_loop_utils, arg_source: [*c]struct_spa_source, arg_value: [*c]struct_timespec, arg_interval: [*c]struct_timespec, arg_absolute: bool) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var source = arg_source; + _ = &source; + var value = arg_value; + _ = &value; + var interval = arg_interval; + _ = &interval; + var absolute = arg_absolute; + _ = &absolute; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_utils_methods = @as([*c]const struct_spa_loop_utils_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.update_timer != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.update_timer.?((&_i.*.cb).*.data, source, value, interval, absolute); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_utils_add_signal(arg_object: [*c]struct_spa_loop_utils, arg_signal_number: c_int, arg_func: spa_source_signal_func_t, arg_data: ?*anyopaque) callconv(.c) [*c]struct_spa_source { + var object = arg_object; + _ = &object; + var signal_number = arg_signal_number; + _ = &signal_number; + var func = arg_func; + _ = &func; + var data = arg_data; + _ = &data; + return blk: { + var _res: [*c]struct_spa_source = null; + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_utils_methods = @as([*c]const struct_spa_loop_utils_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_signal != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.add_signal.?((&_i.*.cb).*.data, signal_number, func, data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_loop_utils_destroy_source(arg_object: [*c]struct_spa_loop_utils, arg_source: [*c]struct_spa_source) callconv(.c) void { + var object = arg_object; + _ = &object; + var source = arg_source; + _ = &source; + { + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_loop_utils_methods = @as([*c]const struct_spa_loop_utils_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + var _res: bool = ((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.destroy_source != null); + _ = &_res; + if (__builtin_expect(@as(c_long, @intFromBool(!!_res)), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _f.*.destroy_source.?((&_i.*.cb).*.data, source); + } + _ = &_res; + } + } +} +pub const struct_pw_loop = extern struct { + system: [*c]struct_spa_system = @import("std").mem.zeroes([*c]struct_spa_system), + loop: [*c]struct_spa_loop = @import("std").mem.zeroes([*c]struct_spa_loop), + control: [*c]struct_spa_loop_control = @import("std").mem.zeroes([*c]struct_spa_loop_control), + utils: [*c]struct_spa_loop_utils = @import("std").mem.zeroes([*c]struct_spa_loop_utils), + name: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), +}; +pub extern fn pw_loop_new(props: [*c]const struct_spa_dict) [*c]struct_pw_loop; +pub extern fn pw_loop_destroy(loop: [*c]struct_pw_loop) void; +pub extern fn pw_loop_set_name(loop: [*c]struct_pw_loop, name: [*c]const u8) c_int; +pub fn pw_loop_add_source(arg_object: [*c]struct_pw_loop, arg_source: [*c]struct_spa_source) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var source = arg_source; + _ = &source; + return spa_loop_add_source(object.*.loop, source); +} +pub fn pw_loop_update_source(arg_object: [*c]struct_pw_loop, arg_source: [*c]struct_spa_source) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var source = arg_source; + _ = &source; + return spa_loop_update_source(object.*.loop, source); +} +pub fn pw_loop_remove_source(arg_object: [*c]struct_pw_loop, arg_source: [*c]struct_spa_source) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var source = arg_source; + _ = &source; + return spa_loop_remove_source(object.*.loop, source); +} +pub fn pw_loop_invoke(arg_object: [*c]struct_pw_loop, arg_func: spa_invoke_func_t, arg_seq: u32, arg_data: ?*const anyopaque, arg_size: usize, arg_block: bool, arg_user_data: ?*anyopaque) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var func = arg_func; + _ = &func; + var seq = arg_seq; + _ = &seq; + var data = arg_data; + _ = &data; + var size = arg_size; + _ = &size; + var block = arg_block; + _ = █ + var user_data = arg_user_data; + _ = &user_data; + return spa_loop_invoke(object.*.loop, func, seq, data, size, block, user_data); +} +pub fn pw_loop_locked(arg_object: [*c]struct_pw_loop, arg_func: spa_invoke_func_t, arg_seq: u32, arg_data: ?*const anyopaque, arg_size: usize, arg_user_data: ?*anyopaque) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var func = arg_func; + _ = &func; + var seq = arg_seq; + _ = &seq; + var data = arg_data; + _ = &data; + var size = arg_size; + _ = &size; + var user_data = arg_user_data; + _ = &user_data; + return spa_loop_locked(object.*.loop, func, seq, data, size, user_data); +} +pub fn pw_loop_get_fd(arg_object: [*c]struct_pw_loop) callconv(.c) c_int { + var object = arg_object; + _ = &object; + return spa_loop_control_get_fd(object.*.control); +} +pub fn pw_loop_add_hook(arg_object: [*c]struct_pw_loop, arg_hook: [*c]struct_spa_hook, arg_hooks: [*c]const struct_spa_loop_control_hooks, arg_data: ?*anyopaque) callconv(.c) void { + var object = arg_object; + _ = &object; + var hook = arg_hook; + _ = &hook; + var hooks = arg_hooks; + _ = &hooks; + var data = arg_data; + _ = &data; + spa_loop_control_add_hook(object.*.control, hook, hooks, data); +} +pub fn pw_loop_enter(arg_object: [*c]struct_pw_loop) callconv(.c) void { + var object = arg_object; + _ = &object; + spa_loop_control_enter(object.*.control); +} +pub fn pw_loop_leave(arg_object: [*c]struct_pw_loop) callconv(.c) void { + var object = arg_object; + _ = &object; + spa_loop_control_leave(object.*.control); +} +pub fn pw_loop_iterate(arg_object: [*c]struct_pw_loop, arg_timeout: c_int) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var timeout = arg_timeout; + _ = &timeout; + return spa_loop_control_iterate_fast(object.*.control, timeout); +} +pub fn pw_loop_check(arg_object: [*c]struct_pw_loop) callconv(.c) c_int { + var object = arg_object; + _ = &object; + return spa_loop_control_check(object.*.control); +} +pub fn pw_loop_lock(arg_object: [*c]struct_pw_loop) callconv(.c) c_int { + var object = arg_object; + _ = &object; + return spa_loop_control_lock(object.*.control); +} +pub fn pw_loop_unlock(arg_object: [*c]struct_pw_loop) callconv(.c) c_int { + var object = arg_object; + _ = &object; + return spa_loop_control_unlock(object.*.control); +} +pub fn pw_loop_get_time(arg_object: [*c]struct_pw_loop, arg_abstime: [*c]struct_timespec, arg_timeout: i64) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var abstime = arg_abstime; + _ = &abstime; + var timeout = arg_timeout; + _ = &timeout; + return spa_loop_control_get_time(object.*.control, abstime, timeout); +} +pub fn pw_loop_wait(arg_object: [*c]struct_pw_loop, arg_abstime: [*c]const struct_timespec) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var abstime = arg_abstime; + _ = &abstime; + return spa_loop_control_wait(object.*.control, abstime); +} +pub fn pw_loop_signal(arg_object: [*c]struct_pw_loop, arg_wait_for_accept: bool) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var wait_for_accept = arg_wait_for_accept; + _ = &wait_for_accept; + return spa_loop_control_signal(object.*.control, wait_for_accept); +} +pub fn pw_loop_accept(arg_object: [*c]struct_pw_loop) callconv(.c) c_int { + var object = arg_object; + _ = &object; + return spa_loop_control_accept(object.*.control); +} +pub fn pw_loop_add_io(arg_object: [*c]struct_pw_loop, arg_fd: c_int, arg_mask: u32, arg_close_1: bool, arg_func: spa_source_io_func_t, arg_data: ?*anyopaque) callconv(.c) [*c]struct_spa_source { + var object = arg_object; + _ = &object; + var fd = arg_fd; + _ = &fd; + var mask = arg_mask; + _ = &mask; + var close_1 = arg_close_1; + _ = &close_1; + var func = arg_func; + _ = &func; + var data = arg_data; + _ = &data; + return spa_loop_utils_add_io(object.*.utils, fd, mask, close_1, func, data); +} +pub fn pw_loop_update_io(arg_object: [*c]struct_pw_loop, arg_source: [*c]struct_spa_source, arg_mask: u32) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var source = arg_source; + _ = &source; + var mask = arg_mask; + _ = &mask; + return spa_loop_utils_update_io(object.*.utils, source, mask); +} +pub fn pw_loop_add_idle(arg_object: [*c]struct_pw_loop, arg_enabled: bool, arg_func: spa_source_idle_func_t, arg_data: ?*anyopaque) callconv(.c) [*c]struct_spa_source { + var object = arg_object; + _ = &object; + var enabled = arg_enabled; + _ = &enabled; + var func = arg_func; + _ = &func; + var data = arg_data; + _ = &data; + return spa_loop_utils_add_idle(object.*.utils, enabled, func, data); +} +pub fn pw_loop_enable_idle(arg_object: [*c]struct_pw_loop, arg_source: [*c]struct_spa_source, arg_enabled: bool) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var source = arg_source; + _ = &source; + var enabled = arg_enabled; + _ = &enabled; + return spa_loop_utils_enable_idle(object.*.utils, source, enabled); +} +pub fn pw_loop_add_event(arg_object: [*c]struct_pw_loop, arg_func: spa_source_event_func_t, arg_data: ?*anyopaque) callconv(.c) [*c]struct_spa_source { + var object = arg_object; + _ = &object; + var func = arg_func; + _ = &func; + var data = arg_data; + _ = &data; + return spa_loop_utils_add_event(object.*.utils, func, data); +} +pub fn pw_loop_signal_event(arg_object: [*c]struct_pw_loop, arg_source: [*c]struct_spa_source) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var source = arg_source; + _ = &source; + return spa_loop_utils_signal_event(object.*.utils, source); +} +pub fn pw_loop_add_timer(arg_object: [*c]struct_pw_loop, arg_func: spa_source_timer_func_t, arg_data: ?*anyopaque) callconv(.c) [*c]struct_spa_source { + var object = arg_object; + _ = &object; + var func = arg_func; + _ = &func; + var data = arg_data; + _ = &data; + return spa_loop_utils_add_timer(object.*.utils, func, data); +} +pub fn pw_loop_update_timer(arg_object: [*c]struct_pw_loop, arg_source: [*c]struct_spa_source, arg_value: [*c]struct_timespec, arg_interval: [*c]struct_timespec, arg_absolute: bool) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var source = arg_source; + _ = &source; + var value = arg_value; + _ = &value; + var interval = arg_interval; + _ = &interval; + var absolute = arg_absolute; + _ = &absolute; + return spa_loop_utils_update_timer(object.*.utils, source, value, interval, absolute); +} +pub fn pw_loop_add_signal(arg_object: [*c]struct_pw_loop, arg_signal_number: c_int, arg_func: spa_source_signal_func_t, arg_data: ?*anyopaque) callconv(.c) [*c]struct_spa_source { + var object = arg_object; + _ = &object; + var signal_number = arg_signal_number; + _ = &signal_number; + var func = arg_func; + _ = &func; + var data = arg_data; + _ = &data; + return spa_loop_utils_add_signal(object.*.utils, signal_number, func, data); +} +pub fn pw_loop_destroy_source(arg_object: [*c]struct_pw_loop, arg_source: [*c]struct_spa_source) callconv(.c) void { + var object = arg_object; + _ = &object; + var source = arg_source; + _ = &source; + spa_loop_utils_destroy_source(object.*.utils, source); +} +pub const struct_pw_context_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + destroy: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), + free: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), + check_access: ?*const fn (?*anyopaque, ?*struct_pw_impl_client) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, ?*struct_pw_impl_client) callconv(.c) void), + global_added: ?*const fn (?*anyopaque, ?*struct_pw_global) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, ?*struct_pw_global) callconv(.c) void), + global_removed: ?*const fn (?*anyopaque, ?*struct_pw_global) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, ?*struct_pw_global) callconv(.c) void), + driver_added: ?*const fn (?*anyopaque, ?*struct_pw_impl_node) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, ?*struct_pw_impl_node) callconv(.c) void), + driver_removed: ?*const fn (?*anyopaque, ?*struct_pw_impl_node) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, ?*struct_pw_impl_node) callconv(.c) void), +}; +pub extern fn pw_context_new(main_loop: [*c]struct_pw_loop, props: [*c]struct_pw_properties, user_data_size: usize) ?*struct_pw_context; +pub extern fn pw_context_destroy(context: ?*struct_pw_context) void; +pub extern fn pw_context_get_user_data(context: ?*struct_pw_context) ?*anyopaque; +pub extern fn pw_context_add_listener(context: ?*struct_pw_context, listener: [*c]struct_spa_hook, events: [*c]const struct_pw_context_events, data: ?*anyopaque) void; +pub extern fn pw_context_get_properties(context: ?*struct_pw_context) [*c]const struct_pw_properties; +pub extern fn pw_context_update_properties(context: ?*struct_pw_context, dict: [*c]const struct_spa_dict) c_int; +pub extern fn pw_context_get_conf_section(context: ?*struct_pw_context, section: [*c]const u8) [*c]const u8; +pub extern fn pw_context_parse_conf_section(context: ?*struct_pw_context, conf: [*c]struct_pw_properties, section: [*c]const u8) c_int; +pub extern fn pw_context_conf_update_props(context: ?*struct_pw_context, section: [*c]const u8, props: [*c]struct_pw_properties) c_int; +pub extern fn pw_context_conf_section_for_each(context: ?*struct_pw_context, section: [*c]const u8, callback: ?*const fn (?*anyopaque, [*c]const u8, [*c]const u8, [*c]const u8, usize) callconv(.c) c_int, data: ?*anyopaque) c_int; +pub extern fn pw_context_conf_section_match_rules(context: ?*struct_pw_context, section: [*c]const u8, props: [*c]const struct_spa_dict, callback: ?*const fn (?*anyopaque, [*c]const u8, [*c]const u8, [*c]const u8, usize) callconv(.c) c_int, data: ?*anyopaque) c_int; +pub extern fn pw_context_get_support(context: ?*struct_pw_context, n_support: [*c]u32) [*c]const struct_spa_support; +pub extern fn pw_context_get_main_loop(context: ?*struct_pw_context) [*c]struct_pw_loop; +pub const struct_pw_data_loop = opaque {}; +pub extern fn pw_context_get_data_loop(context: ?*struct_pw_context) ?*struct_pw_data_loop; +pub extern fn pw_context_acquire_loop(context: ?*struct_pw_context, props: [*c]const struct_spa_dict) [*c]struct_pw_loop; +pub extern fn pw_context_release_loop(context: ?*struct_pw_context, loop: [*c]struct_pw_loop) void; +pub const struct_pw_work_queue = opaque {}; +pub extern fn pw_context_get_work_queue(context: ?*struct_pw_context) ?*struct_pw_work_queue; +pub const struct_pw_timer_queue = opaque {}; +pub extern fn pw_context_get_timer_queue(context: ?*struct_pw_context) ?*struct_pw_timer_queue; +pub extern fn pw_context_get_mempool(context: ?*struct_pw_context) [*c]struct_pw_mempool; +pub extern fn pw_context_for_each_global(context: ?*struct_pw_context, callback: ?*const fn (?*anyopaque, ?*struct_pw_global) callconv(.c) c_int, data: ?*anyopaque) c_int; +pub extern fn pw_context_find_global(context: ?*struct_pw_context, id: u32) ?*struct_pw_global; +pub extern fn pw_context_add_spa_lib(context: ?*struct_pw_context, factory_regex: [*c]const u8, lib: [*c]const u8) c_int; +pub extern fn pw_context_find_spa_lib(context: ?*struct_pw_context, factory_name: [*c]const u8) [*c]const u8; +pub extern fn pw_context_load_spa_handle(context: ?*struct_pw_context, factory_name: [*c]const u8, info: [*c]const struct_spa_dict) [*c]struct_spa_handle; +pub const struct_pw_export_type = extern struct { + link: struct_spa_list = @import("std").mem.zeroes(struct_spa_list), + type: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + func: ?*const fn (?*struct_pw_core, [*c]const u8, [*c]const struct_spa_dict, ?*anyopaque, usize) callconv(.c) ?*struct_pw_proxy = @import("std").mem.zeroes(?*const fn (?*struct_pw_core, [*c]const u8, [*c]const struct_spa_dict, ?*anyopaque, usize) callconv(.c) ?*struct_pw_proxy), +}; +pub extern fn pw_context_register_export_type(context: ?*struct_pw_context, @"type": [*c]struct_pw_export_type) c_int; +pub extern fn pw_context_find_export_type(context: ?*struct_pw_context, @"type": [*c]const u8) [*c]const struct_pw_export_type; +pub extern fn pw_context_set_object(context: ?*struct_pw_context, @"type": [*c]const u8, value: ?*anyopaque) c_int; +pub extern fn pw_context_get_object(context: ?*struct_pw_context, @"type": [*c]const u8) ?*anyopaque; +pub const sa_family_t = c_ushort; +pub const struct_sockaddr_un = extern struct { + sun_family: sa_family_t = @import("std").mem.zeroes(sa_family_t), + sun_path: [108]u8 = @import("std").mem.zeroes([108]u8), +}; +pub const struct_spa_pod = extern struct { + size: u32 = @import("std").mem.zeroes(u32), + type: u32 = @import("std").mem.zeroes(u32), +}; +pub const struct_spa_pod_bool = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), + value: i32 = @import("std").mem.zeroes(i32), + _padding: i32 = @import("std").mem.zeroes(i32), +}; +pub const struct_spa_pod_id = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), + value: u32 = @import("std").mem.zeroes(u32), + _padding: i32 = @import("std").mem.zeroes(i32), +}; +pub const struct_spa_pod_int = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), + value: i32 = @import("std").mem.zeroes(i32), + _padding: i32 = @import("std").mem.zeroes(i32), +}; +pub const struct_spa_pod_long = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), + value: i64 = @import("std").mem.zeroes(i64), +}; +pub const struct_spa_pod_float = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), + value: f32 = @import("std").mem.zeroes(f32), + _padding: i32 = @import("std").mem.zeroes(i32), +}; +pub const struct_spa_pod_double = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), + value: f64 = @import("std").mem.zeroes(f64), +}; +pub const struct_spa_pod_string = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), +}; +pub const struct_spa_pod_bytes = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), +}; +pub const struct_spa_pod_rectangle = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), + value: struct_spa_rectangle = @import("std").mem.zeroes(struct_spa_rectangle), +}; +pub const struct_spa_pod_fraction = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), + value: struct_spa_fraction = @import("std").mem.zeroes(struct_spa_fraction), +}; +pub const struct_spa_pod_bitmap = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), +}; +pub const struct_spa_pod_array_body = extern struct { + child: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), +}; +pub const struct_spa_pod_array = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), + body: struct_spa_pod_array_body = @import("std").mem.zeroes(struct_spa_pod_array_body), +}; +pub const SPA_CHOICE_None: c_int = 0; +pub const SPA_CHOICE_Range: c_int = 1; +pub const SPA_CHOICE_Step: c_int = 2; +pub const SPA_CHOICE_Enum: c_int = 3; +pub const SPA_CHOICE_Flags: c_int = 4; +pub const enum_spa_choice_type = c_uint; +pub const struct_spa_pod_choice_body = extern struct { + type: u32 = @import("std").mem.zeroes(u32), + flags: u32 = @import("std").mem.zeroes(u32), + child: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), +}; +pub const struct_spa_pod_choice = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), + body: struct_spa_pod_choice_body = @import("std").mem.zeroes(struct_spa_pod_choice_body), +}; +pub const struct_spa_pod_struct = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), +}; +pub const struct_spa_pod_object_body = extern struct { + type: u32 = @import("std").mem.zeroes(u32), + id: u32 = @import("std").mem.zeroes(u32), +}; +pub const struct_spa_pod_object = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), + body: struct_spa_pod_object_body = @import("std").mem.zeroes(struct_spa_pod_object_body), +}; +pub const struct_spa_pod_pointer_body = extern struct { + type: u32 = @import("std").mem.zeroes(u32), + _padding: u32 = @import("std").mem.zeroes(u32), + value: ?*const anyopaque = @import("std").mem.zeroes(?*const anyopaque), +}; +pub const struct_spa_pod_pointer = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), + body: struct_spa_pod_pointer_body = @import("std").mem.zeroes(struct_spa_pod_pointer_body), +}; +pub const struct_spa_pod_fd = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), + value: i64 = @import("std").mem.zeroes(i64), +}; +pub const struct_spa_pod_prop = extern struct { + key: u32 = @import("std").mem.zeroes(u32), + flags: u32 = @import("std").mem.zeroes(u32), + value: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), +}; +pub const struct_spa_pod_control = extern struct { + offset: u32 = @import("std").mem.zeroes(u32), + type: u32 = @import("std").mem.zeroes(u32), + value: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), +}; +pub const struct_spa_pod_sequence_body = extern struct { + unit: u32 = @import("std").mem.zeroes(u32), + pad: u32 = @import("std").mem.zeroes(u32), +}; +pub const struct_spa_pod_sequence = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), + body: struct_spa_pod_sequence_body = @import("std").mem.zeroes(struct_spa_pod_sequence_body), +}; +pub const pw_destroy_t = ?*const fn (?*anyopaque) callconv(.c) void; +pub extern fn pw_split_walk(str: [*c]const u8, delimiter: [*c]const u8, len: [*c]usize, state: [*c][*c]const u8) [*c]const u8; +pub extern fn pw_split_strv(str: [*c]const u8, delimiter: [*c]const u8, max_tokens: c_int, n_tokens: [*c]c_int) [*c][*c]u8; +pub extern fn pw_split_ip(str: [*c]u8, delimiter: [*c]const u8, max_tokens: c_int, tokens: [*c][*c]u8) c_int; +pub extern fn pw_strv_parse(val: [*c]const u8, len: usize, max_tokens: c_int, n_tokens: [*c]c_int) [*c][*c]u8; +pub extern fn pw_strv_find(a: [*c][*c]u8, b: [*c]const u8) c_int; +pub extern fn pw_strv_find_common(a: [*c][*c]u8, b: [*c][*c]u8) c_int; +pub extern fn pw_free_strv(str: [*c][*c]u8) void; +pub extern fn pw_strip(str: [*c]u8, whitespace: [*c]const u8) [*c]u8; +pub extern fn pw_getrandom(buf: ?*anyopaque, buflen: usize, flags: c_uint) isize; +pub extern fn pw_random(buf: ?*anyopaque, buflen: usize) void; +pub extern fn pw_reallocarray(ptr: ?*anyopaque, nmemb: usize, size: usize) ?*anyopaque; +pub const _spa_auto_cleanup_type_pw_strv = [*c][*c]u8; +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/cleanup.h:27:6: warning: unsupported bool expression type + +// (no file):242:1: warning: unable to translate function, demoted to extern +pub extern fn _spa_auto_cleanup_func_pw_strv(arg_thing: [*c][*c][*c]u8) callconv(.c) void; +pub const struct_pw_protocol_client = extern struct { + link: struct_spa_list = @import("std").mem.zeroes(struct_spa_list), + protocol: ?*struct_pw_protocol = @import("std").mem.zeroes(?*struct_pw_protocol), + core: ?*struct_pw_core = @import("std").mem.zeroes(?*struct_pw_core), + connect: ?*const fn ([*c]struct_pw_protocol_client, [*c]const struct_spa_dict, ?*const fn (?*anyopaque, c_int) callconv(.c) void, ?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn ([*c]struct_pw_protocol_client, [*c]const struct_spa_dict, ?*const fn (?*anyopaque, c_int) callconv(.c) void, ?*anyopaque) callconv(.c) c_int), + connect_fd: ?*const fn ([*c]struct_pw_protocol_client, c_int, bool) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn ([*c]struct_pw_protocol_client, c_int, bool) callconv(.c) c_int), + steal_fd: ?*const fn ([*c]struct_pw_protocol_client) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn ([*c]struct_pw_protocol_client) callconv(.c) c_int), + disconnect: ?*const fn ([*c]struct_pw_protocol_client) callconv(.c) void = @import("std").mem.zeroes(?*const fn ([*c]struct_pw_protocol_client) callconv(.c) void), + destroy: ?*const fn ([*c]struct_pw_protocol_client) callconv(.c) void = @import("std").mem.zeroes(?*const fn ([*c]struct_pw_protocol_client) callconv(.c) void), + set_paused: ?*const fn ([*c]struct_pw_protocol_client, bool) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn ([*c]struct_pw_protocol_client, bool) callconv(.c) c_int), +}; +pub const struct_pw_impl_core_34 = opaque {}; +pub const struct_pw_protocol_server = extern struct { + link: struct_spa_list = @import("std").mem.zeroes(struct_spa_list), + protocol: ?*struct_pw_protocol = @import("std").mem.zeroes(?*struct_pw_protocol), + core: ?*struct_pw_impl_core_34 = @import("std").mem.zeroes(?*struct_pw_impl_core_34), + client_list: struct_spa_list = @import("std").mem.zeroes(struct_spa_list), + destroy: ?*const fn ([*c]struct_pw_protocol_server) callconv(.c) void = @import("std").mem.zeroes(?*const fn ([*c]struct_pw_protocol_server) callconv(.c) void), +}; +pub const struct_pw_protocol_marshal = extern struct { + type: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + version: u32 = @import("std").mem.zeroes(u32), + flags: u32 = @import("std").mem.zeroes(u32), + n_client_methods: u32 = @import("std").mem.zeroes(u32), + n_server_methods: u32 = @import("std").mem.zeroes(u32), + client_marshal: ?*const anyopaque = @import("std").mem.zeroes(?*const anyopaque), + server_demarshal: ?*const anyopaque = @import("std").mem.zeroes(?*const anyopaque), + server_marshal: ?*const anyopaque = @import("std").mem.zeroes(?*const anyopaque), + client_demarshal: ?*const anyopaque = @import("std").mem.zeroes(?*const anyopaque), +}; +pub const struct_pw_protocol_implementation = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + new_client: ?*const fn (?*struct_pw_protocol, ?*struct_pw_core, [*c]const struct_spa_dict) callconv(.c) [*c]struct_pw_protocol_client = @import("std").mem.zeroes(?*const fn (?*struct_pw_protocol, ?*struct_pw_core, [*c]const struct_spa_dict) callconv(.c) [*c]struct_pw_protocol_client), + add_server: ?*const fn (?*struct_pw_protocol, ?*struct_pw_impl_core_34, [*c]const struct_spa_dict) callconv(.c) [*c]struct_pw_protocol_server = @import("std").mem.zeroes(?*const fn (?*struct_pw_protocol, ?*struct_pw_impl_core_34, [*c]const struct_spa_dict) callconv(.c) [*c]struct_pw_protocol_server), + add_fd_server: ?*const fn (?*struct_pw_protocol, ?*struct_pw_impl_core_34, c_int, c_int, [*c]const struct_spa_dict) callconv(.c) [*c]struct_pw_protocol_server = @import("std").mem.zeroes(?*const fn (?*struct_pw_protocol, ?*struct_pw_impl_core_34, c_int, c_int, [*c]const struct_spa_dict) callconv(.c) [*c]struct_pw_protocol_server), +}; +pub const struct_pw_protocol_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + destroy: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), +}; +pub extern fn pw_protocol_new(context: ?*struct_pw_context, name: [*c]const u8, user_data_size: usize) ?*struct_pw_protocol; +pub extern fn pw_protocol_destroy(protocol: ?*struct_pw_protocol) void; +pub extern fn pw_protocol_get_context(protocol: ?*struct_pw_protocol) ?*struct_pw_context; +pub extern fn pw_protocol_get_user_data(protocol: ?*struct_pw_protocol) ?*anyopaque; +pub extern fn pw_protocol_get_implementation(protocol: ?*struct_pw_protocol) [*c]const struct_pw_protocol_implementation; +pub extern fn pw_protocol_get_extension(protocol: ?*struct_pw_protocol) ?*const anyopaque; +pub extern fn pw_protocol_add_listener(protocol: ?*struct_pw_protocol, listener: [*c]struct_spa_hook, events: [*c]const struct_pw_protocol_events, data: ?*anyopaque) void; +pub extern fn pw_protocol_add_marshal(protocol: ?*struct_pw_protocol, marshal: [*c]const struct_pw_protocol_marshal) c_int; +pub extern fn pw_protocol_get_marshal(protocol: ?*struct_pw_protocol, @"type": [*c]const u8, version: u32, flags: u32) [*c]const struct_pw_protocol_marshal; +pub extern fn pw_context_find_protocol(context: ?*struct_pw_context, name: [*c]const u8) ?*struct_pw_protocol; +pub const struct_pw_proxy_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + destroy: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), + bound: ?*const fn (?*anyopaque, u32) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32) callconv(.c) void), + removed: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), + done: ?*const fn (?*anyopaque, c_int) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int) callconv(.c) void), + @"error": ?*const fn (?*anyopaque, c_int, c_int, [*c]const u8) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, c_int, [*c]const u8) callconv(.c) void), + bound_props: ?*const fn (?*anyopaque, u32, [*c]const struct_spa_dict) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, [*c]const struct_spa_dict) callconv(.c) void), +}; +pub extern fn pw_proxy_new(factory: ?*struct_pw_proxy, @"type": [*c]const u8, version: u32, user_data_size: usize) ?*struct_pw_proxy; +pub extern fn pw_proxy_add_listener(proxy: ?*struct_pw_proxy, listener: [*c]struct_spa_hook, events: [*c]const struct_pw_proxy_events, data: ?*anyopaque) void; +pub extern fn pw_proxy_add_object_listener(proxy: ?*struct_pw_proxy, listener: [*c]struct_spa_hook, funcs: ?*const anyopaque, data: ?*anyopaque) void; +pub extern fn pw_proxy_destroy(proxy: ?*struct_pw_proxy) void; +pub extern fn pw_proxy_ref(proxy: ?*struct_pw_proxy) void; +pub extern fn pw_proxy_unref(proxy: ?*struct_pw_proxy) void; +pub extern fn pw_proxy_get_user_data(proxy: ?*struct_pw_proxy) ?*anyopaque; +pub extern fn pw_proxy_get_id(proxy: ?*struct_pw_proxy) u32; +pub extern fn pw_proxy_get_type(proxy: ?*struct_pw_proxy, version: [*c]u32) [*c]const u8; +pub extern fn pw_proxy_get_protocol(proxy: ?*struct_pw_proxy) ?*struct_pw_protocol; +pub extern fn pw_proxy_sync(proxy: ?*struct_pw_proxy, seq: c_int) c_int; +pub extern fn pw_proxy_set_bound_id(proxy: ?*struct_pw_proxy, global_id: u32) c_int; +pub extern fn pw_proxy_get_bound_id(proxy: ?*struct_pw_proxy) u32; +pub extern fn pw_proxy_error(proxy: ?*struct_pw_proxy, res: c_int, @"error": [*c]const u8) c_int; +pub extern fn pw_proxy_errorf(proxy: ?*struct_pw_proxy, res: c_int, @"error": [*c]const u8, ...) c_int; +pub extern fn pw_proxy_get_object_listeners(proxy: ?*struct_pw_proxy) [*c]struct_spa_hook_list; +pub extern fn pw_proxy_get_marshal(proxy: ?*struct_pw_proxy) [*c]const struct_pw_protocol_marshal; +pub extern fn pw_proxy_install_marshal(proxy: ?*struct_pw_proxy, implementor: bool) c_int; +pub const struct_pw_permission = extern struct { + id: u32 = @import("std").mem.zeroes(u32), + permissions: u32 = @import("std").mem.zeroes(u32), +}; +pub const struct_pw_client_info = extern struct { + id: u32 = @import("std").mem.zeroes(u32), + change_mask: u64 = @import("std").mem.zeroes(u64), + props: [*c]struct_spa_dict = @import("std").mem.zeroes([*c]struct_spa_dict), +}; +pub extern fn pw_client_info_update(info: [*c]struct_pw_client_info, update: [*c]const struct_pw_client_info) [*c]struct_pw_client_info; +pub extern fn pw_client_info_merge(info: [*c]struct_pw_client_info, update: [*c]const struct_pw_client_info, reset: bool) [*c]struct_pw_client_info; +pub extern fn pw_client_info_free(info: [*c]struct_pw_client_info) void; +pub const struct_pw_client_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + info: ?*const fn (?*anyopaque, [*c]const struct_pw_client_info) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_pw_client_info) callconv(.c) void), + permissions: ?*const fn (?*anyopaque, u32, u32, [*c]const struct_pw_permission) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, u32, [*c]const struct_pw_permission) callconv(.c) void), +}; +pub const struct_pw_client_methods = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + add_listener: ?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_client_events, ?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_client_events, ?*anyopaque) callconv(.c) c_int), + @"error": ?*const fn (?*anyopaque, u32, c_int, [*c]const u8) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, c_int, [*c]const u8) callconv(.c) c_int), + update_properties: ?*const fn (?*anyopaque, [*c]const struct_spa_dict) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_spa_dict) callconv(.c) c_int), + get_permissions: ?*const fn (?*anyopaque, u32, u32) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, u32) callconv(.c) c_int), + update_permissions: ?*const fn (?*anyopaque, u32, [*c]const struct_pw_permission) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, [*c]const struct_pw_permission) callconv(.c) c_int), +}; +pub fn pw_client_add_listener(arg_object: ?*struct_pw_client, arg_listener: [*c]struct_spa_hook, arg_events: [*c]const struct_pw_client_events, arg_data: ?*anyopaque) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var listener = arg_listener; + _ = &listener; + var events = arg_events; + _ = &events; + var data = arg_data; + _ = &data; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_client_methods = @as([*c]const struct_pw_client_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_listener != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.add_listener.?((&_i.*.cb).*.data, listener, events, data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_client_error(arg_object: ?*struct_pw_client, arg_id: u32, arg_res: c_int, arg_message: [*c]const u8) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var id = arg_id; + _ = &id; + var res = arg_res; + _ = &res; + var message = arg_message; + _ = &message; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_client_methods = @as([*c]const struct_pw_client_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.@"error" != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.@"error".?((&_i.*.cb).*.data, id, res, message); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_client_update_properties(arg_object: ?*struct_pw_client, arg_props: [*c]const struct_spa_dict) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var props = arg_props; + _ = &props; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_client_methods = @as([*c]const struct_pw_client_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.update_properties != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.update_properties.?((&_i.*.cb).*.data, props); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_client_get_permissions(arg_object: ?*struct_pw_client, arg_index_1: u32, arg_num: u32) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var index_1 = arg_index_1; + _ = &index_1; + var num = arg_num; + _ = # + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_client_methods = @as([*c]const struct_pw_client_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.get_permissions != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.get_permissions.?((&_i.*.cb).*.data, index_1, num); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_client_update_permissions(arg_object: ?*struct_pw_client, arg_n_permissions: u32, arg_permissions: [*c]const struct_pw_permission) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var n_permissions = arg_n_permissions; + _ = &n_permissions; + var permissions = arg_permissions; + _ = &permissions; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_client_methods = @as([*c]const struct_pw_client_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.update_permissions != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.update_permissions.?((&_i.*.cb).*.data, n_permissions, permissions); + } + _ = &_res; + } + break :blk _res; + }; +} +pub const float_t = f32; +pub const double_t = f64; +pub extern fn __fpclassify(__value: f64) c_int; +pub extern fn __signbit(__value: f64) c_int; +pub extern fn __isinf(__value: f64) c_int; +pub extern fn __finite(__value: f64) c_int; +pub extern fn __isnan(__value: f64) c_int; +pub extern fn __iseqsig(__x: f64, __y: f64) c_int; +pub extern fn __issignaling(__value: f64) c_int; +pub extern fn acos(__x: f64) f64; +pub extern fn __acos(__x: f64) f64; +pub extern fn asin(__x: f64) f64; +pub extern fn __asin(__x: f64) f64; +pub extern fn atan(__x: f64) f64; +pub extern fn __atan(__x: f64) f64; +pub extern fn atan2(__y: f64, __x: f64) f64; +pub extern fn __atan2(__y: f64, __x: f64) f64; +pub extern fn cos(__x: f64) f64; +pub extern fn __cos(__x: f64) f64; +pub extern fn sin(__x: f64) f64; +pub extern fn __sin(__x: f64) f64; +pub extern fn tan(__x: f64) f64; +pub extern fn __tan(__x: f64) f64; +pub extern fn cosh(__x: f64) f64; +pub extern fn __cosh(__x: f64) f64; +pub extern fn sinh(__x: f64) f64; +pub extern fn __sinh(__x: f64) f64; +pub extern fn tanh(__x: f64) f64; +pub extern fn __tanh(__x: f64) f64; +pub extern fn acosh(__x: f64) f64; +pub extern fn __acosh(__x: f64) f64; +pub extern fn asinh(__x: f64) f64; +pub extern fn __asinh(__x: f64) f64; +pub extern fn atanh(__x: f64) f64; +pub extern fn __atanh(__x: f64) f64; +pub extern fn exp(__x: f64) f64; +pub extern fn __exp(__x: f64) f64; +pub extern fn frexp(__x: f64, __exponent: [*c]c_int) f64; +pub extern fn __frexp(__x: f64, __exponent: [*c]c_int) f64; +pub extern fn ldexp(__x: f64, __exponent: c_int) f64; +pub extern fn __ldexp(__x: f64, __exponent: c_int) f64; +pub extern fn log(__x: f64) f64; +pub extern fn __log(__x: f64) f64; +pub extern fn log10(__x: f64) f64; +pub extern fn __log10(__x: f64) f64; +pub extern fn modf(__x: f64, __iptr: [*c]f64) f64; +pub extern fn __modf(__x: f64, __iptr: [*c]f64) f64; +pub extern fn expm1(__x: f64) f64; +pub extern fn __expm1(__x: f64) f64; +pub extern fn log1p(__x: f64) f64; +pub extern fn __log1p(__x: f64) f64; +pub extern fn logb(__x: f64) f64; +pub extern fn __logb(__x: f64) f64; +pub extern fn exp2(__x: f64) f64; +pub extern fn __exp2(__x: f64) f64; +pub extern fn log2(__x: f64) f64; +pub extern fn __log2(__x: f64) f64; +pub extern fn pow(__x: f64, __y: f64) f64; +pub extern fn __pow(__x: f64, __y: f64) f64; +pub extern fn sqrt(__x: f64) f64; +pub extern fn __sqrt(__x: f64) f64; +pub extern fn hypot(__x: f64, __y: f64) f64; +pub extern fn __hypot(__x: f64, __y: f64) f64; +pub extern fn cbrt(__x: f64) f64; +pub extern fn __cbrt(__x: f64) f64; +pub extern fn ceil(__x: f64) f64; +pub extern fn __ceil(__x: f64) f64; +pub extern fn fabs(__x: f64) f64; +pub extern fn __fabs(__x: f64) f64; +pub extern fn floor(__x: f64) f64; +pub extern fn __floor(__x: f64) f64; +pub extern fn fmod(__x: f64, __y: f64) f64; +pub extern fn __fmod(__x: f64, __y: f64) f64; +pub extern fn isinf(__value: f64) c_int; +pub extern fn finite(__value: f64) c_int; +pub extern fn drem(__x: f64, __y: f64) f64; +pub extern fn __drem(__x: f64, __y: f64) f64; +pub extern fn significand(__x: f64) f64; +pub extern fn __significand(__x: f64) f64; +pub extern fn copysign(__x: f64, __y: f64) f64; +pub extern fn __copysign(__x: f64, __y: f64) f64; +pub extern fn nan(__tagb: [*c]const u8) f64; +pub extern fn __nan(__tagb: [*c]const u8) f64; +pub extern fn isnan(__value: f64) c_int; +pub extern fn j0(f64) f64; +pub extern fn __j0(f64) f64; +pub extern fn j1(f64) f64; +pub extern fn __j1(f64) f64; +pub extern fn jn(c_int, f64) f64; +pub extern fn __jn(c_int, f64) f64; +pub extern fn y0(f64) f64; +pub extern fn __y0(f64) f64; +pub extern fn y1(f64) f64; +pub extern fn __y1(f64) f64; +pub extern fn yn(c_int, f64) f64; +pub extern fn __yn(c_int, f64) f64; +pub extern fn erf(f64) f64; +pub extern fn __erf(f64) f64; +pub extern fn erfc(f64) f64; +pub extern fn __erfc(f64) f64; +pub extern fn lgamma(f64) f64; +pub extern fn __lgamma(f64) f64; +pub extern fn tgamma(f64) f64; +pub extern fn __tgamma(f64) f64; +pub extern fn gamma(f64) f64; +pub extern fn __gamma(f64) f64; +pub extern fn lgamma_r(f64, __signgamp: [*c]c_int) f64; +pub extern fn __lgamma_r(f64, __signgamp: [*c]c_int) f64; +pub extern fn rint(__x: f64) f64; +pub extern fn __rint(__x: f64) f64; +pub extern fn nextafter(__x: f64, __y: f64) f64; +pub extern fn __nextafter(__x: f64, __y: f64) f64; +pub extern fn nexttoward(__x: f64, __y: c_longdouble) f64; +pub extern fn __nexttoward(__x: f64, __y: c_longdouble) f64; +pub extern fn remainder(__x: f64, __y: f64) f64; +pub extern fn __remainder(__x: f64, __y: f64) f64; +pub extern fn scalbn(__x: f64, __n: c_int) f64; +pub extern fn __scalbn(__x: f64, __n: c_int) f64; +pub extern fn ilogb(__x: f64) c_int; +pub extern fn __ilogb(__x: f64) c_int; +pub extern fn scalbln(__x: f64, __n: c_long) f64; +pub extern fn __scalbln(__x: f64, __n: c_long) f64; +pub extern fn nearbyint(__x: f64) f64; +pub extern fn __nearbyint(__x: f64) f64; +pub extern fn round(__x: f64) f64; +pub extern fn __round(__x: f64) f64; +pub extern fn trunc(__x: f64) f64; +pub extern fn __trunc(__x: f64) f64; +pub extern fn remquo(__x: f64, __y: f64, __quo: [*c]c_int) f64; +pub extern fn __remquo(__x: f64, __y: f64, __quo: [*c]c_int) f64; +pub extern fn lrint(__x: f64) c_long; +pub extern fn __lrint(__x: f64) c_long; +pub extern fn llrint(__x: f64) c_longlong; +pub extern fn __llrint(__x: f64) c_longlong; +pub extern fn lround(__x: f64) c_long; +pub extern fn __lround(__x: f64) c_long; +pub extern fn llround(__x: f64) c_longlong; +pub extern fn __llround(__x: f64) c_longlong; +pub extern fn fdim(__x: f64, __y: f64) f64; +pub extern fn __fdim(__x: f64, __y: f64) f64; +pub extern fn fmax(__x: f64, __y: f64) f64; +pub extern fn __fmax(__x: f64, __y: f64) f64; +pub extern fn fmin(__x: f64, __y: f64) f64; +pub extern fn __fmin(__x: f64, __y: f64) f64; +pub extern fn fma(__x: f64, __y: f64, __z: f64) f64; +pub extern fn __fma(__x: f64, __y: f64, __z: f64) f64; +pub extern fn scalb(__x: f64, __n: f64) f64; +pub extern fn __scalb(__x: f64, __n: f64) f64; +pub extern fn __fpclassifyf(__value: f32) c_int; +pub extern fn __signbitf(__value: f32) c_int; +pub extern fn __isinff(__value: f32) c_int; +pub extern fn __finitef(__value: f32) c_int; +pub extern fn __isnanf(__value: f32) c_int; +pub extern fn __iseqsigf(__x: f32, __y: f32) c_int; +pub extern fn __issignalingf(__value: f32) c_int; +pub extern fn acosf(__x: f32) f32; +pub extern fn __acosf(__x: f32) f32; +pub extern fn asinf(__x: f32) f32; +pub extern fn __asinf(__x: f32) f32; +pub extern fn atanf(__x: f32) f32; +pub extern fn __atanf(__x: f32) f32; +pub extern fn atan2f(__y: f32, __x: f32) f32; +pub extern fn __atan2f(__y: f32, __x: f32) f32; +pub extern fn cosf(__x: f32) f32; +pub extern fn __cosf(__x: f32) f32; +pub extern fn sinf(__x: f32) f32; +pub extern fn __sinf(__x: f32) f32; +pub extern fn tanf(__x: f32) f32; +pub extern fn __tanf(__x: f32) f32; +pub extern fn coshf(__x: f32) f32; +pub extern fn __coshf(__x: f32) f32; +pub extern fn sinhf(__x: f32) f32; +pub extern fn __sinhf(__x: f32) f32; +pub extern fn tanhf(__x: f32) f32; +pub extern fn __tanhf(__x: f32) f32; +pub extern fn acoshf(__x: f32) f32; +pub extern fn __acoshf(__x: f32) f32; +pub extern fn asinhf(__x: f32) f32; +pub extern fn __asinhf(__x: f32) f32; +pub extern fn atanhf(__x: f32) f32; +pub extern fn __atanhf(__x: f32) f32; +pub extern fn expf(__x: f32) f32; +pub extern fn __expf(__x: f32) f32; +pub extern fn frexpf(__x: f32, __exponent: [*c]c_int) f32; +pub extern fn __frexpf(__x: f32, __exponent: [*c]c_int) f32; +pub extern fn ldexpf(__x: f32, __exponent: c_int) f32; +pub extern fn __ldexpf(__x: f32, __exponent: c_int) f32; +pub extern fn logf(__x: f32) f32; +pub extern fn __logf(__x: f32) f32; +pub extern fn log10f(__x: f32) f32; +pub extern fn __log10f(__x: f32) f32; +pub extern fn modff(__x: f32, __iptr: [*c]f32) f32; +pub extern fn __modff(__x: f32, __iptr: [*c]f32) f32; +pub extern fn expm1f(__x: f32) f32; +pub extern fn __expm1f(__x: f32) f32; +pub extern fn log1pf(__x: f32) f32; +pub extern fn __log1pf(__x: f32) f32; +pub extern fn logbf(__x: f32) f32; +pub extern fn __logbf(__x: f32) f32; +pub extern fn exp2f(__x: f32) f32; +pub extern fn __exp2f(__x: f32) f32; +pub extern fn log2f(__x: f32) f32; +pub extern fn __log2f(__x: f32) f32; +pub extern fn powf(__x: f32, __y: f32) f32; +pub extern fn __powf(__x: f32, __y: f32) f32; +pub extern fn sqrtf(__x: f32) f32; +pub extern fn __sqrtf(__x: f32) f32; +pub extern fn hypotf(__x: f32, __y: f32) f32; +pub extern fn __hypotf(__x: f32, __y: f32) f32; +pub extern fn cbrtf(__x: f32) f32; +pub extern fn __cbrtf(__x: f32) f32; +pub extern fn ceilf(__x: f32) f32; +pub extern fn __ceilf(__x: f32) f32; +pub extern fn fabsf(__x: f32) f32; +pub extern fn __fabsf(__x: f32) f32; +pub extern fn floorf(__x: f32) f32; +pub extern fn __floorf(__x: f32) f32; +pub extern fn fmodf(__x: f32, __y: f32) f32; +pub extern fn __fmodf(__x: f32, __y: f32) f32; +pub extern fn isinff(__value: f32) c_int; +pub extern fn finitef(__value: f32) c_int; +pub extern fn dremf(__x: f32, __y: f32) f32; +pub extern fn __dremf(__x: f32, __y: f32) f32; +pub extern fn significandf(__x: f32) f32; +pub extern fn __significandf(__x: f32) f32; +pub extern fn copysignf(__x: f32, __y: f32) f32; +pub extern fn __copysignf(__x: f32, __y: f32) f32; +pub extern fn nanf(__tagb: [*c]const u8) f32; +pub extern fn __nanf(__tagb: [*c]const u8) f32; +pub extern fn isnanf(__value: f32) c_int; +pub extern fn j0f(f32) f32; +pub extern fn __j0f(f32) f32; +pub extern fn j1f(f32) f32; +pub extern fn __j1f(f32) f32; +pub extern fn jnf(c_int, f32) f32; +pub extern fn __jnf(c_int, f32) f32; +pub extern fn y0f(f32) f32; +pub extern fn __y0f(f32) f32; +pub extern fn y1f(f32) f32; +pub extern fn __y1f(f32) f32; +pub extern fn ynf(c_int, f32) f32; +pub extern fn __ynf(c_int, f32) f32; +pub extern fn erff(f32) f32; +pub extern fn __erff(f32) f32; +pub extern fn erfcf(f32) f32; +pub extern fn __erfcf(f32) f32; +pub extern fn lgammaf(f32) f32; +pub extern fn __lgammaf(f32) f32; +pub extern fn tgammaf(f32) f32; +pub extern fn __tgammaf(f32) f32; +pub extern fn gammaf(f32) f32; +pub extern fn __gammaf(f32) f32; +pub extern fn lgammaf_r(f32, __signgamp: [*c]c_int) f32; +pub extern fn __lgammaf_r(f32, __signgamp: [*c]c_int) f32; +pub extern fn rintf(__x: f32) f32; +pub extern fn __rintf(__x: f32) f32; +pub extern fn nextafterf(__x: f32, __y: f32) f32; +pub extern fn __nextafterf(__x: f32, __y: f32) f32; +pub extern fn nexttowardf(__x: f32, __y: c_longdouble) f32; +pub extern fn __nexttowardf(__x: f32, __y: c_longdouble) f32; +pub extern fn remainderf(__x: f32, __y: f32) f32; +pub extern fn __remainderf(__x: f32, __y: f32) f32; +pub extern fn scalbnf(__x: f32, __n: c_int) f32; +pub extern fn __scalbnf(__x: f32, __n: c_int) f32; +pub extern fn ilogbf(__x: f32) c_int; +pub extern fn __ilogbf(__x: f32) c_int; +pub extern fn scalblnf(__x: f32, __n: c_long) f32; +pub extern fn __scalblnf(__x: f32, __n: c_long) f32; +pub extern fn nearbyintf(__x: f32) f32; +pub extern fn __nearbyintf(__x: f32) f32; +pub extern fn roundf(__x: f32) f32; +pub extern fn __roundf(__x: f32) f32; +pub extern fn truncf(__x: f32) f32; +pub extern fn __truncf(__x: f32) f32; +pub extern fn remquof(__x: f32, __y: f32, __quo: [*c]c_int) f32; +pub extern fn __remquof(__x: f32, __y: f32, __quo: [*c]c_int) f32; +pub extern fn lrintf(__x: f32) c_long; +pub extern fn __lrintf(__x: f32) c_long; +pub extern fn llrintf(__x: f32) c_longlong; +pub extern fn __llrintf(__x: f32) c_longlong; +pub extern fn lroundf(__x: f32) c_long; +pub extern fn __lroundf(__x: f32) c_long; +pub extern fn llroundf(__x: f32) c_longlong; +pub extern fn __llroundf(__x: f32) c_longlong; +pub extern fn fdimf(__x: f32, __y: f32) f32; +pub extern fn __fdimf(__x: f32, __y: f32) f32; +pub extern fn fmaxf(__x: f32, __y: f32) f32; +pub extern fn __fmaxf(__x: f32, __y: f32) f32; +pub extern fn fminf(__x: f32, __y: f32) f32; +pub extern fn __fminf(__x: f32, __y: f32) f32; +pub extern fn fmaf(__x: f32, __y: f32, __z: f32) f32; +pub extern fn __fmaf(__x: f32, __y: f32, __z: f32) f32; +pub extern fn scalbf(__x: f32, __n: f32) f32; +pub extern fn __scalbf(__x: f32, __n: f32) f32; +pub extern fn __fpclassifyl(__value: c_longdouble) c_int; +pub extern fn __signbitl(__value: c_longdouble) c_int; +pub extern fn __isinfl(__value: c_longdouble) c_int; +pub extern fn __finitel(__value: c_longdouble) c_int; +pub extern fn __isnanl(__value: c_longdouble) c_int; +pub extern fn __iseqsigl(__x: c_longdouble, __y: c_longdouble) c_int; +pub extern fn __issignalingl(__value: c_longdouble) c_int; +pub extern fn acosl(__x: c_longdouble) c_longdouble; +pub extern fn __acosl(__x: c_longdouble) c_longdouble; +pub extern fn asinl(__x: c_longdouble) c_longdouble; +pub extern fn __asinl(__x: c_longdouble) c_longdouble; +pub extern fn atanl(__x: c_longdouble) c_longdouble; +pub extern fn __atanl(__x: c_longdouble) c_longdouble; +pub extern fn atan2l(__y: c_longdouble, __x: c_longdouble) c_longdouble; +pub extern fn __atan2l(__y: c_longdouble, __x: c_longdouble) c_longdouble; +pub extern fn cosl(__x: c_longdouble) c_longdouble; +pub extern fn __cosl(__x: c_longdouble) c_longdouble; +pub extern fn sinl(__x: c_longdouble) c_longdouble; +pub extern fn __sinl(__x: c_longdouble) c_longdouble; +pub extern fn tanl(__x: c_longdouble) c_longdouble; +pub extern fn __tanl(__x: c_longdouble) c_longdouble; +pub extern fn coshl(__x: c_longdouble) c_longdouble; +pub extern fn __coshl(__x: c_longdouble) c_longdouble; +pub extern fn sinhl(__x: c_longdouble) c_longdouble; +pub extern fn __sinhl(__x: c_longdouble) c_longdouble; +pub extern fn tanhl(__x: c_longdouble) c_longdouble; +pub extern fn __tanhl(__x: c_longdouble) c_longdouble; +pub extern fn acoshl(__x: c_longdouble) c_longdouble; +pub extern fn __acoshl(__x: c_longdouble) c_longdouble; +pub extern fn asinhl(__x: c_longdouble) c_longdouble; +pub extern fn __asinhl(__x: c_longdouble) c_longdouble; +pub extern fn atanhl(__x: c_longdouble) c_longdouble; +pub extern fn __atanhl(__x: c_longdouble) c_longdouble; +pub extern fn expl(__x: c_longdouble) c_longdouble; +pub extern fn __expl(__x: c_longdouble) c_longdouble; +pub extern fn frexpl(__x: c_longdouble, __exponent: [*c]c_int) c_longdouble; +pub extern fn __frexpl(__x: c_longdouble, __exponent: [*c]c_int) c_longdouble; +pub extern fn ldexpl(__x: c_longdouble, __exponent: c_int) c_longdouble; +pub extern fn __ldexpl(__x: c_longdouble, __exponent: c_int) c_longdouble; +pub extern fn logl(__x: c_longdouble) c_longdouble; +pub extern fn __logl(__x: c_longdouble) c_longdouble; +pub extern fn log10l(__x: c_longdouble) c_longdouble; +pub extern fn __log10l(__x: c_longdouble) c_longdouble; +pub extern fn modfl(__x: c_longdouble, __iptr: [*c]c_longdouble) c_longdouble; +pub extern fn __modfl(__x: c_longdouble, __iptr: [*c]c_longdouble) c_longdouble; +pub extern fn expm1l(__x: c_longdouble) c_longdouble; +pub extern fn __expm1l(__x: c_longdouble) c_longdouble; +pub extern fn log1pl(__x: c_longdouble) c_longdouble; +pub extern fn __log1pl(__x: c_longdouble) c_longdouble; +pub extern fn logbl(__x: c_longdouble) c_longdouble; +pub extern fn __logbl(__x: c_longdouble) c_longdouble; +pub extern fn exp2l(__x: c_longdouble) c_longdouble; +pub extern fn __exp2l(__x: c_longdouble) c_longdouble; +pub extern fn log2l(__x: c_longdouble) c_longdouble; +pub extern fn __log2l(__x: c_longdouble) c_longdouble; +pub extern fn powl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __powl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn sqrtl(__x: c_longdouble) c_longdouble; +pub extern fn __sqrtl(__x: c_longdouble) c_longdouble; +pub extern fn hypotl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __hypotl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn cbrtl(__x: c_longdouble) c_longdouble; +pub extern fn __cbrtl(__x: c_longdouble) c_longdouble; +pub extern fn ceill(__x: c_longdouble) c_longdouble; +pub extern fn __ceill(__x: c_longdouble) c_longdouble; +pub extern fn fabsl(__x: c_longdouble) c_longdouble; +pub extern fn __fabsl(__x: c_longdouble) c_longdouble; +pub extern fn floorl(__x: c_longdouble) c_longdouble; +pub extern fn __floorl(__x: c_longdouble) c_longdouble; +pub extern fn fmodl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __fmodl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn isinfl(__value: c_longdouble) c_int; +pub extern fn finitel(__value: c_longdouble) c_int; +pub extern fn dreml(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __dreml(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn significandl(__x: c_longdouble) c_longdouble; +pub extern fn __significandl(__x: c_longdouble) c_longdouble; +pub extern fn copysignl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __copysignl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn nanl(__tagb: [*c]const u8) c_longdouble; +pub extern fn __nanl(__tagb: [*c]const u8) c_longdouble; +pub extern fn isnanl(__value: c_longdouble) c_int; +pub extern fn j0l(c_longdouble) c_longdouble; +pub extern fn __j0l(c_longdouble) c_longdouble; +pub extern fn j1l(c_longdouble) c_longdouble; +pub extern fn __j1l(c_longdouble) c_longdouble; +pub extern fn jnl(c_int, c_longdouble) c_longdouble; +pub extern fn __jnl(c_int, c_longdouble) c_longdouble; +pub extern fn y0l(c_longdouble) c_longdouble; +pub extern fn __y0l(c_longdouble) c_longdouble; +pub extern fn y1l(c_longdouble) c_longdouble; +pub extern fn __y1l(c_longdouble) c_longdouble; +pub extern fn ynl(c_int, c_longdouble) c_longdouble; +pub extern fn __ynl(c_int, c_longdouble) c_longdouble; +pub extern fn erfl(c_longdouble) c_longdouble; +pub extern fn __erfl(c_longdouble) c_longdouble; +pub extern fn erfcl(c_longdouble) c_longdouble; +pub extern fn __erfcl(c_longdouble) c_longdouble; +pub extern fn lgammal(c_longdouble) c_longdouble; +pub extern fn __lgammal(c_longdouble) c_longdouble; +pub extern fn tgammal(c_longdouble) c_longdouble; +pub extern fn __tgammal(c_longdouble) c_longdouble; +pub extern fn gammal(c_longdouble) c_longdouble; +pub extern fn __gammal(c_longdouble) c_longdouble; +pub extern fn lgammal_r(c_longdouble, __signgamp: [*c]c_int) c_longdouble; +pub extern fn __lgammal_r(c_longdouble, __signgamp: [*c]c_int) c_longdouble; +pub extern fn rintl(__x: c_longdouble) c_longdouble; +pub extern fn __rintl(__x: c_longdouble) c_longdouble; +pub extern fn nextafterl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __nextafterl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn nexttowardl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __nexttowardl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn remainderl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __remainderl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn scalbnl(__x: c_longdouble, __n: c_int) c_longdouble; +pub extern fn __scalbnl(__x: c_longdouble, __n: c_int) c_longdouble; +pub extern fn ilogbl(__x: c_longdouble) c_int; +pub extern fn __ilogbl(__x: c_longdouble) c_int; +pub extern fn scalblnl(__x: c_longdouble, __n: c_long) c_longdouble; +pub extern fn __scalblnl(__x: c_longdouble, __n: c_long) c_longdouble; +pub extern fn nearbyintl(__x: c_longdouble) c_longdouble; +pub extern fn __nearbyintl(__x: c_longdouble) c_longdouble; +pub extern fn roundl(__x: c_longdouble) c_longdouble; +pub extern fn __roundl(__x: c_longdouble) c_longdouble; +pub extern fn truncl(__x: c_longdouble) c_longdouble; +pub extern fn __truncl(__x: c_longdouble) c_longdouble; +pub extern fn remquol(__x: c_longdouble, __y: c_longdouble, __quo: [*c]c_int) c_longdouble; +pub extern fn __remquol(__x: c_longdouble, __y: c_longdouble, __quo: [*c]c_int) c_longdouble; +pub extern fn lrintl(__x: c_longdouble) c_long; +pub extern fn __lrintl(__x: c_longdouble) c_long; +pub extern fn llrintl(__x: c_longdouble) c_longlong; +pub extern fn __llrintl(__x: c_longdouble) c_longlong; +pub extern fn lroundl(__x: c_longdouble) c_long; +pub extern fn __lroundl(__x: c_longdouble) c_long; +pub extern fn llroundl(__x: c_longdouble) c_longlong; +pub extern fn __llroundl(__x: c_longdouble) c_longlong; +pub extern fn fdiml(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __fdiml(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn fmaxl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __fmaxl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn fminl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn __fminl(__x: c_longdouble, __y: c_longdouble) c_longdouble; +pub extern fn fmal(__x: c_longdouble, __y: c_longdouble, __z: c_longdouble) c_longdouble; +pub extern fn __fmal(__x: c_longdouble, __y: c_longdouble, __z: c_longdouble) c_longdouble; +pub extern fn scalbl(__x: c_longdouble, __n: c_longdouble) c_longdouble; +pub extern fn __scalbl(__x: c_longdouble, __n: c_longdouble) c_longdouble; +pub extern var signgam: c_int; +pub const FP_NAN: c_int = 0; +pub const FP_INFINITE: c_int = 1; +pub const FP_ZERO: c_int = 2; +pub const FP_SUBNORMAL: c_int = 3; +pub const FP_NORMAL: c_int = 4; +const enum_unnamed_35 = c_uint; +pub const struct_spa_json = extern struct { + cur: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + end: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + parent: [*c]struct_spa_json = @import("std").mem.zeroes([*c]struct_spa_json), + state: u32 = @import("std").mem.zeroes(u32), + depth: u32 = @import("std").mem.zeroes(u32), +}; +pub fn spa_json_init(arg_iter: [*c]struct_spa_json, arg_data: [*c]const u8, arg_size: usize) callconv(.c) void { + var iter = arg_iter; + _ = &iter; + var data = arg_data; + _ = &data; + var size = arg_size; + _ = &size; + iter.* = struct_spa_json{ + .cur = data, + .end = data + size, + .parent = null, + .state = @as(u32, @bitCast(@as(c_int, 0))), + .depth = @as(u32, @bitCast(@as(c_int, 0))), + }; +} +pub fn spa_json_enter(arg_iter: [*c]struct_spa_json, arg_sub: [*c]struct_spa_json) callconv(.c) void { + var iter = arg_iter; + _ = &iter; + var sub = arg_sub; + _ = ⊂ + sub.* = struct_spa_json{ + .cur = iter.*.cur, + .end = iter.*.end, + .parent = iter, + .state = iter.*.state & @as(u32, @bitCast(@as(c_int, 4080))), + .depth = @as(u32, @bitCast(@as(c_int, 0))), + }; +} +pub fn spa_json_save(arg_iter: [*c]struct_spa_json, arg_save: [*c]struct_spa_json) callconv(.c) void { + var iter = arg_iter; + _ = &iter; + var save = arg_save; + _ = &save; + save.* = struct_spa_json{ + .cur = iter.*.cur, + .end = iter.*.end, + .parent = null, + .state = iter.*.state, + .depth = @as(u32, @bitCast(@as(c_int, 0))), + }; +} +pub fn spa_json_start(arg_iter: [*c]struct_spa_json, arg_sub: [*c]struct_spa_json, arg_pos: [*c]const u8) callconv(.c) void { + var iter = arg_iter; + _ = &iter; + var sub = arg_sub; + _ = ⊂ + var pos = arg_pos; + _ = &pos; + sub.* = struct_spa_json{ + .cur = pos, + .end = iter.*.end, + .parent = null, + .state = @as(u32, @bitCast(@as(c_int, 0))), + .depth = @as(u32, @bitCast(@as(c_int, 0))), + }; +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/json-core.h:116:2: warning: TODO implement translation of stmt class LabelStmtClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/json-core.h:80:18: warning: unable to translate function, demoted to extern +pub extern fn spa_json_next(arg_iter: [*c]struct_spa_json, arg_value: [*c][*c]const u8) callconv(.c) c_int; +pub fn spa_json_get_error(arg_iter: [*c]struct_spa_json, arg_start: [*c]const u8, arg_loc: [*c]struct_spa_error_location) callconv(.c) bool { + var iter = arg_iter; + _ = &iter; + var start = arg_start; + _ = &start; + var loc = arg_loc; + _ = &loc; + const reasons = struct { + var static: [14][*c]const u8 = [14][*c]const u8{ + "System error", + "Invalid array separator", + "Expected object key", + "Expected object value", + "Too deep nesting", + "Expected array close bracket", + "Expected object close brace", + "Mismatched bracket", + "Escape not allowed", + "Character not allowed", + "Invalid escape", + "Invalid state", + "Unfinished string", + "Expected key separator", + }; + }; + _ = &reasons; + if (!((iter.*.state & @as(u32, @bitCast(@as(c_int, 256)))) != 0)) return @as(c_int, 0) != 0; + if (loc != null) { + var linepos: c_int = 1; + _ = &linepos; + var colpos: c_int = 1; + _ = &colpos; + var code: c_int = undefined; + _ = &code; + var p: [*c]const u8 = undefined; + _ = &p; + var l: [*c]const u8 = undefined; + _ = &l; + { + l = blk: { + const tmp = start; + p = tmp; + break :blk tmp; + }; + while ((p != null) and (p != iter.*.cur)) : (p += 1) { + if (@as(c_int, @bitCast(@as(c_uint, p.*))) == @as(c_int, '\n')) { + linepos += 1; + colpos = 1; + l = p + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + } else { + colpos += 1; + } + } + } + code = @as(c_int, @bitCast(@as(c_uint, @truncate(blk: { + var _v: @TypeOf(iter.*.state & @as(u32, @bitCast(@as(c_int, 255)))) = iter.*.state & @as(u32, @bitCast(@as(c_int, 255))); + _ = &_v; + var _low: @TypeOf(@as(c_uint, 0)) = @as(c_uint, 0); + _ = &_low; + var _high: @TypeOf((@sizeOf([14][*c]const u8) / @sizeOf([*c]const u8)) -% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1))))) = (@sizeOf([14][*c]const u8) / @sizeOf([*c]const u8)) -% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))); + _ = &_high; + break :blk blk_1: { + var _min_a: @TypeOf(blk_2: { + var _max_a: @TypeOf(_v) = _v; + _ = &_max_a; + var _max_b: @TypeOf(_low) = _low; + _ = &_max_b; + break :blk_2 if (__builtin_expect(@as(c_long, @intFromBool(!!(_max_a >= _max_b))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) _max_a else _max_b; + }) = blk_2: { + var _max_a: @TypeOf(_v) = _v; + _ = &_max_a; + var _max_b: @TypeOf(_low) = _low; + _ = &_max_b; + break :blk_2 if (__builtin_expect(@as(c_long, @intFromBool(!!(_max_a >= _max_b))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) _max_a else _max_b; + }; + _ = &_min_a; + var _min_b: @TypeOf(_high) = _high; + _ = &_min_b; + break :blk_1 if (__builtin_expect(@as(c_long, @intFromBool(!!(@as(@TypeOf(_high), @bitCast(@as(c_ulong, _min_a))) <= _min_b))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) @as(@TypeOf(_high), @bitCast(@as(c_ulong, _min_a))) else _min_b; + }; + })))); + loc.*.line = linepos; + loc.*.col = colpos; + loc.*.location = l; + loc.*.len = @as(c_ulong, @bitCast(@as(isize, @intCast(@intFromPtr(iter.*.end))) - @as(isize, @intCast(@intFromPtr(loc.*.location))))) / @sizeOf(u8); + loc.*.reason = if (code == @as(c_int, 0)) @as([*c]const u8, @ptrCast(@alignCast(strerror(__errno_location().*)))) else reasons.static[@as(c_uint, @intCast(code))]; + } + return @as(c_int, 1) != 0; +} +pub fn spa_json_is_container(arg_val: [*c]const u8, arg_len: c_int) callconv(.c) c_int { + var val = arg_val; + _ = &val; + var len = arg_len; + _ = &len; + return @intFromBool((len > @as(c_int, 0)) and ((@as(c_int, @bitCast(@as(c_uint, val.*))) == @as(c_int, '{')) or (@as(c_int, @bitCast(@as(c_uint, val.*))) == @as(c_int, '[')))); +} +pub fn spa_json_is_object(arg_val: [*c]const u8, arg_len: c_int) callconv(.c) c_int { + var val = arg_val; + _ = &val; + var len = arg_len; + _ = &len; + return @intFromBool((len > @as(c_int, 0)) and (@as(c_int, @bitCast(@as(c_uint, val.*))) == @as(c_int, '{'))); +} +pub fn spa_json_is_array(arg_val: [*c]const u8, arg_len: c_int) callconv(.c) bool { + var val = arg_val; + _ = &val; + var len = arg_len; + _ = &len; + return (len > @as(c_int, 0)) and (@as(c_int, @bitCast(@as(c_uint, val.*))) == @as(c_int, '[')); +} +pub fn spa_json_is_null(arg_val: [*c]const u8, arg_len: c_int) callconv(.c) bool { + var val = arg_val; + _ = &val; + var len = arg_len; + _ = &len; + return (len == @as(c_int, 4)) and (strncmp(val, "null", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))) == @as(c_int, 0)); +} +pub fn spa_json_parse_float(arg_val: [*c]const u8, arg_len: c_int, arg_result: [*c]f32) callconv(.c) c_int { + var val = arg_val; + _ = &val; + var len = arg_len; + _ = &len; + var result = arg_result; + _ = &result; + var buf: [96]u8 = undefined; + _ = &buf; + var end: [*c]u8 = undefined; + _ = &end; + var pos: c_int = undefined; + _ = &pos; + if ((len <= @as(c_int, 0)) or (len >= @as(c_int, @bitCast(@as(c_uint, @truncate(@sizeOf([96]u8))))))) return 0; + { + pos = 0; + while (pos < len) : (pos += 1) { + while (true) { + switch (@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = pos; + if (tmp >= 0) break :blk val + @as(usize, @intCast(tmp)) else break :blk val - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*)))) { + @as(c_int, 43), @as(c_int, 45), @as(c_int, 48)...@as(c_int, 57), @as(c_int, 46), @as(c_int, 101), @as(c_int, 69) => break, + else => return 0, + } + break; + } + } + } + _ = memcpy(@as(?*anyopaque, @ptrCast(@as([*c]u8, @ptrCast(@alignCast(&buf[@as(usize, @intCast(0))]))))), @as(?*const anyopaque, @ptrCast(val)), @as(c_ulong, @bitCast(@as(c_long, len)))); + buf[@as(c_uint, @intCast(len))] = '\x00'; + result.* = spa_strtof(@as([*c]u8, @ptrCast(@alignCast(&buf[@as(usize, @intCast(0))]))), &end); + return @intFromBool((len > @as(c_int, 0)) and (end == (@as([*c]u8, @ptrCast(@alignCast(&buf[@as(usize, @intCast(0))]))) + @as(usize, @bitCast(@as(isize, @intCast(len))))))); +} +pub fn spa_json_is_float(arg_val: [*c]const u8, arg_len: c_int) callconv(.c) bool { + var val = arg_val; + _ = &val; + var len = arg_len; + _ = &len; + var dummy: f32 = undefined; + _ = &dummy; + return spa_json_parse_float(val, len, &dummy) != 0; +} +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:1002:23: warning: TODO implement function '__builtin_isnormal' in std.zig.c_builtins + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/json-core.h:442:20: warning: unable to translate function, demoted to extern +pub extern fn spa_json_format_float(arg_str: [*c]u8, arg_size: c_int, arg_val: f32) callconv(.c) [*c]u8; +pub fn spa_json_parse_int(arg_val: [*c]const u8, arg_len: c_int, arg_result: [*c]c_int) callconv(.c) c_int { + var val = arg_val; + _ = &val; + var len = arg_len; + _ = &len; + var result = arg_result; + _ = &result; + var buf: [64]u8 = undefined; + _ = &buf; + var end: [*c]u8 = undefined; + _ = &end; + if ((len <= @as(c_int, 0)) or (len >= @as(c_int, @bitCast(@as(c_uint, @truncate(@sizeOf([64]u8))))))) return 0; + _ = memcpy(@as(?*anyopaque, @ptrCast(@as([*c]u8, @ptrCast(@alignCast(&buf[@as(usize, @intCast(0))]))))), @as(?*const anyopaque, @ptrCast(val)), @as(c_ulong, @bitCast(@as(c_long, len)))); + buf[@as(c_uint, @intCast(len))] = '\x00'; + result.* = @as(c_int, @bitCast(@as(c_int, @truncate(strtol(@as([*c]u8, @ptrCast(@alignCast(&buf[@as(usize, @intCast(0))]))), &end, @as(c_int, 0)))))); + return @intFromBool((len > @as(c_int, 0)) and (end == (@as([*c]u8, @ptrCast(@alignCast(&buf[@as(usize, @intCast(0))]))) + @as(usize, @bitCast(@as(isize, @intCast(len))))))); +} +pub fn spa_json_is_int(arg_val: [*c]const u8, arg_len: c_int) callconv(.c) bool { + var val = arg_val; + _ = &val; + var len = arg_len; + _ = &len; + var dummy: c_int = undefined; + _ = &dummy; + return spa_json_parse_int(val, len, &dummy) != 0; +} +pub fn spa_json_is_true(arg_val: [*c]const u8, arg_len: c_int) callconv(.c) bool { + var val = arg_val; + _ = &val; + var len = arg_len; + _ = &len; + return (len == @as(c_int, 4)) and (strncmp(val, "true", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 4))))) == @as(c_int, 0)); +} +pub fn spa_json_is_false(arg_val: [*c]const u8, arg_len: c_int) callconv(.c) bool { + var val = arg_val; + _ = &val; + var len = arg_len; + _ = &len; + return (len == @as(c_int, 5)) and (strncmp(val, "false", @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 5))))) == @as(c_int, 0)); +} +pub fn spa_json_is_bool(arg_val: [*c]const u8, arg_len: c_int) callconv(.c) bool { + var val = arg_val; + _ = &val; + var len = arg_len; + _ = &len; + return (@as(c_int, @intFromBool(spa_json_is_true(val, len))) != 0) or (@as(c_int, @intFromBool(spa_json_is_false(val, len))) != 0); +} +pub fn spa_json_parse_bool(arg_val: [*c]const u8, arg_len: c_int, arg_result: [*c]bool) callconv(.c) c_int { + var val = arg_val; + _ = &val; + var len = arg_len; + _ = &len; + var result = arg_result; + _ = &result; + if (blk: { + const tmp = spa_json_is_true(val, len); + result.* = tmp; + break :blk tmp; + }) return 1; + if (!(blk: { + const tmp = !spa_json_is_false(val, len); + result.* = tmp; + break :blk tmp; + })) return 1; + return -@as(c_int, 1); +} +pub fn spa_json_is_string(arg_val: [*c]const u8, arg_len: c_int) callconv(.c) bool { + var val = arg_val; + _ = &val; + var len = arg_len; + _ = &len; + return (len > @as(c_int, 1)) and (@as(c_int, @bitCast(@as(c_uint, val.*))) == @as(c_int, '"')); +} +pub fn spa_json_parse_hex(arg_p: [*c]const u8, arg_num: c_int, arg_res: [*c]u32) callconv(.c) c_int { + var p = arg_p; + _ = &p; + var num = arg_num; + _ = # + var res = arg_res; + _ = &res; + var i: c_int = undefined; + _ = &i; + res.* = 0; + { + i = 0; + while (i < num) : (i += 1) { + var v: u8 = (blk: { + const tmp = i; + if (tmp >= 0) break :blk p + @as(usize, @intCast(tmp)) else break :blk p - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + _ = &v; + if ((@as(c_int, @bitCast(@as(c_uint, v))) >= @as(c_int, '0')) and (@as(c_int, @bitCast(@as(c_uint, v))) <= @as(c_int, '9'))) { + v = @as(u8, @bitCast(@as(i8, @truncate(@as(c_int, @bitCast(@as(c_uint, v))) - @as(c_int, '0'))))); + } else if ((@as(c_int, @bitCast(@as(c_uint, v))) >= @as(c_int, 'a')) and (@as(c_int, @bitCast(@as(c_uint, v))) <= @as(c_int, 'f'))) { + v = @as(u8, @bitCast(@as(i8, @truncate((@as(c_int, @bitCast(@as(c_uint, v))) - @as(c_int, 'a')) + @as(c_int, 10))))); + } else if ((@as(c_int, @bitCast(@as(c_uint, v))) >= @as(c_int, 'A')) and (@as(c_int, @bitCast(@as(c_uint, v))) <= @as(c_int, 'F'))) { + v = @as(u8, @bitCast(@as(i8, @truncate((@as(c_int, @bitCast(@as(c_uint, v))) - @as(c_int, 'A')) + @as(c_int, 10))))); + } else return -@as(c_int, 1); + res.* = (res.* << @intCast(4)) | @as(u32, @bitCast(@as(c_uint, v))); + } + } + return 1; +} +pub fn spa_json_parse_stringn(arg_val: [*c]const u8, arg_len: c_int, arg_result: [*c]u8, arg_maxlen: c_int) callconv(.c) c_int { + var val = arg_val; + _ = &val; + var len = arg_len; + _ = &len; + var result = arg_result; + _ = &result; + var maxlen = arg_maxlen; + _ = &maxlen; + var p: [*c]const u8 = undefined; + _ = &p; + if (maxlen <= len) return -@as(c_int, 28); + if (!spa_json_is_string(val, len)) { + if (result != @as([*c]u8, @ptrCast(@constCast(@volatileCast(val))))) { + _ = memmove(@as(?*anyopaque, @ptrCast(result)), @as(?*const anyopaque, @ptrCast(val)), @as(c_ulong, @bitCast(@as(c_long, len)))); + } + result += @as(usize, @bitCast(@as(isize, @intCast(len)))); + } else { + { + p = val + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))); + while (p < (val + @as(usize, @bitCast(@as(isize, @intCast(len)))))) : (p += 1) { + if (@as(c_int, @bitCast(@as(c_uint, p.*))) == @as(c_int, '\\')) { + p += 1; + if (@as(c_int, @bitCast(@as(c_uint, p.*))) == @as(c_int, 'n')) { + (blk: { + const ref = &result; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\n'; + } else if (@as(c_int, @bitCast(@as(c_uint, p.*))) == @as(c_int, 'r')) { + (blk: { + const ref = &result; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\r'; + } else if (@as(c_int, @bitCast(@as(c_uint, p.*))) == @as(c_int, 'b')) { + (blk: { + const ref = &result; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\x08'; + } else if (@as(c_int, @bitCast(@as(c_uint, p.*))) == @as(c_int, 't')) { + (blk: { + const ref = &result; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\t'; + } else if (@as(c_int, @bitCast(@as(c_uint, p.*))) == @as(c_int, 'f')) { + (blk: { + const ref = &result; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\x0c'; + } else if (@as(c_int, @bitCast(@as(c_uint, p.*))) == @as(c_int, 'u')) { + var prefix: [4]u8 = [4]u8{ + 0, + 192, + 224, + 240, + }; + _ = &prefix; + var idx: u32 = undefined; + _ = &idx; + var n: u32 = undefined; + _ = &n; + var v: u32 = undefined; + _ = &v; + var cp: u32 = undefined; + _ = &cp; + var enc: [3]u32 = [3]u32{ + 128, + @as(u32, @bitCast(@as(c_int, 2048))), + @as(u32, @bitCast(@as(c_int, 65536))), + }; + _ = &enc; + if ((@divExact(@as(c_long, @bitCast(@intFromPtr(val + @as(usize, @bitCast(@as(isize, @intCast(len))))) -% @intFromPtr(p))), @sizeOf(u8)) < @as(c_long, @bitCast(@as(c_long, @as(c_int, 5))))) or (spa_json_parse_hex(p + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 1))))), @as(c_int, 4), &cp) < @as(c_int, 0))) { + (blk: { + const ref = &result; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = p.*; + continue; + } + p += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 4))))); + if ((cp >= @as(u32, @bitCast(@as(c_int, 55296)))) and (cp <= @as(u32, @bitCast(@as(c_int, 56319))))) { + if ((((((@divExact(@as(c_long, @bitCast(@intFromPtr(val + @as(usize, @bitCast(@as(isize, @intCast(len))))) -% @intFromPtr(p))), @sizeOf(u8)) < @as(c_long, @bitCast(@as(c_long, @as(c_int, 7))))) or (@as(c_int, @bitCast(@as(c_uint, p[@as(c_uint, @intCast(@as(c_int, 1)))]))) != @as(c_int, '\\'))) or (@as(c_int, @bitCast(@as(c_uint, p[@as(c_uint, @intCast(@as(c_int, 2)))]))) != @as(c_int, 'u'))) or (spa_json_parse_hex(p + @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 3))))), @as(c_int, 4), &v) < @as(c_int, 0))) or (v < @as(u32, @bitCast(@as(c_int, 56320))))) or (v > @as(u32, @bitCast(@as(c_int, 57343))))) continue; + p += @as(usize, @bitCast(@as(isize, @intCast(@as(c_int, 6))))); + cp = @as(u32, @bitCast(@as(c_int, 65536))) +% (((cp & @as(u32, @bitCast(@as(c_int, 1023)))) << @intCast(10)) | (v & @as(u32, @bitCast(@as(c_int, 1023))))); + } else if ((cp >= @as(u32, @bitCast(@as(c_int, 56320)))) and (cp <= @as(u32, @bitCast(@as(c_int, 57343))))) continue; + { + idx = 0; + while (idx < @as(u32, @bitCast(@as(c_int, 3)))) : (idx +%= 1) if (cp < enc[idx]) break; + } + { + n = idx; + while (n > @as(u32, @bitCast(@as(c_int, 0)))) : (_ = blk: { + n -%= 1; + break :blk blk_1: { + const ref = &cp; + ref.* >>= @intCast(@as(c_int, 6)); + break :blk_1 ref.*; + }; + }) { + result[n] = @as(u8, @bitCast(@as(u8, @truncate((cp | @as(u32, @bitCast(@as(c_int, 128)))) & @as(u32, @bitCast(@as(c_int, 191))))))); + } + } + (blk: { + const ref = &result; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = @as(u8, @bitCast(@as(u8, @truncate((cp | @as(u32, @bitCast(@as(c_uint, prefix[idx])))) & @as(u32, @bitCast(@as(c_int, 255))))))); + result += idx; + } else { + (blk: { + const ref = &result; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = p.*; + } + } else if (@as(c_int, @bitCast(@as(c_uint, p.*))) == @as(c_int, '"')) { + break; + } else { + (blk: { + const ref = &result; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = p.*; + } + } + } + } + result.* = '\x00'; + return 1; +} +pub fn spa_json_parse_string(arg_val: [*c]const u8, arg_len: c_int, arg_result: [*c]u8) callconv(.c) c_int { + var val = arg_val; + _ = &val; + var len = arg_len; + _ = &len; + var result = arg_result; + _ = &result; + return spa_json_parse_stringn(val, len, result, len + @as(c_int, 1)); +} +pub fn spa_json_encode_string(arg_str: [*c]u8, arg_size: c_int, arg_val: [*c]const u8) callconv(.c) c_int { + var str = arg_str; + _ = &str; + var size = arg_size; + _ = &size; + var val = arg_val; + _ = &val; + var len: c_int = 0; + _ = &len; + const hex = struct { + const static: [16:0]u8 = "0123456789abcdef"; + }; + _ = &hex; + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '"'; + } + len += 1; + } + while (val.* != 0) { + while (true) { + switch (@as(c_int, @bitCast(@as(c_uint, val.*)))) { + @as(c_int, 10) => { + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\\'; + } + len += 1; + } + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = 'n'; + } + len += 1; + } + break; + }, + @as(c_int, 13) => { + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\\'; + } + len += 1; + } + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = 'r'; + } + len += 1; + } + break; + }, + @as(c_int, 8) => { + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\\'; + } + len += 1; + } + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = 'b'; + } + len += 1; + } + break; + }, + @as(c_int, 9) => { + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\\'; + } + len += 1; + } + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = 't'; + } + len += 1; + } + break; + }, + @as(c_int, 12) => { + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\\'; + } + len += 1; + } + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = 'f'; + } + len += 1; + } + break; + }, + @as(c_int, 92), @as(c_int, 34) => { + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\\'; + } + len += 1; + } + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = val.*; + } + len += 1; + } + break; + }, + else => { + if ((@as(c_int, @bitCast(@as(c_uint, val.*))) > @as(c_int, 0)) and (@as(c_int, @bitCast(@as(c_uint, val.*))) < @as(c_int, 32))) { + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\\'; + } + len += 1; + } + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = 'u'; + } + len += 1; + } + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '0'; + } + len += 1; + } + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '0'; + } + len += 1; + } + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = hex.static[@as(c_uint, @intCast((@as(c_int, @bitCast(@as(c_uint, val.*))) >> @intCast(4)) & @as(c_int, 15)))]; + } + len += 1; + } + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = hex.static[@as(c_uint, @intCast(@as(c_int, @bitCast(@as(c_uint, val.*))) & @as(c_int, 15)))]; + } + len += 1; + } + } else { + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = val.*; + } + len += 1; + } + } + break; + }, + } + break; + } + val += 1; + } + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '"'; + } + len += 1; + } + { + if (len < size) { + (blk: { + const ref = &str; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }).* = '\x00'; + } + len += 1; + } + return len - @as(c_int, 1); +} +pub extern fn pw_conf_load_conf_for_context(props: [*c]struct_pw_properties, conf: [*c]struct_pw_properties) c_int; +pub extern fn pw_conf_load_conf(prefix: [*c]const u8, name: [*c]const u8, conf: [*c]struct_pw_properties) c_int; +pub extern fn pw_conf_load_state(prefix: [*c]const u8, name: [*c]const u8, conf: [*c]struct_pw_properties) c_int; +pub extern fn pw_conf_save_state(prefix: [*c]const u8, name: [*c]const u8, conf: [*c]const struct_pw_properties) c_int; +pub extern fn pw_conf_find_match(arr: [*c]struct_spa_json, props: [*c]const struct_spa_dict, condition: bool) bool; +pub extern fn pw_conf_section_update_props(conf: [*c]const struct_spa_dict, section: [*c]const u8, props: [*c]struct_pw_properties) c_int; +pub extern fn pw_conf_section_update_props_rules(conf: [*c]const struct_spa_dict, context: [*c]const struct_spa_dict, section: [*c]const u8, props: [*c]struct_pw_properties) c_int; +pub extern fn pw_conf_section_for_each(conf: [*c]const struct_spa_dict, section: [*c]const u8, callback: ?*const fn (?*anyopaque, [*c]const u8, [*c]const u8, [*c]const u8, usize) callconv(.c) c_int, data: ?*anyopaque) c_int; +pub extern fn pw_conf_match_rules(str: [*c]const u8, len: usize, location: [*c]const u8, props: [*c]const struct_spa_dict, callback: ?*const fn (?*anyopaque, [*c]const u8, [*c]const u8, [*c]const u8, usize) callconv(.c) c_int, data: ?*anyopaque) c_int; +pub extern fn pw_conf_section_match_rules(conf: [*c]const struct_spa_dict, section: [*c]const u8, props: [*c]const struct_spa_dict, callback: ?*const fn (?*anyopaque, [*c]const u8, [*c]const u8, [*c]const u8, usize) callconv(.c) c_int, data: ?*anyopaque) c_int; +pub const struct_pw_device = opaque {}; +pub const struct_pw_device_info = extern struct { + id: u32 = @import("std").mem.zeroes(u32), + change_mask: u64 = @import("std").mem.zeroes(u64), + props: [*c]struct_spa_dict = @import("std").mem.zeroes([*c]struct_spa_dict), + params: [*c]struct_spa_param_info = @import("std").mem.zeroes([*c]struct_spa_param_info), + n_params: u32 = @import("std").mem.zeroes(u32), +}; +pub extern fn pw_device_info_update(info: [*c]struct_pw_device_info, update: [*c]const struct_pw_device_info) [*c]struct_pw_device_info; +pub extern fn pw_device_info_merge(info: [*c]struct_pw_device_info, update: [*c]const struct_pw_device_info, reset: bool) [*c]struct_pw_device_info; +pub extern fn pw_device_info_free(info: [*c]struct_pw_device_info) void; +pub const struct_pw_device_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + info: ?*const fn (?*anyopaque, [*c]const struct_pw_device_info) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_pw_device_info) callconv(.c) void), + param: ?*const fn (?*anyopaque, c_int, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) void), +}; +pub const struct_pw_device_methods = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + add_listener: ?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_device_events, ?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_device_events, ?*anyopaque) callconv(.c) c_int), + subscribe_params: ?*const fn (?*anyopaque, [*c]u32, u32) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]u32, u32) callconv(.c) c_int), + enum_params: ?*const fn (?*anyopaque, c_int, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int), + set_param: ?*const fn (?*anyopaque, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int), +}; +pub fn pw_device_add_listener(arg_object: ?*struct_pw_device, arg_listener: [*c]struct_spa_hook, arg_events: [*c]const struct_pw_device_events, arg_data: ?*anyopaque) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var listener = arg_listener; + _ = &listener; + var events = arg_events; + _ = &events; + var data = arg_data; + _ = &data; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_device_methods = @as([*c]const struct_pw_device_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_listener != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.add_listener.?((&_i.*.cb).*.data, listener, events, data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_device_subscribe_params(arg_object: ?*struct_pw_device, arg_ids: [*c]u32, arg_n_ids: u32) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var ids = arg_ids; + _ = &ids; + var n_ids = arg_n_ids; + _ = &n_ids; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_device_methods = @as([*c]const struct_pw_device_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.subscribe_params != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.subscribe_params.?((&_i.*.cb).*.data, ids, n_ids); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_device_enum_params(arg_object: ?*struct_pw_device, arg_seq: c_int, arg_id: u32, arg_start: u32, arg_num: u32, arg_filter: [*c]const struct_spa_pod) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var seq = arg_seq; + _ = &seq; + var id = arg_id; + _ = &id; + var start = arg_start; + _ = &start; + var num = arg_num; + _ = # + var filter = arg_filter; + _ = &filter; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_device_methods = @as([*c]const struct_pw_device_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.enum_params != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.enum_params.?((&_i.*.cb).*.data, seq, id, start, num, filter); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_device_set_param(arg_object: ?*struct_pw_device, arg_id: u32, arg_flags: u32, arg_param: [*c]const struct_spa_pod) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var id = arg_id; + _ = &id; + var flags = arg_flags; + _ = &flags; + var param = arg_param; + _ = ¶m; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_device_methods = @as([*c]const struct_pw_device_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.set_param != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.set_param.?((&_i.*.cb).*.data, id, flags, param); + } + _ = &_res; + } + break :blk _res; + }; +} +pub const SPA_META_Invalid: c_int = 0; +pub const SPA_META_Header: c_int = 1; +pub const SPA_META_VideoCrop: c_int = 2; +pub const SPA_META_VideoDamage: c_int = 3; +pub const SPA_META_Bitmap: c_int = 4; +pub const SPA_META_Cursor: c_int = 5; +pub const SPA_META_Control: c_int = 6; +pub const SPA_META_Busy: c_int = 7; +pub const SPA_META_VideoTransform: c_int = 8; +pub const SPA_META_SyncTimeline: c_int = 9; +pub const _SPA_META_LAST: c_int = 10; +pub const SPA_META_START_custom: c_int = 512; +pub const SPA_META_START_features: c_int = 65536; +pub const enum_spa_meta_type = c_uint; +pub const struct_spa_meta = extern struct { + type: u32 = @import("std").mem.zeroes(u32), + size: u32 = @import("std").mem.zeroes(u32), + data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), +}; +pub fn spa_meta_first(arg_m: [*c]const struct_spa_meta) callconv(.c) ?*anyopaque { + var m = arg_m; + _ = &m; + return m.*.data; +} +pub fn spa_meta_end(arg_m: [*c]const struct_spa_meta) callconv(.c) ?*anyopaque { + var m = arg_m; + _ = &m; + return @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(m.*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, m.*.size))))))); +} +pub const struct_spa_meta_header = extern struct { + flags: u32 = @import("std").mem.zeroes(u32), + offset: u32 = @import("std").mem.zeroes(u32), + pts: i64 = @import("std").mem.zeroes(i64), + dts_offset: i64 = @import("std").mem.zeroes(i64), + seq: u64 = @import("std").mem.zeroes(u64), +}; +pub const struct_spa_meta_region = extern struct { + region: struct_spa_region = @import("std").mem.zeroes(struct_spa_region), +}; +pub fn spa_meta_region_is_valid(arg_m: [*c]const struct_spa_meta_region) callconv(.c) bool { + var m = arg_m; + _ = &m; + return (m.*.region.size.width != @as(u32, @bitCast(@as(c_int, 0)))) and (m.*.region.size.height != @as(u32, @bitCast(@as(c_int, 0)))); +} +pub const struct_spa_meta_bitmap = extern struct { + format: u32 = @import("std").mem.zeroes(u32), + size: struct_spa_rectangle = @import("std").mem.zeroes(struct_spa_rectangle), + stride: i32 = @import("std").mem.zeroes(i32), + offset: u32 = @import("std").mem.zeroes(u32), +}; +pub fn spa_meta_bitmap_is_valid(arg_m: [*c]const struct_spa_meta_bitmap) callconv(.c) bool { + var m = arg_m; + _ = &m; + return m.*.format != @as(u32, @bitCast(@as(c_int, 0))); +} +pub const struct_spa_meta_cursor = extern struct { + id: u32 = @import("std").mem.zeroes(u32), + flags: u32 = @import("std").mem.zeroes(u32), + position: struct_spa_point = @import("std").mem.zeroes(struct_spa_point), + hotspot: struct_spa_point = @import("std").mem.zeroes(struct_spa_point), + bitmap_offset: u32 = @import("std").mem.zeroes(u32), +}; +pub fn spa_meta_cursor_is_valid(arg_m: [*c]const struct_spa_meta_cursor) callconv(.c) bool { + var m = arg_m; + _ = &m; + return m.*.id != @as(u32, @bitCast(@as(c_int, 0))); +} +pub const struct_spa_meta_control = extern struct { + sequence: struct_spa_pod_sequence = @import("std").mem.zeroes(struct_spa_pod_sequence), +}; +pub const struct_spa_meta_busy = extern struct { + flags: u32 = @import("std").mem.zeroes(u32), + count: u32 = @import("std").mem.zeroes(u32), +}; +pub const SPA_META_TRANSFORMATION_None: c_int = 0; +pub const SPA_META_TRANSFORMATION_90: c_int = 1; +pub const SPA_META_TRANSFORMATION_180: c_int = 2; +pub const SPA_META_TRANSFORMATION_270: c_int = 3; +pub const SPA_META_TRANSFORMATION_Flipped: c_int = 4; +pub const SPA_META_TRANSFORMATION_Flipped90: c_int = 5; +pub const SPA_META_TRANSFORMATION_Flipped180: c_int = 6; +pub const SPA_META_TRANSFORMATION_Flipped270: c_int = 7; +pub const enum_spa_meta_videotransform_value = c_uint; +pub const struct_spa_meta_videotransform = extern struct { + transform: u32 = @import("std").mem.zeroes(u32), +}; +pub const struct_spa_meta_sync_timeline = extern struct { + flags: u32 = @import("std").mem.zeroes(u32), + padding: u32 = @import("std").mem.zeroes(u32), + acquire_point: u64 = @import("std").mem.zeroes(u64), + release_point: u64 = @import("std").mem.zeroes(u64), +}; +pub const SPA_DATA_Invalid: c_int = 0; +pub const SPA_DATA_MemPtr: c_int = 1; +pub const SPA_DATA_MemFd: c_int = 2; +pub const SPA_DATA_DmaBuf: c_int = 3; +pub const SPA_DATA_MemId: c_int = 4; +pub const SPA_DATA_SyncObj: c_int = 5; +pub const _SPA_DATA_LAST: c_int = 6; +pub const enum_spa_data_type = c_uint; +pub const struct_spa_chunk = extern struct { + offset: u32 = @import("std").mem.zeroes(u32), + size: u32 = @import("std").mem.zeroes(u32), + stride: i32 = @import("std").mem.zeroes(i32), + flags: i32 = @import("std").mem.zeroes(i32), +}; +pub const struct_spa_data = extern struct { + type: u32 = @import("std").mem.zeroes(u32), + flags: u32 = @import("std").mem.zeroes(u32), + fd: i64 = @import("std").mem.zeroes(i64), + mapoffset: u32 = @import("std").mem.zeroes(u32), + maxsize: u32 = @import("std").mem.zeroes(u32), + data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + chunk: [*c]struct_spa_chunk = @import("std").mem.zeroes([*c]struct_spa_chunk), +}; +pub const struct_spa_buffer = extern struct { + n_metas: u32 = @import("std").mem.zeroes(u32), + n_datas: u32 = @import("std").mem.zeroes(u32), + metas: [*c]struct_spa_meta = @import("std").mem.zeroes([*c]struct_spa_meta), + datas: [*c]struct_spa_data = @import("std").mem.zeroes([*c]struct_spa_data), +}; +pub fn spa_buffer_find_meta(arg_b: [*c]const struct_spa_buffer, arg_type: u32) callconv(.c) [*c]struct_spa_meta { + var b = arg_b; + _ = &b; + var @"type" = arg_type; + _ = &@"type"; + var i: u32 = undefined; + _ = &i; + { + i = 0; + while (i < b.*.n_metas) : (i +%= 1) if (b.*.metas[i].type == @"type") return &b.*.metas[i]; + } + return null; +} +pub fn spa_buffer_find_meta_data(arg_b: [*c]const struct_spa_buffer, arg_type: u32, arg_size: usize) callconv(.c) ?*anyopaque { + var b = arg_b; + _ = &b; + var @"type" = arg_type; + _ = &@"type"; + var size = arg_size; + _ = &size; + var m: [*c]struct_spa_meta = undefined; + _ = &m; + if (((blk: { + const tmp = spa_buffer_find_meta(b, @"type"); + m = tmp; + break :blk tmp; + }) != null) and (@as(usize, @bitCast(@as(c_ulong, m.*.size))) >= size)) return m.*.data; + return @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); +} +pub fn spa_buffer_has_meta_features(arg_b: [*c]const struct_spa_buffer, arg_type: u32, arg_features: u32) callconv(.c) bool { + var b = arg_b; + _ = &b; + var @"type" = arg_type; + _ = &@"type"; + var features = arg_features; + _ = &features; + var i: u32 = undefined; + _ = &i; + { + i = 0; + while (i < b.*.n_metas) : (i +%= 1) { + var t: u32 = b.*.metas[i].type; + _ = &t; + if (((t >> @intCast(16)) == @"type") and ((t & features) == features)) return @as(c_int, 1) != 0; + } + } + return @as(c_int, 0) != 0; +} +pub const struct_spa_event_body = extern struct { + body: struct_spa_pod_object_body = @import("std").mem.zeroes(struct_spa_pod_object_body), +}; +pub const struct_spa_event = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), + body: struct_spa_event_body = @import("std").mem.zeroes(struct_spa_event_body), +}; +pub const SPA_NODE_EVENT_Error: c_int = 0; +pub const SPA_NODE_EVENT_Buffering: c_int = 1; +pub const SPA_NODE_EVENT_RequestRefresh: c_int = 2; +pub const SPA_NODE_EVENT_RequestProcess: c_int = 3; +pub const SPA_NODE_EVENT_User: c_int = 4; +pub const enum_spa_node_event = c_uint; +pub const SPA_EVENT_NODE_START: c_int = 0; +pub const SPA_EVENT_NODE_START_User: c_int = 4096; +pub const SPA_EVENT_NODE_extra: c_int = 4097; +pub const SPA_EVENT_NODE_START_CUSTOM: c_int = 16777216; +pub const enum_spa_event_node = c_uint; +pub const struct_spa_command_body = extern struct { + body: struct_spa_pod_object_body = @import("std").mem.zeroes(struct_spa_pod_object_body), +}; +pub const struct_spa_command = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), + body: struct_spa_command_body = @import("std").mem.zeroes(struct_spa_command_body), +}; +pub const SPA_NODE_COMMAND_Suspend: c_int = 0; +pub const SPA_NODE_COMMAND_Pause: c_int = 1; +pub const SPA_NODE_COMMAND_Start: c_int = 2; +pub const SPA_NODE_COMMAND_Enable: c_int = 3; +pub const SPA_NODE_COMMAND_Disable: c_int = 4; +pub const SPA_NODE_COMMAND_Flush: c_int = 5; +pub const SPA_NODE_COMMAND_Drain: c_int = 6; +pub const SPA_NODE_COMMAND_Marker: c_int = 7; +pub const SPA_NODE_COMMAND_ParamBegin: c_int = 8; +pub const SPA_NODE_COMMAND_ParamEnd: c_int = 9; +pub const SPA_NODE_COMMAND_RequestProcess: c_int = 10; +pub const SPA_NODE_COMMAND_User: c_int = 11; +pub const enum_spa_node_command = c_uint; +pub const SPA_COMMAND_NODE_START: c_int = 0; +pub const SPA_COMMAND_NODE_START_User: c_int = 4096; +pub const SPA_COMMAND_NODE_extra: c_int = 4097; +pub const SPA_COMMAND_NODE_START_CUSTOM: c_int = 16777216; +pub const enum_spa_command_node = c_uint; +pub const struct_spa_node = extern struct { + iface: struct_spa_interface = @import("std").mem.zeroes(struct_spa_interface), +}; +pub const struct_spa_node_info = extern struct { + max_input_ports: u32 = @import("std").mem.zeroes(u32), + max_output_ports: u32 = @import("std").mem.zeroes(u32), + change_mask: u64 = @import("std").mem.zeroes(u64), + flags: u64 = @import("std").mem.zeroes(u64), + props: [*c]struct_spa_dict = @import("std").mem.zeroes([*c]struct_spa_dict), + params: [*c]struct_spa_param_info = @import("std").mem.zeroes([*c]struct_spa_param_info), + n_params: u32 = @import("std").mem.zeroes(u32), +}; +pub const struct_spa_port_info = extern struct { + change_mask: u64 = @import("std").mem.zeroes(u64), + flags: u64 = @import("std").mem.zeroes(u64), + rate: struct_spa_fraction = @import("std").mem.zeroes(struct_spa_fraction), + props: [*c]const struct_spa_dict = @import("std").mem.zeroes([*c]const struct_spa_dict), + params: [*c]struct_spa_param_info = @import("std").mem.zeroes([*c]struct_spa_param_info), + n_params: u32 = @import("std").mem.zeroes(u32), +}; +pub const struct_spa_result_node_error = extern struct { + message: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), +}; +pub const struct_spa_result_node_params = extern struct { + id: u32 = @import("std").mem.zeroes(u32), + index: u32 = @import("std").mem.zeroes(u32), + next: u32 = @import("std").mem.zeroes(u32), + param: [*c]struct_spa_pod = @import("std").mem.zeroes([*c]struct_spa_pod), +}; +pub const struct_spa_node_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + info: ?*const fn (?*anyopaque, [*c]const struct_spa_node_info) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_spa_node_info) callconv(.c) void), + port_info: ?*const fn (?*anyopaque, enum_spa_direction, u32, [*c]const struct_spa_port_info) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, enum_spa_direction, u32, [*c]const struct_spa_port_info) callconv(.c) void), + result: ?*const fn (?*anyopaque, c_int, c_int, u32, ?*const anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, c_int, u32, ?*const anyopaque) callconv(.c) void), + event: ?*const fn (?*anyopaque, [*c]const struct_spa_event) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_spa_event) callconv(.c) void), +}; +pub const struct_spa_node_callbacks = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + ready: ?*const fn (?*anyopaque, c_int) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int) callconv(.c) c_int), + reuse_buffer: ?*const fn (?*anyopaque, u32, u32) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, u32) callconv(.c) c_int), + xrun: ?*const fn (?*anyopaque, u64, u64, [*c]struct_spa_pod) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, u64, u64, [*c]struct_spa_pod) callconv(.c) c_int), +}; +pub const struct_spa_node_methods = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + add_listener: ?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_spa_node_events, ?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_spa_node_events, ?*anyopaque) callconv(.c) c_int), + set_callbacks: ?*const fn (?*anyopaque, [*c]const struct_spa_node_callbacks, ?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_spa_node_callbacks, ?*anyopaque) callconv(.c) c_int), + sync: ?*const fn (?*anyopaque, c_int) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int) callconv(.c) c_int), + enum_params: ?*const fn (?*anyopaque, c_int, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int), + set_param: ?*const fn (?*anyopaque, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int), + set_io: ?*const fn (?*anyopaque, u32, ?*anyopaque, usize) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, ?*anyopaque, usize) callconv(.c) c_int), + send_command: ?*const fn (?*anyopaque, [*c]const struct_spa_command) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_spa_command) callconv(.c) c_int), + add_port: ?*const fn (?*anyopaque, enum_spa_direction, u32, [*c]const struct_spa_dict) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, enum_spa_direction, u32, [*c]const struct_spa_dict) callconv(.c) c_int), + remove_port: ?*const fn (?*anyopaque, enum_spa_direction, u32) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, enum_spa_direction, u32) callconv(.c) c_int), + port_enum_params: ?*const fn (?*anyopaque, c_int, enum_spa_direction, u32, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, enum_spa_direction, u32, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int), + port_set_param: ?*const fn (?*anyopaque, enum_spa_direction, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, enum_spa_direction, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int), + port_use_buffers: ?*const fn (?*anyopaque, enum_spa_direction, u32, u32, [*c][*c]struct_spa_buffer, u32) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, enum_spa_direction, u32, u32, [*c][*c]struct_spa_buffer, u32) callconv(.c) c_int), + port_set_io: ?*const fn (?*anyopaque, enum_spa_direction, u32, u32, ?*anyopaque, usize) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, enum_spa_direction, u32, u32, ?*anyopaque, usize) callconv(.c) c_int), + port_reuse_buffer: ?*const fn (?*anyopaque, u32, u32) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, u32) callconv(.c) c_int), + process: ?*const fn (?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) c_int), +}; +pub fn spa_node_add_listener(arg_object: [*c]struct_spa_node, arg_listener: [*c]struct_spa_hook, arg_events: [*c]const struct_spa_node_events, arg_data: ?*anyopaque) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var listener = arg_listener; + _ = &listener; + var events = arg_events; + _ = &events; + var data = arg_data; + _ = &data; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_node_methods = @as([*c]const struct_spa_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_listener != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.add_listener.?((&_i.*.cb).*.data, listener, events, data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_node_set_callbacks(arg_object: [*c]struct_spa_node, arg_callbacks: [*c]const struct_spa_node_callbacks, arg_data: ?*anyopaque) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var callbacks = arg_callbacks; + _ = &callbacks; + var data = arg_data; + _ = &data; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_node_methods = @as([*c]const struct_spa_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.set_callbacks != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.set_callbacks.?((&_i.*.cb).*.data, callbacks, data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_node_sync(arg_object: [*c]struct_spa_node, arg_seq: c_int) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var seq = arg_seq; + _ = &seq; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_node_methods = @as([*c]const struct_spa_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.sync != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.sync.?((&_i.*.cb).*.data, seq); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_node_enum_params(arg_object: [*c]struct_spa_node, arg_seq: c_int, arg_id: u32, arg_start: u32, arg_max: u32, arg_filter: [*c]const struct_spa_pod) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var seq = arg_seq; + _ = &seq; + var id = arg_id; + _ = &id; + var start = arg_start; + _ = &start; + var max = arg_max; + _ = &max; + var filter = arg_filter; + _ = &filter; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_node_methods = @as([*c]const struct_spa_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.enum_params != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.enum_params.?((&_i.*.cb).*.data, seq, id, start, max, filter); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_node_set_param(arg_object: [*c]struct_spa_node, arg_id: u32, arg_flags: u32, arg_param: [*c]const struct_spa_pod) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var id = arg_id; + _ = &id; + var flags = arg_flags; + _ = &flags; + var param = arg_param; + _ = ¶m; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_node_methods = @as([*c]const struct_spa_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.set_param != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.set_param.?((&_i.*.cb).*.data, id, flags, param); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_node_set_io(arg_object: [*c]struct_spa_node, arg_id: u32, arg_data: ?*anyopaque, arg_size: usize) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var id = arg_id; + _ = &id; + var data = arg_data; + _ = &data; + var size = arg_size; + _ = &size; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_node_methods = @as([*c]const struct_spa_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.set_io != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.set_io.?((&_i.*.cb).*.data, id, data, size); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_node_send_command(arg_object: [*c]struct_spa_node, arg_command: [*c]const struct_spa_command) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var command = arg_command; + _ = &command; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_node_methods = @as([*c]const struct_spa_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.send_command != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.send_command.?((&_i.*.cb).*.data, command); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_node_add_port(arg_object: [*c]struct_spa_node, arg_direction: enum_spa_direction, arg_port_id: u32, arg_props: [*c]const struct_spa_dict) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var direction = arg_direction; + _ = &direction; + var port_id = arg_port_id; + _ = &port_id; + var props = arg_props; + _ = &props; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_node_methods = @as([*c]const struct_spa_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_port != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.add_port.?((&_i.*.cb).*.data, direction, port_id, props); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_node_remove_port(arg_object: [*c]struct_spa_node, arg_direction: enum_spa_direction, arg_port_id: u32) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var direction = arg_direction; + _ = &direction; + var port_id = arg_port_id; + _ = &port_id; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_node_methods = @as([*c]const struct_spa_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.remove_port != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.remove_port.?((&_i.*.cb).*.data, direction, port_id); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_node_port_enum_params(arg_object: [*c]struct_spa_node, arg_seq: c_int, arg_direction: enum_spa_direction, arg_port_id: u32, arg_id: u32, arg_start: u32, arg_max: u32, arg_filter: [*c]const struct_spa_pod) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var seq = arg_seq; + _ = &seq; + var direction = arg_direction; + _ = &direction; + var port_id = arg_port_id; + _ = &port_id; + var id = arg_id; + _ = &id; + var start = arg_start; + _ = &start; + var max = arg_max; + _ = &max; + var filter = arg_filter; + _ = &filter; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_node_methods = @as([*c]const struct_spa_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.port_enum_params != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.port_enum_params.?((&_i.*.cb).*.data, seq, direction, port_id, id, start, max, filter); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_node_port_set_param(arg_object: [*c]struct_spa_node, arg_direction: enum_spa_direction, arg_port_id: u32, arg_id: u32, arg_flags: u32, arg_param: [*c]const struct_spa_pod) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var direction = arg_direction; + _ = &direction; + var port_id = arg_port_id; + _ = &port_id; + var id = arg_id; + _ = &id; + var flags = arg_flags; + _ = &flags; + var param = arg_param; + _ = ¶m; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_node_methods = @as([*c]const struct_spa_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.port_set_param != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.port_set_param.?((&_i.*.cb).*.data, direction, port_id, id, flags, param); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_node_port_use_buffers(arg_object: [*c]struct_spa_node, arg_direction: enum_spa_direction, arg_port_id: u32, arg_flags: u32, arg_buffers: [*c][*c]struct_spa_buffer, arg_n_buffers: u32) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var direction = arg_direction; + _ = &direction; + var port_id = arg_port_id; + _ = &port_id; + var flags = arg_flags; + _ = &flags; + var buffers = arg_buffers; + _ = &buffers; + var n_buffers = arg_n_buffers; + _ = &n_buffers; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_node_methods = @as([*c]const struct_spa_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.port_use_buffers != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.port_use_buffers.?((&_i.*.cb).*.data, direction, port_id, flags, buffers, n_buffers); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_node_port_set_io(arg_object: [*c]struct_spa_node, arg_direction: enum_spa_direction, arg_port_id: u32, arg_id: u32, arg_data: ?*anyopaque, arg_size: usize) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var direction = arg_direction; + _ = &direction; + var port_id = arg_port_id; + _ = &port_id; + var id = arg_id; + _ = &id; + var data = arg_data; + _ = &data; + var size = arg_size; + _ = &size; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_node_methods = @as([*c]const struct_spa_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.port_set_io != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.port_set_io.?((&_i.*.cb).*.data, direction, port_id, id, data, size); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_node_port_reuse_buffer(arg_object: [*c]struct_spa_node, arg_port_id: u32, arg_buffer_id: u32) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var port_id = arg_port_id; + _ = &port_id; + var buffer_id = arg_buffer_id; + _ = &buffer_id; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_node_methods = @as([*c]const struct_spa_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.port_reuse_buffer != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.port_reuse_buffer.?((&_i.*.cb).*.data, port_id, buffer_id); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_node_port_reuse_buffer_fast(arg_object: [*c]struct_spa_node, arg_port_id: u32, arg_buffer_id: u32) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var port_id = arg_port_id; + _ = &port_id; + var buffer_id = arg_buffer_id; + _ = &buffer_id; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_node_methods = @as([*c]const struct_spa_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.port_reuse_buffer.?((&_i.*.cb).*.data, port_id, buffer_id); + } + break :blk _res; + }; +} +pub fn spa_node_process(arg_object: [*c]struct_spa_node) callconv(.c) c_int { + var object = arg_object; + _ = &object; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_node_methods = @as([*c]const struct_spa_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.process != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.process.?((&_i.*.cb).*.data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_node_process_fast(arg_object: [*c]struct_spa_node) callconv(.c) c_int { + var object = arg_object; + _ = &object; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &object.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_node_methods = @as([*c]const struct_spa_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + _res = _f.*.process.?((&_i.*.cb).*.data); + } + break :blk _res; + }; +} +pub const PW_MEMBLOCK_FLAG_NONE: c_int = 0; +pub const PW_MEMBLOCK_FLAG_READABLE: c_int = 1; +pub const PW_MEMBLOCK_FLAG_WRITABLE: c_int = 2; +pub const PW_MEMBLOCK_FLAG_SEAL: c_int = 4; +pub const PW_MEMBLOCK_FLAG_MAP: c_int = 8; +pub const PW_MEMBLOCK_FLAG_DONT_CLOSE: c_int = 16; +pub const PW_MEMBLOCK_FLAG_DONT_NOTIFY: c_int = 32; +pub const PW_MEMBLOCK_FLAG_UNMAPPABLE: c_int = 64; +pub const PW_MEMBLOCK_FLAG_READWRITE: c_int = 3; +pub const enum_pw_memblock_flags = c_uint; +pub const PW_MEMMAP_FLAG_NONE: c_int = 0; +pub const PW_MEMMAP_FLAG_READ: c_int = 1; +pub const PW_MEMMAP_FLAG_WRITE: c_int = 2; +pub const PW_MEMMAP_FLAG_TWICE: c_int = 4; +pub const PW_MEMMAP_FLAG_PRIVATE: c_int = 8; +pub const PW_MEMMAP_FLAG_LOCKED: c_int = 16; +pub const PW_MEMMAP_FLAG_READWRITE: c_int = 3; +pub const enum_pw_memmap_flags = c_uint; +pub const struct_pw_memchunk = opaque {}; +pub const struct_pw_memmap = extern struct { + block: [*c]struct_pw_memblock = @import("std").mem.zeroes([*c]struct_pw_memblock), + ptr: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + flags: u32 = @import("std").mem.zeroes(u32), + offset: u32 = @import("std").mem.zeroes(u32), + size: u32 = @import("std").mem.zeroes(u32), + tag: [5]u32 = @import("std").mem.zeroes([5]u32), +}; +pub const struct_pw_memblock = extern struct { + pool: [*c]struct_pw_mempool = @import("std").mem.zeroes([*c]struct_pw_mempool), + id: u32 = @import("std").mem.zeroes(u32), + ref: c_int = @import("std").mem.zeroes(c_int), + flags: u32 = @import("std").mem.zeroes(u32), + type: u32 = @import("std").mem.zeroes(u32), + fd: c_int = @import("std").mem.zeroes(c_int), + size: u32 = @import("std").mem.zeroes(u32), + map: [*c]struct_pw_memmap = @import("std").mem.zeroes([*c]struct_pw_memmap), +}; +pub const struct_pw_mempool_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + destroy: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), + added: ?*const fn (?*anyopaque, [*c]struct_pw_memblock) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_pw_memblock) callconv(.c) void), + removed: ?*const fn (?*anyopaque, [*c]struct_pw_memblock) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_pw_memblock) callconv(.c) void), +}; +pub extern fn pw_mempool_new(props: [*c]struct_pw_properties) [*c]struct_pw_mempool; +pub extern fn pw_mempool_add_listener(pool: [*c]struct_pw_mempool, listener: [*c]struct_spa_hook, events: [*c]const struct_pw_mempool_events, data: ?*anyopaque) void; +pub extern fn pw_mempool_clear(pool: [*c]struct_pw_mempool) void; +pub extern fn pw_mempool_destroy(pool: [*c]struct_pw_mempool) void; +pub extern fn pw_mempool_alloc(pool: [*c]struct_pw_mempool, flags: enum_pw_memblock_flags, @"type": u32, size: usize) [*c]struct_pw_memblock; +pub extern fn pw_mempool_import_block(pool: [*c]struct_pw_mempool, mem: [*c]struct_pw_memblock) [*c]struct_pw_memblock; +pub extern fn pw_mempool_import(pool: [*c]struct_pw_mempool, flags: enum_pw_memblock_flags, @"type": u32, fd: c_int) [*c]struct_pw_memblock; +pub extern fn pw_memblock_free(mem: [*c]struct_pw_memblock) void; +pub fn pw_memblock_unref(arg_mem: [*c]struct_pw_memblock) callconv(.c) void { + var mem = arg_mem; + _ = &mem; + if ((blk: { + const ref = &mem.*.ref; + ref.* -= 1; + break :blk ref.*; + }) == @as(c_int, 0)) { + pw_memblock_free(mem); + } +} +pub extern fn pw_mempool_remove_id(pool: [*c]struct_pw_mempool, id: u32) c_int; +pub extern fn pw_mempool_find_ptr(pool: [*c]struct_pw_mempool, ptr: ?*const anyopaque) [*c]struct_pw_memblock; +pub extern fn pw_mempool_find_id(pool: [*c]struct_pw_mempool, id: u32) [*c]struct_pw_memblock; +pub extern fn pw_mempool_find_fd(pool: [*c]struct_pw_mempool, fd: c_int) [*c]struct_pw_memblock; +pub extern fn pw_memblock_map(block: [*c]struct_pw_memblock, flags: enum_pw_memmap_flags, offset: u32, size: u32, tag: [*c]u32) [*c]struct_pw_memmap; +pub extern fn pw_mempool_map_id(pool: [*c]struct_pw_mempool, id: u32, flags: enum_pw_memmap_flags, offset: u32, size: u32, tag: [*c]u32) [*c]struct_pw_memmap; +pub extern fn pw_mempool_import_map(pool: [*c]struct_pw_mempool, other: [*c]struct_pw_mempool, data: ?*anyopaque, size: u32, tag: [*c]u32) [*c]struct_pw_memmap; +pub extern fn pw_mempool_find_tag(pool: [*c]struct_pw_mempool, tag: [*c]u32, size: usize) [*c]struct_pw_memmap; +pub extern fn pw_memmap_free(map: [*c]struct_pw_memmap) c_int; +pub const struct_pw_map_range = extern struct { + start: u32 = @import("std").mem.zeroes(u32), + offset: u32 = @import("std").mem.zeroes(u32), + size: u32 = @import("std").mem.zeroes(u32), +}; +pub fn pw_map_range_init(arg_range: [*c]struct_pw_map_range, arg_offset: u32, arg_size: u32, arg_page_size: u32) callconv(.c) void { + var range = arg_range; + _ = ⦥ + var offset = arg_offset; + _ = &offset; + var size = arg_size; + _ = &size; + var page_size = arg_page_size; + _ = &page_size; + range.*.offset = offset & ~@as(@TypeOf(offset), @bitCast(page_size -% @as(u32, @bitCast(@as(c_int, 1))))); + range.*.start = offset -% range.*.offset; + range.*.size = (((range.*.start +% size) -% @as(u32, @bitCast(@as(c_int, 1)))) | @as(@TypeOf(range.*.start +% size), @bitCast(page_size -% @as(u32, @bitCast(@as(c_int, 1)))))) +% @as(u32, @bitCast(@as(c_int, 1))); +} +pub const struct_pw_buffers = extern struct { + mem: [*c]struct_pw_memblock = @import("std").mem.zeroes([*c]struct_pw_memblock), + buffers: [*c][*c]struct_spa_buffer = @import("std").mem.zeroes([*c][*c]struct_spa_buffer), + n_buffers: u32 = @import("std").mem.zeroes(u32), + flags: u32 = @import("std").mem.zeroes(u32), +}; +pub extern fn pw_buffers_negotiate(context: ?*struct_pw_context, flags: u32, outnode: [*c]struct_spa_node, out_port_id: u32, innode: [*c]struct_spa_node, in_port_id: u32, result: [*c]struct_pw_buffers) c_int; +pub extern fn pw_buffers_clear(buffers: [*c]struct_pw_buffers) void; +pub const struct_pw_factory = opaque {}; +pub const struct_pw_factory_info = extern struct { + id: u32 = @import("std").mem.zeroes(u32), + name: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + type: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + version: u32 = @import("std").mem.zeroes(u32), + change_mask: u64 = @import("std").mem.zeroes(u64), + props: [*c]struct_spa_dict = @import("std").mem.zeroes([*c]struct_spa_dict), +}; +pub extern fn pw_factory_info_update(info: [*c]struct_pw_factory_info, update: [*c]const struct_pw_factory_info) [*c]struct_pw_factory_info; +pub extern fn pw_factory_info_merge(info: [*c]struct_pw_factory_info, update: [*c]const struct_pw_factory_info, reset: bool) [*c]struct_pw_factory_info; +pub extern fn pw_factory_info_free(info: [*c]struct_pw_factory_info) void; +pub const struct_pw_factory_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + info: ?*const fn (?*anyopaque, [*c]const struct_pw_factory_info) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_pw_factory_info) callconv(.c) void), +}; +pub const struct_pw_factory_methods = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + add_listener: ?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_factory_events, ?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_factory_events, ?*anyopaque) callconv(.c) c_int), +}; +pub fn pw_factory_add_listener(arg_object: ?*struct_pw_factory, arg_listener: [*c]struct_spa_hook, arg_events: [*c]const struct_pw_factory_events, arg_data: ?*anyopaque) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var listener = arg_listener; + _ = &listener; + var events = arg_events; + _ = &events; + var data = arg_data; + _ = &data; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_factory_methods = @as([*c]const struct_pw_factory_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_listener != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.add_listener.?((&_i.*.cb).*.data, listener, events, data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub const SPA_LOG_LEVEL_NONE: c_int = 0; +pub const SPA_LOG_LEVEL_ERROR: c_int = 1; +pub const SPA_LOG_LEVEL_WARN: c_int = 2; +pub const SPA_LOG_LEVEL_INFO: c_int = 3; +pub const SPA_LOG_LEVEL_DEBUG: c_int = 4; +pub const SPA_LOG_LEVEL_TRACE: c_int = 5; +pub const enum_spa_log_level = c_uint; +pub const struct_spa_log = extern struct { + iface: struct_spa_interface = @import("std").mem.zeroes(struct_spa_interface), + level: enum_spa_log_level = @import("std").mem.zeroes(enum_spa_log_level), +}; +pub const struct_spa_log_topic = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + topic: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + level: enum_spa_log_level = @import("std").mem.zeroes(enum_spa_log_level), + has_custom_level: bool = @import("std").mem.zeroes(bool), +}; +pub const struct_spa_log_topic_enum = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + topics: [*c]const [*c]struct_spa_log_topic = @import("std").mem.zeroes([*c]const [*c]struct_spa_log_topic), + topics_end: [*c]const [*c]struct_spa_log_topic = @import("std").mem.zeroes([*c]const [*c]struct_spa_log_topic), +}; +pub const struct_spa_log_methods = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + log: ?*const fn (?*anyopaque, enum_spa_log_level, [*c]const u8, c_int, [*c]const u8, [*c]const u8, ...) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, enum_spa_log_level, [*c]const u8, c_int, [*c]const u8, [*c]const u8, ...) callconv(.c) void), + logv: ?*const fn (?*anyopaque, enum_spa_log_level, [*c]const u8, c_int, [*c]const u8, [*c]const u8, [*c]struct___va_list_tag_26) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, enum_spa_log_level, [*c]const u8, c_int, [*c]const u8, [*c]const u8, [*c]struct___va_list_tag_26) callconv(.c) void), + logt: ?*const fn (?*anyopaque, enum_spa_log_level, [*c]const struct_spa_log_topic, [*c]const u8, c_int, [*c]const u8, [*c]const u8, ...) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, enum_spa_log_level, [*c]const struct_spa_log_topic, [*c]const u8, c_int, [*c]const u8, [*c]const u8, ...) callconv(.c) void), + logtv: ?*const fn (?*anyopaque, enum_spa_log_level, [*c]const struct_spa_log_topic, [*c]const u8, c_int, [*c]const u8, [*c]const u8, [*c]struct___va_list_tag_26) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, enum_spa_log_level, [*c]const struct_spa_log_topic, [*c]const u8, c_int, [*c]const u8, [*c]const u8, [*c]struct___va_list_tag_26) callconv(.c) void), + topic_init: ?*const fn (?*anyopaque, [*c]struct_spa_log_topic) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_log_topic) callconv(.c) void), +}; +pub fn spa_log_topic_init(arg_log_1: [*c]struct_spa_log, arg_topic: [*c]struct_spa_log_topic) callconv(.c) void { + var log_1 = arg_log_1; + _ = &log_1; + var topic = arg_topic; + _ = &topic; + if (__builtin_expect(@as(c_long, @intFromBool(!!!(log_1 != null))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 0))))) != 0) return; + { + var _f: [*c]const struct_spa_log_methods = @as([*c]const struct_spa_log_methods, @ptrCast(@alignCast((&(&log_1.*.iface).*.cb).*.funcs))); + _ = &_f; + var _res: bool = ((_f != null) and ((@as(c_int, 1) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 1) - @as(c_int, 1)))))) and (_f.*.topic_init != null); + _ = &_res; + if (__builtin_expect(@as(c_long, @intFromBool(!!_res)), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _f.*.topic_init.?((&(&log_1.*.iface).*.cb).*.data, topic); + } + _ = &_res; + } +} +pub fn spa_log_level_topic_enabled(arg_log_1: [*c]const struct_spa_log, arg_topic: [*c]const struct_spa_log_topic, arg_level: enum_spa_log_level) callconv(.c) bool { + var log_1 = arg_log_1; + _ = &log_1; + var topic = arg_topic; + _ = &topic; + var level = arg_level; + _ = &level; + var max_level: enum_spa_log_level = undefined; + _ = &max_level; + if (__builtin_expect(@as(c_long, @intFromBool(!!!(log_1 != null))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 0))))) != 0) return @as(c_int, 0) != 0; + if ((topic != null) and (@as(c_int, @intFromBool(topic.*.has_custom_level)) != 0)) { + max_level = topic.*.level; + } else { + max_level = log_1.*.level; + } + return level <= max_level; +} +pub fn spa_log_logtv(arg_l: [*c]struct_spa_log, arg_level: enum_spa_log_level, arg_topic: [*c]const struct_spa_log_topic, arg_file: [*c]const u8, arg_line: c_int, arg_func: [*c]const u8, arg_fmt: [*c]const u8, arg_args: [*c]struct___va_list_tag_26) callconv(.c) void { + var l = arg_l; + _ = &l; + var level = arg_level; + _ = &level; + var topic = arg_topic; + _ = &topic; + var file = arg_file; + _ = &file; + var line = arg_line; + _ = &line; + var func = arg_func; + _ = &func; + var fmt = arg_fmt; + _ = &fmt; + var args = arg_args; + _ = &args; + if (__builtin_expect(@as(c_long, @intFromBool(!!spa_log_level_topic_enabled(l, topic, level))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 0))))) != 0) { + var i: [*c]struct_spa_interface = &l.*.iface; + _ = &i; + if (!(blk: { + var _f: [*c]const struct_spa_log_methods = @as([*c]const struct_spa_log_methods, @ptrCast(@alignCast((&i.*.cb).*.funcs))); + _ = &_f; + var _res: bool = ((_f != null) and ((@as(c_int, 1) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 1) - @as(c_int, 1)))))) and (_f.*.logtv != null); + _ = &_res; + if (__builtin_expect(@as(c_long, @intFromBool(!!_res)), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _f.*.logtv.?((&i.*.cb).*.data, level, topic, file, line, func, fmt, args); + } + break :blk _res; + })) { + { + var _f: [*c]const struct_spa_log_methods = @as([*c]const struct_spa_log_methods, @ptrCast(@alignCast((&i.*.cb).*.funcs))); + _ = &_f; + var _res: bool = ((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.logv != null); + _ = &_res; + if (__builtin_expect(@as(c_long, @intFromBool(!!_res)), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _f.*.logv.?((&i.*.cb).*.data, level, file, line, func, fmt, args); + } + _ = &_res; + } + } + } +} +pub extern var pw_log_level: enum_spa_log_level; +pub extern const PW_LOG_TOPIC_DEFAULT: [*c]struct_spa_log_topic; +pub extern fn pw_log_set(log: [*c]struct_spa_log) void; +pub extern fn pw_log_get() [*c]struct_spa_log; +pub extern fn pw_log_set_level(level: enum_spa_log_level) void; +pub extern fn pw_log_set_level_string(str: [*c]const u8) c_int; +pub extern fn pw_log_logt(level: enum_spa_log_level, topic: [*c]const struct_spa_log_topic, file: [*c]const u8, line: c_int, func: [*c]const u8, fmt: [*c]const u8, ...) void; +pub extern fn pw_log_logtv(level: enum_spa_log_level, topic: [*c]const struct_spa_log_topic, file: [*c]const u8, line: c_int, func: [*c]const u8, fmt: [*c]const u8, args: [*c]struct___va_list_tag_26) void; +pub extern fn pw_log_log(level: enum_spa_log_level, file: [*c]const u8, line: c_int, func: [*c]const u8, fmt: [*c]const u8, ...) void; +pub extern fn pw_log_logv(level: enum_spa_log_level, file: [*c]const u8, line: c_int, func: [*c]const u8, fmt: [*c]const u8, args: [*c]struct___va_list_tag_26) void; +pub extern fn pw_log_topic_register(t: [*c]struct_spa_log_topic) void; +pub extern fn pw_log_topic_unregister(t: [*c]struct_spa_log_topic) void; +pub const struct_pw_link = opaque {}; +pub const PW_LINK_STATE_ERROR: c_int = -2; +pub const PW_LINK_STATE_UNLINKED: c_int = -1; +pub const PW_LINK_STATE_INIT: c_int = 0; +pub const PW_LINK_STATE_NEGOTIATING: c_int = 1; +pub const PW_LINK_STATE_ALLOCATING: c_int = 2; +pub const PW_LINK_STATE_PAUSED: c_int = 3; +pub const PW_LINK_STATE_ACTIVE: c_int = 4; +pub const enum_pw_link_state = c_int; +pub extern fn pw_link_state_as_string(state: enum_pw_link_state) [*c]const u8; +pub const struct_pw_link_info = extern struct { + id: u32 = @import("std").mem.zeroes(u32), + output_node_id: u32 = @import("std").mem.zeroes(u32), + output_port_id: u32 = @import("std").mem.zeroes(u32), + input_node_id: u32 = @import("std").mem.zeroes(u32), + input_port_id: u32 = @import("std").mem.zeroes(u32), + change_mask: u64 = @import("std").mem.zeroes(u64), + state: enum_pw_link_state = @import("std").mem.zeroes(enum_pw_link_state), + @"error": [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + format: [*c]struct_spa_pod = @import("std").mem.zeroes([*c]struct_spa_pod), + props: [*c]struct_spa_dict = @import("std").mem.zeroes([*c]struct_spa_dict), +}; +pub extern fn pw_link_info_update(info: [*c]struct_pw_link_info, update: [*c]const struct_pw_link_info) [*c]struct_pw_link_info; +pub extern fn pw_link_info_merge(info: [*c]struct_pw_link_info, update: [*c]const struct_pw_link_info, reset: bool) [*c]struct_pw_link_info; +pub extern fn pw_link_info_free(info: [*c]struct_pw_link_info) void; +pub const struct_pw_link_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + info: ?*const fn (?*anyopaque, [*c]const struct_pw_link_info) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_pw_link_info) callconv(.c) void), +}; +pub const struct_pw_link_methods = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + add_listener: ?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_link_events, ?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_link_events, ?*anyopaque) callconv(.c) c_int), +}; +pub fn pw_link_add_listener(arg_object: ?*struct_pw_link, arg_listener: [*c]struct_spa_hook, arg_events: [*c]const struct_pw_link_events, arg_data: ?*anyopaque) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var listener = arg_listener; + _ = &listener; + var events = arg_events; + _ = &events; + var data = arg_data; + _ = &data; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_link_methods = @as([*c]const struct_pw_link_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_listener != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.add_listener.?((&_i.*.cb).*.data, listener, events, data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub const struct_pw_main_loop = opaque {}; +pub const struct_pw_main_loop_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + destroy: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), +}; +pub extern fn pw_main_loop_new(props: [*c]const struct_spa_dict) ?*struct_pw_main_loop; +pub extern fn pw_main_loop_add_listener(loop: ?*struct_pw_main_loop, listener: [*c]struct_spa_hook, events: [*c]const struct_pw_main_loop_events, data: ?*anyopaque) void; +pub extern fn pw_main_loop_get_loop(loop: ?*struct_pw_main_loop) [*c]struct_pw_loop; +pub extern fn pw_main_loop_destroy(loop: ?*struct_pw_main_loop) void; +pub extern fn pw_main_loop_run(loop: ?*struct_pw_main_loop) c_int; +pub extern fn pw_main_loop_quit(loop: ?*struct_pw_main_loop) c_int; +pub const union_pw_map_item = extern union { + next: usize, + data: ?*anyopaque, +}; +pub const struct_pw_map = extern struct { + items: struct_pw_array = @import("std").mem.zeroes(struct_pw_array), + free_list: u32 = @import("std").mem.zeroes(u32), +}; +pub fn pw_map_init(arg_map: [*c]struct_pw_map, arg_size: usize, arg_extend: usize) callconv(.c) void { + var map = arg_map; + _ = ↦ + var size = arg_size; + _ = &size; + var extend = arg_extend; + _ = &extend; + pw_array_init(&map.*.items, extend *% @sizeOf(union_pw_map_item)); + _ = pw_array_ensure_size(&map.*.items, size *% @sizeOf(union_pw_map_item)); + map.*.free_list = @as(u32, @bitCast(@as(c_uint, 4294967295))); +} +pub fn pw_map_clear(arg_map: [*c]struct_pw_map) callconv(.c) void { + var map = arg_map; + _ = ↦ + pw_array_clear(&map.*.items); +} +pub fn pw_map_reset(arg_map: [*c]struct_pw_map) callconv(.c) void { + var map = arg_map; + _ = ↦ + pw_array_reset(&map.*.items); + map.*.free_list = @as(u32, @bitCast(@as(c_uint, 4294967295))); +} +pub fn pw_map_insert_new(arg_map: [*c]struct_pw_map, arg_data: ?*anyopaque) callconv(.c) u32 { + var map = arg_map; + _ = ↦ + var data = arg_data; + _ = &data; + var start: [*c]union_pw_map_item = undefined; + _ = &start; + var item: [*c]union_pw_map_item = undefined; + _ = &item; + var id: u32 = undefined; + _ = &id; + if (map.*.free_list != @as(u32, @bitCast(@as(c_uint, 4294967295)))) { + start = @as([*c]union_pw_map_item, @ptrCast(@alignCast(map.*.items.data))); + item = &start[map.*.free_list >> @intCast(1)]; + map.*.free_list = @as(u32, @bitCast(@as(c_uint, @truncate(item.*.next)))); + } else { + item = @as([*c]union_pw_map_item, @ptrCast(@alignCast(pw_array_add(&map.*.items, @sizeOf(union_pw_map_item))))); + if (item == @as([*c]union_pw_map_item, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return @as(u32, @bitCast(@as(c_uint, 4294967295))); + start = @as([*c]union_pw_map_item, @ptrCast(@alignCast(map.*.items.data))); + } + item.*.data = data; + id = @as(u32, @bitCast(@as(c_int, @truncate(@divExact(@as(c_long, @bitCast(@intFromPtr(item) -% @intFromPtr(start))), @sizeOf(union_pw_map_item)))))); + return id; +} +pub fn pw_map_insert_at(arg_map: [*c]struct_pw_map, arg_id: u32, arg_data: ?*anyopaque) callconv(.c) c_int { + var map = arg_map; + _ = ↦ + var id = arg_id; + _ = &id; + var data = arg_data; + _ = &data; + var size: usize = (&map.*.items).*.size / @sizeOf(union_pw_map_item); + _ = &size; + var item: [*c]union_pw_map_item = undefined; + _ = &item; + if (@as(usize, @bitCast(@as(c_ulong, id))) > size) return -@as(c_int, 28) else if (@as(usize, @bitCast(@as(c_ulong, id))) == size) { + item = @as([*c]union_pw_map_item, @ptrCast(@alignCast(pw_array_add(&map.*.items, @sizeOf(union_pw_map_item))))); + if (item == @as([*c]union_pw_map_item, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return -__errno_location().*; + } else { + item = @as([*c]union_pw_map_item, @ptrFromInt(@as(usize, @intCast(@intFromPtr((&map.*.items).*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, @bitCast(@as(c_ulong, id))) *% @sizeOf(union_pw_map_item))))))); + if ((item.*.next & @as(usize, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) return -@as(c_int, 22); + } + item.*.data = data; + return 0; +} +pub fn pw_map_remove(arg_map: [*c]struct_pw_map, arg_id: u32) callconv(.c) void { + var map = arg_map; + _ = ↦ + var id = arg_id; + _ = &id; + if ((@as([*c]union_pw_map_item, @ptrFromInt(@as(usize, @intCast(@intFromPtr((&map.*.items).*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, @bitCast(@as(c_ulong, id))) *% @sizeOf(union_pw_map_item))))))).*.next & @as(usize, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) return; + @as([*c]union_pw_map_item, @ptrFromInt(@as(usize, @intCast(@intFromPtr((&map.*.items).*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, @bitCast(@as(c_ulong, id))) *% @sizeOf(union_pw_map_item))))))).*.next = @as(usize, @bitCast(@as(c_ulong, map.*.free_list))); + map.*.free_list = (id << @intCast(1)) | @as(u32, @bitCast(@as(c_int, 1))); +} +pub fn pw_map_lookup(arg_map: [*c]const struct_pw_map, arg_id: u32) callconv(.c) ?*anyopaque { + var map = arg_map; + _ = ↦ + var id = arg_id; + _ = &id; + if (__builtin_expect(@as(c_long, @intFromBool(!!(@as(c_ulong, @bitCast(@as(c_ulong, id))) < ((&map.*.items).*.size / @sizeOf(union_pw_map_item))))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + var item: [*c]union_pw_map_item = @as([*c]union_pw_map_item, @ptrFromInt(@as(usize, @intCast(@intFromPtr((&map.*.items).*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, @bitCast(@as(c_ulong, id))) *% @sizeOf(union_pw_map_item))))))); + _ = &item; + if (!((item.*.next & @as(usize, @bitCast(@as(c_long, @as(c_int, 1))))) != 0)) return item.*.data; + } + return @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); +} +pub fn pw_map_for_each(arg_map: [*c]const struct_pw_map, arg_func: ?*const fn (?*anyopaque, ?*anyopaque) callconv(.c) c_int, arg_data: ?*anyopaque) callconv(.c) c_int { + var map = arg_map; + _ = ↦ + var func = arg_func; + _ = &func; + var data = arg_data; + _ = &data; + var item: [*c]union_pw_map_item = undefined; + _ = &item; + var res: c_int = 0; + _ = &res; + { + item = @as(@TypeOf(item), @ptrCast(@alignCast((&map.*.items).*.data))); + while (@as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(item))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(union_pw_map_item))))))) <= @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr((&map.*.items).*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast((&map.*.items).*.size))))))) : (item += 1) { + if (!((item.*.next & @as(usize, @bitCast(@as(c_long, @as(c_int, 1))))) != 0)) if ((blk: { + const tmp = func.?(item.*.data, data); + res = tmp; + break :blk tmp; + }) != @as(c_int, 0)) break; + } + } + return res; +} +pub const struct_pw_module = opaque {}; +pub const struct_pw_module_info = extern struct { + id: u32 = @import("std").mem.zeroes(u32), + name: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + filename: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + args: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + change_mask: u64 = @import("std").mem.zeroes(u64), + props: [*c]struct_spa_dict = @import("std").mem.zeroes([*c]struct_spa_dict), +}; +pub extern fn pw_module_info_update(info: [*c]struct_pw_module_info, update: [*c]const struct_pw_module_info) [*c]struct_pw_module_info; +pub extern fn pw_module_info_merge(info: [*c]struct_pw_module_info, update: [*c]const struct_pw_module_info, reset: bool) [*c]struct_pw_module_info; +pub extern fn pw_module_info_free(info: [*c]struct_pw_module_info) void; +pub const struct_pw_module_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + info: ?*const fn (?*anyopaque, [*c]const struct_pw_module_info) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_pw_module_info) callconv(.c) void), +}; +pub const struct_pw_module_methods = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + add_listener: ?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_module_events, ?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_module_events, ?*anyopaque) callconv(.c) c_int), +}; +pub fn pw_module_add_listener(arg_object: ?*struct_pw_module, arg_listener: [*c]struct_spa_hook, arg_events: [*c]const struct_pw_module_events, arg_data: ?*anyopaque) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var listener = arg_listener; + _ = &listener; + var events = arg_events; + _ = &events; + var data = arg_data; + _ = &data; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_module_methods = @as([*c]const struct_pw_module_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_listener != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.add_listener.?((&_i.*.cb).*.data, listener, events, data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub const struct_pw_node = opaque {}; +pub const PW_NODE_STATE_ERROR: c_int = -1; +pub const PW_NODE_STATE_CREATING: c_int = 0; +pub const PW_NODE_STATE_SUSPENDED: c_int = 1; +pub const PW_NODE_STATE_IDLE: c_int = 2; +pub const PW_NODE_STATE_RUNNING: c_int = 3; +pub const enum_pw_node_state = c_int; +pub extern fn pw_node_state_as_string(state: enum_pw_node_state) [*c]const u8; +pub const struct_pw_node_info = extern struct { + id: u32 = @import("std").mem.zeroes(u32), + max_input_ports: u32 = @import("std").mem.zeroes(u32), + max_output_ports: u32 = @import("std").mem.zeroes(u32), + change_mask: u64 = @import("std").mem.zeroes(u64), + n_input_ports: u32 = @import("std").mem.zeroes(u32), + n_output_ports: u32 = @import("std").mem.zeroes(u32), + state: enum_pw_node_state = @import("std").mem.zeroes(enum_pw_node_state), + @"error": [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + props: [*c]struct_spa_dict = @import("std").mem.zeroes([*c]struct_spa_dict), + params: [*c]struct_spa_param_info = @import("std").mem.zeroes([*c]struct_spa_param_info), + n_params: u32 = @import("std").mem.zeroes(u32), +}; +pub extern fn pw_node_info_update(info: [*c]struct_pw_node_info, update: [*c]const struct_pw_node_info) [*c]struct_pw_node_info; +pub extern fn pw_node_info_merge(info: [*c]struct_pw_node_info, update: [*c]const struct_pw_node_info, reset: bool) [*c]struct_pw_node_info; +pub extern fn pw_node_info_free(info: [*c]struct_pw_node_info) void; +pub const struct_pw_node_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + info: ?*const fn (?*anyopaque, [*c]const struct_pw_node_info) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_pw_node_info) callconv(.c) void), + param: ?*const fn (?*anyopaque, c_int, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) void), +}; +pub const struct_pw_node_methods = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + add_listener: ?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_node_events, ?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_node_events, ?*anyopaque) callconv(.c) c_int), + subscribe_params: ?*const fn (?*anyopaque, [*c]u32, u32) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]u32, u32) callconv(.c) c_int), + enum_params: ?*const fn (?*anyopaque, c_int, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int), + set_param: ?*const fn (?*anyopaque, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int), + send_command: ?*const fn (?*anyopaque, [*c]const struct_spa_command) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_spa_command) callconv(.c) c_int), +}; +pub fn pw_node_add_listener(arg_object: ?*struct_pw_node, arg_listener: [*c]struct_spa_hook, arg_events: [*c]const struct_pw_node_events, arg_data: ?*anyopaque) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var listener = arg_listener; + _ = &listener; + var events = arg_events; + _ = &events; + var data = arg_data; + _ = &data; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_node_methods = @as([*c]const struct_pw_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_listener != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.add_listener.?((&_i.*.cb).*.data, listener, events, data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_node_subscribe_params(arg_object: ?*struct_pw_node, arg_ids: [*c]u32, arg_n_ids: u32) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var ids = arg_ids; + _ = &ids; + var n_ids = arg_n_ids; + _ = &n_ids; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_node_methods = @as([*c]const struct_pw_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.subscribe_params != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.subscribe_params.?((&_i.*.cb).*.data, ids, n_ids); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_node_enum_params(arg_object: ?*struct_pw_node, arg_seq: c_int, arg_id: u32, arg_start: u32, arg_num: u32, arg_filter: [*c]const struct_spa_pod) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var seq = arg_seq; + _ = &seq; + var id = arg_id; + _ = &id; + var start = arg_start; + _ = &start; + var num = arg_num; + _ = # + var filter = arg_filter; + _ = &filter; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_node_methods = @as([*c]const struct_pw_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.enum_params != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.enum_params.?((&_i.*.cb).*.data, seq, id, start, num, filter); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_node_set_param(arg_object: ?*struct_pw_node, arg_id: u32, arg_flags: u32, arg_param: [*c]const struct_spa_pod) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var id = arg_id; + _ = &id; + var flags = arg_flags; + _ = &flags; + var param = arg_param; + _ = ¶m; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_node_methods = @as([*c]const struct_pw_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.set_param != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.set_param.?((&_i.*.cb).*.data, id, flags, param); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_node_send_command(arg_object: ?*struct_pw_node, arg_command: [*c]const struct_spa_command) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var command = arg_command; + _ = &command; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_node_methods = @as([*c]const struct_pw_node_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.send_command != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.send_command.?((&_i.*.cb).*.data, command); + } + _ = &_res; + } + break :blk _res; + }; +} +pub const struct_pw_port = opaque {}; +pub extern fn pw_direction_as_string(direction: enum_spa_direction) [*c]const u8; +pub const struct_pw_port_info = extern struct { + id: u32 = @import("std").mem.zeroes(u32), + direction: enum_spa_direction = @import("std").mem.zeroes(enum_spa_direction), + change_mask: u64 = @import("std").mem.zeroes(u64), + props: [*c]struct_spa_dict = @import("std").mem.zeroes([*c]struct_spa_dict), + params: [*c]struct_spa_param_info = @import("std").mem.zeroes([*c]struct_spa_param_info), + n_params: u32 = @import("std").mem.zeroes(u32), +}; +pub extern fn pw_port_info_update(info: [*c]struct_pw_port_info, update: [*c]const struct_pw_port_info) [*c]struct_pw_port_info; +pub extern fn pw_port_info_merge(info: [*c]struct_pw_port_info, update: [*c]const struct_pw_port_info, reset: bool) [*c]struct_pw_port_info; +pub extern fn pw_port_info_free(info: [*c]struct_pw_port_info) void; +pub const struct_pw_port_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + info: ?*const fn (?*anyopaque, [*c]const struct_pw_port_info) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_pw_port_info) callconv(.c) void), + param: ?*const fn (?*anyopaque, c_int, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) void), +}; +pub const struct_pw_port_methods = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + add_listener: ?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_port_events, ?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_hook, [*c]const struct_pw_port_events, ?*anyopaque) callconv(.c) c_int), + subscribe_params: ?*const fn (?*anyopaque, [*c]u32, u32) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]u32, u32) callconv(.c) c_int), + enum_params: ?*const fn (?*anyopaque, c_int, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, c_int, u32, u32, u32, [*c]const struct_spa_pod) callconv(.c) c_int), +}; +pub fn pw_port_add_listener(arg_object: ?*struct_pw_port, arg_listener: [*c]struct_spa_hook, arg_events: [*c]const struct_pw_port_events, arg_data: ?*anyopaque) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var listener = arg_listener; + _ = &listener; + var events = arg_events; + _ = &events; + var data = arg_data; + _ = &data; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_port_methods = @as([*c]const struct_pw_port_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.add_listener != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.add_listener.?((&_i.*.cb).*.data, listener, events, data); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_port_subscribe_params(arg_object: ?*struct_pw_port, arg_ids: [*c]u32, arg_n_ids: u32) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var ids = arg_ids; + _ = &ids; + var n_ids = arg_n_ids; + _ = &n_ids; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_port_methods = @as([*c]const struct_pw_port_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.subscribe_params != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.subscribe_params.?((&_i.*.cb).*.data, ids, n_ids); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn pw_port_enum_params(arg_object: ?*struct_pw_port, arg_seq: c_int, arg_id: u32, arg_start: u32, arg_num: u32, arg_filter: [*c]const struct_spa_pod) callconv(.c) c_int { + var object = arg_object; + _ = &object; + var seq = arg_seq; + _ = &seq; + var id = arg_id; + _ = &id; + var start = arg_start; + _ = &start; + var num = arg_num; + _ = # + var filter = arg_filter; + _ = &filter; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = @as([*c]struct_spa_interface, @ptrCast(@alignCast(object))); + _ = &_i; + { + var _f: [*c]const struct_pw_port_methods = @as([*c]const struct_pw_port_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.enum_params != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.enum_params.?((&_i.*.cb).*.data, seq, id, start, num, filter); + } + _ = &_res; + } + break :blk _res; + }; +} +pub const struct_pw_stream = opaque {}; +pub const PW_STREAM_STATE_ERROR: c_int = -1; +pub const PW_STREAM_STATE_UNCONNECTED: c_int = 0; +pub const PW_STREAM_STATE_CONNECTING: c_int = 1; +pub const PW_STREAM_STATE_PAUSED: c_int = 2; +pub const PW_STREAM_STATE_STREAMING: c_int = 3; +pub const enum_pw_stream_state = c_int; +pub const struct_pw_buffer = extern struct { + buffer: [*c]struct_spa_buffer = @import("std").mem.zeroes([*c]struct_spa_buffer), + user_data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + size: u64 = @import("std").mem.zeroes(u64), + requested: u64 = @import("std").mem.zeroes(u64), + time: u64 = @import("std").mem.zeroes(u64), +}; +pub const struct_pw_stream_control = extern struct { + name: [*c]const u8 = @import("std").mem.zeroes([*c]const u8), + flags: u32 = @import("std").mem.zeroes(u32), + def: f32 = @import("std").mem.zeroes(f32), + min: f32 = @import("std").mem.zeroes(f32), + max: f32 = @import("std").mem.zeroes(f32), + values: [*c]f32 = @import("std").mem.zeroes([*c]f32), + n_values: u32 = @import("std").mem.zeroes(u32), + max_values: u32 = @import("std").mem.zeroes(u32), +}; +pub const struct_pw_time = extern struct { + now: i64 = @import("std").mem.zeroes(i64), + rate: struct_spa_fraction = @import("std").mem.zeroes(struct_spa_fraction), + ticks: u64 = @import("std").mem.zeroes(u64), + delay: i64 = @import("std").mem.zeroes(i64), + queued: u64 = @import("std").mem.zeroes(u64), + buffered: u64 = @import("std").mem.zeroes(u64), + queued_buffers: u32 = @import("std").mem.zeroes(u32), + avail_buffers: u32 = @import("std").mem.zeroes(u32), + size: u64 = @import("std").mem.zeroes(u64), +}; +pub const struct_pw_stream_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + destroy: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), + state_changed: ?*const fn (?*anyopaque, enum_pw_stream_state, enum_pw_stream_state, [*c]const u8) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, enum_pw_stream_state, enum_pw_stream_state, [*c]const u8) callconv(.c) void), + control_info: ?*const fn (?*anyopaque, u32, [*c]const struct_pw_stream_control) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, [*c]const struct_pw_stream_control) callconv(.c) void), + io_changed: ?*const fn (?*anyopaque, u32, ?*anyopaque, u32) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, ?*anyopaque, u32) callconv(.c) void), + param_changed: ?*const fn (?*anyopaque, u32, [*c]const struct_spa_pod) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32, [*c]const struct_spa_pod) callconv(.c) void), + add_buffer: ?*const fn (?*anyopaque, [*c]struct_pw_buffer) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_pw_buffer) callconv(.c) void), + remove_buffer: ?*const fn (?*anyopaque, [*c]struct_pw_buffer) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_pw_buffer) callconv(.c) void), + process: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), + drained: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), + command: ?*const fn (?*anyopaque, [*c]const struct_spa_command) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_spa_command) callconv(.c) void), + trigger_done: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), +}; +pub extern fn pw_stream_state_as_string(state: enum_pw_stream_state) [*c]const u8; +pub const PW_STREAM_FLAG_NONE: c_int = 0; +pub const PW_STREAM_FLAG_AUTOCONNECT: c_int = 1; +pub const PW_STREAM_FLAG_INACTIVE: c_int = 2; +pub const PW_STREAM_FLAG_MAP_BUFFERS: c_int = 4; +pub const PW_STREAM_FLAG_DRIVER: c_int = 8; +pub const PW_STREAM_FLAG_RT_PROCESS: c_int = 16; +pub const PW_STREAM_FLAG_NO_CONVERT: c_int = 32; +pub const PW_STREAM_FLAG_EXCLUSIVE: c_int = 64; +pub const PW_STREAM_FLAG_DONT_RECONNECT: c_int = 128; +pub const PW_STREAM_FLAG_ALLOC_BUFFERS: c_int = 256; +pub const PW_STREAM_FLAG_TRIGGER: c_int = 512; +pub const PW_STREAM_FLAG_ASYNC: c_int = 1024; +pub const PW_STREAM_FLAG_EARLY_PROCESS: c_int = 2048; +pub const PW_STREAM_FLAG_RT_TRIGGER_DONE: c_int = 4096; +pub const enum_pw_stream_flags = c_uint; +pub extern fn pw_stream_new(core: ?*struct_pw_core, name: [*c]const u8, props: [*c]struct_pw_properties) ?*struct_pw_stream; +pub extern fn pw_stream_new_simple(loop: [*c]struct_pw_loop, name: [*c]const u8, props: [*c]struct_pw_properties, events: [*c]const struct_pw_stream_events, data: ?*anyopaque) ?*struct_pw_stream; +pub extern fn pw_stream_destroy(stream: ?*struct_pw_stream) void; +pub extern fn pw_stream_add_listener(stream: ?*struct_pw_stream, listener: [*c]struct_spa_hook, events: [*c]const struct_pw_stream_events, data: ?*anyopaque) void; +pub extern fn pw_stream_get_state(stream: ?*struct_pw_stream, @"error": [*c][*c]const u8) enum_pw_stream_state; +pub extern fn pw_stream_get_name(stream: ?*struct_pw_stream) [*c]const u8; +pub extern fn pw_stream_get_core(stream: ?*struct_pw_stream) ?*struct_pw_core; +pub extern fn pw_stream_get_properties(stream: ?*struct_pw_stream) [*c]const struct_pw_properties; +pub extern fn pw_stream_update_properties(stream: ?*struct_pw_stream, dict: [*c]const struct_spa_dict) c_int; +pub extern fn pw_stream_connect(stream: ?*struct_pw_stream, direction: enum_spa_direction, target_id: u32, flags: enum_pw_stream_flags, params: [*c][*c]const struct_spa_pod, n_params: u32) c_int; +pub extern fn pw_stream_get_node_id(stream: ?*struct_pw_stream) u32; +pub extern fn pw_stream_disconnect(stream: ?*struct_pw_stream) c_int; +pub extern fn pw_stream_set_error(stream: ?*struct_pw_stream, res: c_int, @"error": [*c]const u8, ...) c_int; +pub extern fn pw_stream_update_params(stream: ?*struct_pw_stream, params: [*c][*c]const struct_spa_pod, n_params: u32) c_int; +pub extern fn pw_stream_set_param(stream: ?*struct_pw_stream, id: u32, param: [*c]const struct_spa_pod) c_int; +pub extern fn pw_stream_get_control(stream: ?*struct_pw_stream, id: u32) [*c]const struct_pw_stream_control; +pub extern fn pw_stream_set_control(stream: ?*struct_pw_stream, id: u32, n_values: u32, values: [*c]f32, ...) c_int; +pub extern fn pw_stream_get_time_n(stream: ?*struct_pw_stream, time: [*c]struct_pw_time, size: usize) c_int; +pub extern fn pw_stream_get_nsec(stream: ?*struct_pw_stream) u64; +pub extern fn pw_stream_get_data_loop(stream: ?*struct_pw_stream) [*c]struct_pw_loop; +pub extern fn pw_stream_get_time(stream: ?*struct_pw_stream, time: [*c]struct_pw_time) c_int; +pub extern fn pw_stream_dequeue_buffer(stream: ?*struct_pw_stream) [*c]struct_pw_buffer; +pub extern fn pw_stream_queue_buffer(stream: ?*struct_pw_stream, buffer: [*c]struct_pw_buffer) c_int; +pub extern fn pw_stream_return_buffer(stream: ?*struct_pw_stream, buffer: [*c]struct_pw_buffer) c_int; +pub extern fn pw_stream_set_active(stream: ?*struct_pw_stream, active: bool) c_int; +pub extern fn pw_stream_flush(stream: ?*struct_pw_stream, drain: bool) c_int; +pub extern fn pw_stream_is_driving(stream: ?*struct_pw_stream) bool; +pub extern fn pw_stream_is_lazy(stream: ?*struct_pw_stream) bool; +pub extern fn pw_stream_trigger_process(stream: ?*struct_pw_stream) c_int; +pub extern fn pw_stream_emit_event(stream: ?*struct_pw_stream, event: [*c]const struct_spa_event) c_int; +pub extern fn pw_stream_set_rate(stream: ?*struct_pw_stream, rate: f64) c_int; +pub const struct_pw_filter = opaque {}; +pub const SPA_IO_Invalid: c_int = 0; +pub const SPA_IO_Buffers: c_int = 1; +pub const SPA_IO_Range: c_int = 2; +pub const SPA_IO_Clock: c_int = 3; +pub const SPA_IO_Latency: c_int = 4; +pub const SPA_IO_Control: c_int = 5; +pub const SPA_IO_Notify: c_int = 6; +pub const SPA_IO_Position: c_int = 7; +pub const SPA_IO_RateMatch: c_int = 8; +pub const SPA_IO_Memory: c_int = 9; +pub const SPA_IO_AsyncBuffers: c_int = 10; +pub const enum_spa_io_type = c_uint; +pub const struct_spa_io_buffers = extern struct { + status: i32 = @import("std").mem.zeroes(i32), + buffer_id: u32 = @import("std").mem.zeroes(u32), +}; +pub const struct_spa_io_memory = extern struct { + status: i32 = @import("std").mem.zeroes(i32), + size: u32 = @import("std").mem.zeroes(u32), + data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), +}; +pub const struct_spa_io_range = extern struct { + offset: u64 = @import("std").mem.zeroes(u64), + min_size: u32 = @import("std").mem.zeroes(u32), + max_size: u32 = @import("std").mem.zeroes(u32), +}; +pub const struct_spa_io_clock = extern struct { + flags: u32 = @import("std").mem.zeroes(u32), + id: u32 = @import("std").mem.zeroes(u32), + name: [64]u8 = @import("std").mem.zeroes([64]u8), + nsec: u64 = @import("std").mem.zeroes(u64), + rate: struct_spa_fraction = @import("std").mem.zeroes(struct_spa_fraction), + position: u64 = @import("std").mem.zeroes(u64), + duration: u64 = @import("std").mem.zeroes(u64), + delay: i64 = @import("std").mem.zeroes(i64), + rate_diff: f64 = @import("std").mem.zeroes(f64), + next_nsec: u64 = @import("std").mem.zeroes(u64), + target_rate: struct_spa_fraction = @import("std").mem.zeroes(struct_spa_fraction), + target_duration: u64 = @import("std").mem.zeroes(u64), + target_seq: u32 = @import("std").mem.zeroes(u32), + cycle: u32 = @import("std").mem.zeroes(u32), + xrun: u64 = @import("std").mem.zeroes(u64), +}; +pub const struct_spa_io_video_size = extern struct { + flags: u32 = @import("std").mem.zeroes(u32), + stride: u32 = @import("std").mem.zeroes(u32), + size: struct_spa_rectangle = @import("std").mem.zeroes(struct_spa_rectangle), + framerate: struct_spa_fraction = @import("std").mem.zeroes(struct_spa_fraction), + padding: [4]u32 = @import("std").mem.zeroes([4]u32), +}; +pub const struct_spa_io_latency = extern struct { + rate: struct_spa_fraction = @import("std").mem.zeroes(struct_spa_fraction), + min: u64 = @import("std").mem.zeroes(u64), + max: u64 = @import("std").mem.zeroes(u64), +}; +pub const struct_spa_io_sequence = extern struct { + sequence: struct_spa_pod_sequence = @import("std").mem.zeroes(struct_spa_pod_sequence), +}; +pub const struct_spa_io_segment_bar = extern struct { + flags: u32 = @import("std").mem.zeroes(u32), + offset: u32 = @import("std").mem.zeroes(u32), + signature_num: f32 = @import("std").mem.zeroes(f32), + signature_denom: f32 = @import("std").mem.zeroes(f32), + bpm: f64 = @import("std").mem.zeroes(f64), + beat: f64 = @import("std").mem.zeroes(f64), + bar_start_tick: f64 = @import("std").mem.zeroes(f64), + ticks_per_beat: f64 = @import("std").mem.zeroes(f64), + padding: [4]u32 = @import("std").mem.zeroes([4]u32), +}; +pub const struct_spa_io_segment_video = extern struct { + flags: u32 = @import("std").mem.zeroes(u32), + offset: u32 = @import("std").mem.zeroes(u32), + framerate: struct_spa_fraction = @import("std").mem.zeroes(struct_spa_fraction), + hours: u32 = @import("std").mem.zeroes(u32), + minutes: u32 = @import("std").mem.zeroes(u32), + seconds: u32 = @import("std").mem.zeroes(u32), + frames: u32 = @import("std").mem.zeroes(u32), + field_count: u32 = @import("std").mem.zeroes(u32), + padding: [11]u32 = @import("std").mem.zeroes([11]u32), +}; +pub const struct_spa_io_segment = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + flags: u32 = @import("std").mem.zeroes(u32), + start: u64 = @import("std").mem.zeroes(u64), + duration: u64 = @import("std").mem.zeroes(u64), + rate: f64 = @import("std").mem.zeroes(f64), + position: u64 = @import("std").mem.zeroes(u64), + bar: struct_spa_io_segment_bar = @import("std").mem.zeroes(struct_spa_io_segment_bar), + video: struct_spa_io_segment_video = @import("std").mem.zeroes(struct_spa_io_segment_video), +}; +pub const SPA_IO_POSITION_STATE_STOPPED: c_int = 0; +pub const SPA_IO_POSITION_STATE_STARTING: c_int = 1; +pub const SPA_IO_POSITION_STATE_RUNNING: c_int = 2; +pub const enum_spa_io_position_state = c_uint; +pub const struct_spa_io_position = extern struct { + clock: struct_spa_io_clock = @import("std").mem.zeroes(struct_spa_io_clock), + video: struct_spa_io_video_size = @import("std").mem.zeroes(struct_spa_io_video_size), + offset: i64 = @import("std").mem.zeroes(i64), + state: u32 = @import("std").mem.zeroes(u32), + n_segments: u32 = @import("std").mem.zeroes(u32), + segments: [8]struct_spa_io_segment = @import("std").mem.zeroes([8]struct_spa_io_segment), +}; +pub const struct_spa_io_rate_match = extern struct { + delay: u32 = @import("std").mem.zeroes(u32), + size: u32 = @import("std").mem.zeroes(u32), + rate: f64 = @import("std").mem.zeroes(f64), + flags: u32 = @import("std").mem.zeroes(u32), + delay_frac: i32 = @import("std").mem.zeroes(i32), + padding: [6]u32 = @import("std").mem.zeroes([6]u32), +}; +pub const struct_spa_io_async_buffers = extern struct { + buffers: [2]struct_spa_io_buffers = @import("std").mem.zeroes([2]struct_spa_io_buffers), +}; +pub const PW_FILTER_STATE_ERROR: c_int = -1; +pub const PW_FILTER_STATE_UNCONNECTED: c_int = 0; +pub const PW_FILTER_STATE_CONNECTING: c_int = 1; +pub const PW_FILTER_STATE_PAUSED: c_int = 2; +pub const PW_FILTER_STATE_STREAMING: c_int = 3; +pub const enum_pw_filter_state = c_int; +pub const struct_pw_filter_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + destroy: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), + state_changed: ?*const fn (?*anyopaque, enum_pw_filter_state, enum_pw_filter_state, [*c]const u8) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, enum_pw_filter_state, enum_pw_filter_state, [*c]const u8) callconv(.c) void), + io_changed: ?*const fn (?*anyopaque, ?*anyopaque, u32, ?*anyopaque, u32) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, ?*anyopaque, u32, ?*anyopaque, u32) callconv(.c) void), + param_changed: ?*const fn (?*anyopaque, ?*anyopaque, u32, [*c]const struct_spa_pod) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, ?*anyopaque, u32, [*c]const struct_spa_pod) callconv(.c) void), + add_buffer: ?*const fn (?*anyopaque, ?*anyopaque, [*c]struct_pw_buffer) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, ?*anyopaque, [*c]struct_pw_buffer) callconv(.c) void), + remove_buffer: ?*const fn (?*anyopaque, ?*anyopaque, [*c]struct_pw_buffer) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, ?*anyopaque, [*c]struct_pw_buffer) callconv(.c) void), + process: ?*const fn (?*anyopaque, [*c]struct_spa_io_position) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]struct_spa_io_position) callconv(.c) void), + drained: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), + command: ?*const fn (?*anyopaque, [*c]const struct_spa_command) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_spa_command) callconv(.c) void), +}; +pub extern fn pw_filter_state_as_string(state: enum_pw_filter_state) [*c]const u8; +pub const PW_FILTER_FLAG_NONE: c_int = 0; +pub const PW_FILTER_FLAG_INACTIVE: c_int = 1; +pub const PW_FILTER_FLAG_DRIVER: c_int = 2; +pub const PW_FILTER_FLAG_RT_PROCESS: c_int = 4; +pub const PW_FILTER_FLAG_CUSTOM_LATENCY: c_int = 8; +pub const PW_FILTER_FLAG_TRIGGER: c_int = 16; +pub const PW_FILTER_FLAG_ASYNC: c_int = 32; +pub const enum_pw_filter_flags = c_uint; +pub const PW_FILTER_PORT_FLAG_NONE: c_int = 0; +pub const PW_FILTER_PORT_FLAG_MAP_BUFFERS: c_int = 1; +pub const PW_FILTER_PORT_FLAG_ALLOC_BUFFERS: c_int = 2; +pub const enum_pw_filter_port_flags = c_uint; +pub extern fn pw_filter_new(core: ?*struct_pw_core, name: [*c]const u8, props: [*c]struct_pw_properties) ?*struct_pw_filter; +pub extern fn pw_filter_new_simple(loop: [*c]struct_pw_loop, name: [*c]const u8, props: [*c]struct_pw_properties, events: [*c]const struct_pw_filter_events, data: ?*anyopaque) ?*struct_pw_filter; +pub extern fn pw_filter_destroy(filter: ?*struct_pw_filter) void; +pub extern fn pw_filter_add_listener(filter: ?*struct_pw_filter, listener: [*c]struct_spa_hook, events: [*c]const struct_pw_filter_events, data: ?*anyopaque) void; +pub extern fn pw_filter_get_state(filter: ?*struct_pw_filter, @"error": [*c][*c]const u8) enum_pw_filter_state; +pub extern fn pw_filter_get_name(filter: ?*struct_pw_filter) [*c]const u8; +pub extern fn pw_filter_get_core(filter: ?*struct_pw_filter) ?*struct_pw_core; +pub extern fn pw_filter_connect(filter: ?*struct_pw_filter, flags: enum_pw_filter_flags, params: [*c][*c]const struct_spa_pod, n_params: u32) c_int; +pub extern fn pw_filter_get_node_id(filter: ?*struct_pw_filter) u32; +pub extern fn pw_filter_disconnect(filter: ?*struct_pw_filter) c_int; +pub extern fn pw_filter_add_port(filter: ?*struct_pw_filter, direction: enum_spa_direction, flags: enum_pw_filter_port_flags, port_data_size: usize, props: [*c]struct_pw_properties, params: [*c][*c]const struct_spa_pod, n_params: u32) ?*anyopaque; +pub extern fn pw_filter_remove_port(port_data: ?*anyopaque) c_int; +pub extern fn pw_filter_get_properties(filter: ?*struct_pw_filter, port_data: ?*anyopaque) [*c]const struct_pw_properties; +pub extern fn pw_filter_update_properties(filter: ?*struct_pw_filter, port_data: ?*anyopaque, dict: [*c]const struct_spa_dict) c_int; +pub extern fn pw_filter_set_error(filter: ?*struct_pw_filter, res: c_int, @"error": [*c]const u8, ...) c_int; +pub extern fn pw_filter_update_params(filter: ?*struct_pw_filter, port_data: ?*anyopaque, params: [*c][*c]const struct_spa_pod, n_params: u32) c_int; +pub extern fn pw_filter_get_time(filter: ?*struct_pw_filter, time: [*c]struct_pw_time) c_int; +pub extern fn pw_filter_get_nsec(filter: ?*struct_pw_filter) u64; +pub extern fn pw_filter_get_data_loop(filter: ?*struct_pw_filter) [*c]struct_pw_loop; +pub extern fn pw_filter_dequeue_buffer(port_data: ?*anyopaque) [*c]struct_pw_buffer; +pub extern fn pw_filter_queue_buffer(port_data: ?*anyopaque, buffer: [*c]struct_pw_buffer) c_int; +pub extern fn pw_filter_get_dsp_buffer(port_data: ?*anyopaque, n_samples: u32) ?*anyopaque; +pub extern fn pw_filter_set_active(filter: ?*struct_pw_filter, active: bool) c_int; +pub extern fn pw_filter_flush(filter: ?*struct_pw_filter, drain: bool) c_int; +pub extern fn pw_filter_is_driving(filter: ?*struct_pw_filter) bool; +pub extern fn pw_filter_is_lazy(filter: ?*struct_pw_filter) bool; +pub extern fn pw_filter_trigger_process(filter: ?*struct_pw_filter) c_int; +pub extern fn pw_filter_emit_event(filter: ?*struct_pw_filter, event: [*c]const struct_spa_event) c_int; +pub const struct_pw_thread_loop = opaque {}; +pub const struct_pw_thread_loop_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + destroy: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), +}; +pub extern fn pw_thread_loop_new(name: [*c]const u8, props: [*c]const struct_spa_dict) ?*struct_pw_thread_loop; +pub extern fn pw_thread_loop_new_full(loop: [*c]struct_pw_loop, name: [*c]const u8, props: [*c]const struct_spa_dict) ?*struct_pw_thread_loop; +pub extern fn pw_thread_loop_destroy(loop: ?*struct_pw_thread_loop) void; +pub extern fn pw_thread_loop_add_listener(loop: ?*struct_pw_thread_loop, listener: [*c]struct_spa_hook, events: [*c]const struct_pw_thread_loop_events, data: ?*anyopaque) void; +pub extern fn pw_thread_loop_get_loop(loop: ?*struct_pw_thread_loop) [*c]struct_pw_loop; +pub extern fn pw_thread_loop_start(loop: ?*struct_pw_thread_loop) c_int; +pub extern fn pw_thread_loop_stop(loop: ?*struct_pw_thread_loop) void; +pub extern fn pw_thread_loop_lock(loop: ?*struct_pw_thread_loop) void; +pub extern fn pw_thread_loop_unlock(loop: ?*struct_pw_thread_loop) void; +pub extern fn pw_thread_loop_wait(loop: ?*struct_pw_thread_loop) void; +pub extern fn pw_thread_loop_timed_wait(loop: ?*struct_pw_thread_loop, wait_max_sec: c_int) c_int; +pub extern fn pw_thread_loop_get_time(loop: ?*struct_pw_thread_loop, abstime: [*c]struct_timespec, timeout: i64) c_int; +pub extern fn pw_thread_loop_timed_wait_full(loop: ?*struct_pw_thread_loop, abstime: [*c]const struct_timespec) c_int; +pub extern fn pw_thread_loop_signal(loop: ?*struct_pw_thread_loop, wait_for_accept: bool) void; +pub extern fn pw_thread_loop_accept(loop: ?*struct_pw_thread_loop) void; +pub extern fn pw_thread_loop_in_thread(loop: ?*struct_pw_thread_loop) bool; +pub const struct_spa_thread = opaque {}; +pub const struct_spa_thread_utils = extern struct { + iface: struct_spa_interface = @import("std").mem.zeroes(struct_spa_interface), +}; +pub const struct_spa_thread_utils_methods = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + create: ?*const fn (?*anyopaque, [*c]const struct_spa_dict, ?*const fn (?*anyopaque) callconv(.c) ?*anyopaque, ?*anyopaque) callconv(.c) ?*struct_spa_thread = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_spa_dict, ?*const fn (?*anyopaque) callconv(.c) ?*anyopaque, ?*anyopaque) callconv(.c) ?*struct_spa_thread), + join: ?*const fn (?*anyopaque, ?*struct_spa_thread, [*c]?*anyopaque) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, ?*struct_spa_thread, [*c]?*anyopaque) callconv(.c) c_int), + get_rt_range: ?*const fn (?*anyopaque, [*c]const struct_spa_dict, [*c]c_int, [*c]c_int) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, [*c]const struct_spa_dict, [*c]c_int, [*c]c_int) callconv(.c) c_int), + acquire_rt: ?*const fn (?*anyopaque, ?*struct_spa_thread, c_int) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, ?*struct_spa_thread, c_int) callconv(.c) c_int), + drop_rt: ?*const fn (?*anyopaque, ?*struct_spa_thread) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, ?*struct_spa_thread) callconv(.c) c_int), +}; +pub fn spa_thread_utils_create(arg_o: [*c]struct_spa_thread_utils, arg_props: [*c]const struct_spa_dict, arg_start_routine: ?*const fn (?*anyopaque) callconv(.c) ?*anyopaque, arg_arg: ?*anyopaque) callconv(.c) ?*struct_spa_thread { + var o = arg_o; + _ = &o; + var props = arg_props; + _ = &props; + var start_routine = arg_start_routine; + _ = &start_routine; + var arg = arg_arg; + _ = &arg; + return blk: { + var _res: ?*struct_spa_thread = null; + _ = &_res; + var _i: [*c]struct_spa_interface = &o.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_thread_utils_methods = @as([*c]const struct_spa_thread_utils_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.create != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.create.?((&_i.*.cb).*.data, props, start_routine, arg); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_thread_utils_join(arg_o: [*c]struct_spa_thread_utils, arg_thread: ?*struct_spa_thread, arg_retval: [*c]?*anyopaque) callconv(.c) c_int { + var o = arg_o; + _ = &o; + var thread = arg_thread; + _ = &thread; + var retval = arg_retval; + _ = &retval; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &o.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_thread_utils_methods = @as([*c]const struct_spa_thread_utils_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.join != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.join.?((&_i.*.cb).*.data, thread, retval); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_thread_utils_get_rt_range(arg_o: [*c]struct_spa_thread_utils, arg_props: [*c]const struct_spa_dict, arg_min: [*c]c_int, arg_max: [*c]c_int) callconv(.c) c_int { + var o = arg_o; + _ = &o; + var props = arg_props; + _ = &props; + var min = arg_min; + _ = &min; + var max = arg_max; + _ = &max; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &o.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_thread_utils_methods = @as([*c]const struct_spa_thread_utils_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.get_rt_range != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.get_rt_range.?((&_i.*.cb).*.data, props, min, max); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_thread_utils_acquire_rt(arg_o: [*c]struct_spa_thread_utils, arg_thread: ?*struct_spa_thread, arg_priority: c_int) callconv(.c) c_int { + var o = arg_o; + _ = &o; + var thread = arg_thread; + _ = &thread; + var priority = arg_priority; + _ = &priority; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &o.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_thread_utils_methods = @as([*c]const struct_spa_thread_utils_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.acquire_rt != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.acquire_rt.?((&_i.*.cb).*.data, thread, priority); + } + _ = &_res; + } + break :blk _res; + }; +} +pub fn spa_thread_utils_drop_rt(arg_o: [*c]struct_spa_thread_utils, arg_thread: ?*struct_spa_thread) callconv(.c) c_int { + var o = arg_o; + _ = &o; + var thread = arg_thread; + _ = &thread; + return blk: { + var _res: c_int = -@as(c_int, 95); + _ = &_res; + var _i: [*c]struct_spa_interface = &o.*.iface; + _ = &_i; + { + var _f: [*c]const struct_spa_thread_utils_methods = @as([*c]const struct_spa_thread_utils_methods, @ptrCast(@alignCast((&_i.*.cb).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.drop_rt != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + _res = _f.*.drop_rt.?((&_i.*.cb).*.data, thread); + } + _ = &_res; + } + break :blk _res; + }; +} +pub const struct_pw_data_loop_events = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + destroy: ?*const fn (?*anyopaque) callconv(.c) void = @import("std").mem.zeroes(?*const fn (?*anyopaque) callconv(.c) void), +}; +pub extern fn pw_data_loop_new(props: [*c]const struct_spa_dict) ?*struct_pw_data_loop; +pub extern fn pw_data_loop_add_listener(loop: ?*struct_pw_data_loop, listener: [*c]struct_spa_hook, events: [*c]const struct_pw_data_loop_events, data: ?*anyopaque) void; +pub extern fn pw_data_loop_wait(loop: ?*struct_pw_data_loop, timeout: c_int) c_int; +pub extern fn pw_data_loop_exit(loop: ?*struct_pw_data_loop) void; +pub extern fn pw_data_loop_get_loop(loop: ?*struct_pw_data_loop) [*c]struct_pw_loop; +pub extern fn pw_data_loop_get_name(loop: ?*struct_pw_data_loop) [*c]const u8; +pub extern fn pw_data_loop_get_class(loop: ?*struct_pw_data_loop) [*c]const u8; +pub extern fn pw_data_loop_destroy(loop: ?*struct_pw_data_loop) void; +pub extern fn pw_data_loop_start(loop: ?*struct_pw_data_loop) c_int; +pub extern fn pw_data_loop_stop(loop: ?*struct_pw_data_loop) c_int; +pub extern fn pw_data_loop_in_thread(loop: ?*struct_pw_data_loop) bool; +pub extern fn pw_data_loop_get_thread(loop: ?*struct_pw_data_loop) ?*struct_spa_thread; +pub extern fn pw_data_loop_invoke(loop: ?*struct_pw_data_loop, func: spa_invoke_func_t, seq: u32, data: ?*const anyopaque, size: usize, block: bool, user_data: ?*anyopaque) c_int; +pub extern fn pw_data_loop_set_thread_utils(loop: ?*struct_pw_data_loop, impl: [*c]struct_spa_thread_utils) void; +pub const pw_timer_callback = ?*const fn (?*anyopaque) callconv(.c) void; +pub const struct_pw_timer = extern struct { + link: struct_spa_list = @import("std").mem.zeroes(struct_spa_list), + queue: ?*struct_pw_timer_queue = @import("std").mem.zeroes(?*struct_pw_timer_queue), + timeout: struct_timespec = @import("std").mem.zeroes(struct_timespec), + callback: pw_timer_callback = @import("std").mem.zeroes(pw_timer_callback), + data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + padding: [16]u32 = @import("std").mem.zeroes([16]u32), +}; +pub extern fn pw_timer_queue_new(loop: [*c]struct_pw_loop) ?*struct_pw_timer_queue; +pub extern fn pw_timer_queue_destroy(queue: ?*struct_pw_timer_queue) void; +pub extern fn pw_timer_queue_add(queue: ?*struct_pw_timer_queue, timer: [*c]struct_pw_timer, abs_time: [*c]struct_timespec, timeout_ns: i64, callback: pw_timer_callback, data: ?*anyopaque) c_int; +pub extern fn pw_timer_queue_cancel(timer: [*c]struct_pw_timer) c_int; +pub extern fn pw_get_library_version() [*c]const u8; +pub extern fn pw_check_library_version(major: c_int, minor: c_int, micro: c_int) bool; +pub extern fn pw_init(argc: [*c]c_int, argv: [*c][*c][*c]u8) void; +pub extern fn pw_deinit() void; +pub extern fn pw_debug_is_category_enabled(name: [*c]const u8) bool; +pub extern fn pw_get_application_name() [*c]const u8; +pub extern fn pw_get_prgname() [*c]const u8; +pub extern fn pw_get_user_name() [*c]const u8; +pub extern fn pw_get_host_name() [*c]const u8; +pub extern fn pw_get_client_name() [*c]const u8; +pub extern fn pw_check_option(option: [*c]const u8, value: [*c]const u8) bool; +pub extern fn pw_direction_reverse(direction: enum_spa_direction) enum_spa_direction; +pub extern fn pw_set_domain(domain: [*c]const u8) c_int; +pub extern fn pw_get_domain() [*c]const u8; +pub extern fn pw_get_support(support: [*c]struct_spa_support, max_support: u32) u32; +pub extern fn pw_load_spa_handle(lib: [*c]const u8, factory_name: [*c]const u8, info: [*c]const struct_spa_dict, n_support: u32, support: [*c]const struct_spa_support) [*c]struct_spa_handle; +pub extern fn pw_unload_spa_handle(handle: [*c]struct_spa_handle) c_int; +pub const struct_spa_pod_frame = extern struct { + pod: struct_spa_pod = @import("std").mem.zeroes(struct_spa_pod), + parent: [*c]struct_spa_pod_frame = @import("std").mem.zeroes([*c]struct_spa_pod_frame), + offset: u32 = @import("std").mem.zeroes(u32), + flags: u32 = @import("std").mem.zeroes(u32), +}; +pub fn spa_pod_type_size(arg_type: u32) callconv(.c) u32 { + var @"type" = arg_type; + _ = &@"type"; + while (true) { + switch (@"type") { + @as(u32, @bitCast(@as(c_int, 1))), @as(u32, @bitCast(@as(c_int, 9))), @as(u32, @bitCast(@as(c_int, 14))), @as(u32, @bitCast(@as(c_int, 20))) => return 0, + @as(u32, @bitCast(@as(c_int, 8))) => return 1, + @as(u32, @bitCast(@as(c_int, 2))), @as(u32, @bitCast(@as(c_int, 4))) => return @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(i32))))), + @as(u32, @bitCast(@as(c_int, 3))) => return @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(u32))))), + @as(u32, @bitCast(@as(c_int, 5))) => return @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(i64))))), + @as(u32, @bitCast(@as(c_int, 6))) => return @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(f32))))), + @as(u32, @bitCast(@as(c_int, 7))) => return @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(f64))))), + @as(u32, @bitCast(@as(c_int, 10))) => return @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_rectangle))))), + @as(u32, @bitCast(@as(c_int, 11))) => return @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_fraction))))), + @as(u32, @bitCast(@as(c_int, 12))) => return @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(u8))))), + @as(u32, @bitCast(@as(c_int, 13))) => return @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_array_body))))), + @as(u32, @bitCast(@as(c_int, 15))) => return @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_object_body))))), + @as(u32, @bitCast(@as(c_int, 16))) => return @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_sequence_body))))), + @as(u32, @bitCast(@as(c_int, 17))) => return @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_pointer_body))))), + @as(u32, @bitCast(@as(c_int, 18))) => return @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(i64))))), + @as(u32, @bitCast(@as(c_int, 19))) => return @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_choice_body))))), + else => {}, + } + break; + } + return 0; +} +pub fn spa_pod_body_from_data(arg_data: ?*anyopaque, arg_maxsize: usize, arg_offset: off_t, arg_size: usize, arg_pod: [*c]struct_spa_pod, arg_body: [*c]?*const anyopaque) callconv(.c) c_int { + var data = arg_data; + _ = &data; + var maxsize = arg_maxsize; + _ = &maxsize; + var offset = arg_offset; + _ = &offset; + var size = arg_size; + _ = &size; + var pod = arg_pod; + _ = &pod; + var body = arg_body; + _ = &body; + if ((offset < @as(off_t, @bitCast(@as(c_long, @as(c_int, 0))))) or (offset > @as(i64, @bitCast(@as(c_ulong, @as(c_uint, 4294967295)))))) return -@as(c_int, 22); + if (((size < @sizeOf(struct_spa_pod)) or (size > maxsize)) or ((maxsize -% size) < @as(usize, @bitCast(@as(c_ulong, @as(u32, @bitCast(@as(c_int, @truncate(offset))))))))) return -@as(c_int, 22); + _ = memcpy(@as(?*anyopaque, @ptrCast(pod)), @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(offset)))))), @sizeOf(struct_spa_pod)); + if (!(pod.*.size < (@as(c_uint, 1) << @intCast(20)))) return -@as(c_int, 22); + if (@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) > (size -% @sizeOf(struct_spa_pod))) return -@as(c_int, 22); + body.* = @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, @bitCast(offset)) +% @sizeOf(struct_spa_pod))))))); + return 0; +} +pub fn spa_pod_is_none(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_None)))); +} +pub fn spa_pod_is_bool(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool(((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Bool)))) and (@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) >= @sizeOf(i32))); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:116:13: warning: TODO implement translation of stmt class AtomicExprClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:112:22: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_body_get_bool(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_value: [*c]bool) callconv(.c) c_int; +pub fn spa_pod_is_id(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool(((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Id)))) and (@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) >= @sizeOf(u32))); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/atomic.h:22:27: warning: TODO implement translation of stmt class AtomicExprClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:125:22: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_body_get_id(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_value: [*c]u32) callconv(.c) c_int; +pub fn spa_pod_is_int(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool(((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Int)))) and (@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) >= @sizeOf(i32))); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/atomic.h:22:27: warning: TODO implement translation of stmt class AtomicExprClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:138:22: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_body_get_int(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_value: [*c]i32) callconv(.c) c_int; +pub fn spa_pod_is_long(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool(((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Long)))) and (@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) >= @sizeOf(i64))); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:245:21: warning: TODO implement translation of stmt class GCCAsmStmtClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:151:22: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_body_get_long(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_value: [*c]i64) callconv(.c) c_int; +pub fn spa_pod_is_float(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool(((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Float)))) and (@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) >= @sizeOf(f32))); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:245:21: warning: TODO implement translation of stmt class GCCAsmStmtClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:167:22: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_body_get_float(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_value: [*c]f32) callconv(.c) c_int; +pub fn spa_pod_is_double(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool(((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Double)))) and (@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) >= @sizeOf(f64))); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:245:21: warning: TODO implement translation of stmt class GCCAsmStmtClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:182:22: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_body_get_double(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_value: [*c]f64) callconv(.c) c_int; +pub fn spa_pod_is_string(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool(((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_String)))) and (pod.*.size >= @as(u32, @bitCast(@as(c_int, 1))))); +} +pub fn spa_pod_body_get_string(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_value: [*c][*c]const u8) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var body = arg_body; + _ = &body; + var value = arg_value; + _ = &value; + var s: [*c]const u8 = undefined; + _ = &s; + if (!(spa_pod_is_string(pod) != 0)) return -@as(c_int, 22); + s = @as([*c]const u8, @ptrCast(@alignCast(body))); + if (@as(c_int, @bitCast(@as(c_uint, @as([*c]const volatile u8, @ptrCast(@alignCast(s)))[pod.*.size -% @as(u32, @bitCast(@as(c_int, 1)))]))) != @as(c_int, '\x00')) return -@as(c_int, 22); + value.* = s; + return 0; +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:245:21: warning: TODO implement translation of stmt class GCCAsmStmtClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:210:22: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_body_copy_string(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_dest: [*c]u8, arg_maxlen: usize) callconv(.c) c_int; +pub fn spa_pod_is_bytes(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Bytes)))); +} +pub fn spa_pod_body_get_bytes(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_value: [*c]?*const anyopaque, arg_len: [*c]u32) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var body = arg_body; + _ = &body; + var value = arg_value; + _ = &value; + var len = arg_len; + _ = &len; + if (!(spa_pod_is_bytes(pod) != 0)) return -@as(c_int, 22); + value.* = body; + len.* = pod.*.size; + return 0; +} +pub fn spa_pod_is_pointer(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool(((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Pointer)))) and (@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) >= @sizeOf(struct_spa_pod_pointer_body))); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/atomic.h:22:27: warning: TODO implement translation of stmt class AtomicExprClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:243:22: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_body_get_pointer(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_type: [*c]u32, arg_value: [*c]?*const anyopaque) callconv(.c) c_int; +pub fn spa_pod_is_fd(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool(((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Fd)))) and (@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) >= @sizeOf(i64))); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:245:21: warning: TODO implement translation of stmt class GCCAsmStmtClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:261:22: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_body_get_fd(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_value: [*c]i64) callconv(.c) c_int; +pub fn spa_pod_is_rectangle(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool(((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Rectangle)))) and (@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) >= @sizeOf(struct_spa_rectangle))); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/atomic.h:22:27: warning: TODO implement translation of stmt class AtomicExprClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:277:22: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_body_get_rectangle(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_value: [*c]struct_spa_rectangle) callconv(.c) c_int; +pub fn spa_pod_is_fraction(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool(((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Fraction)))) and (@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) >= @sizeOf(struct_spa_fraction))); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/atomic.h:22:27: warning: TODO implement translation of stmt class AtomicExprClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:291:22: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_body_get_fraction(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_value: [*c]struct_spa_fraction) callconv(.c) c_int; +pub fn spa_pod_is_bitmap(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool(((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Bitmap)))) and (@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) >= @sizeOf(u8))); +} +pub fn spa_pod_body_get_bitmap(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_value: [*c][*c]const u8) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var body = arg_body; + _ = &body; + var value = arg_value; + _ = &value; + if (!(spa_pod_is_bitmap(pod) != 0)) return -@as(c_int, 22); + value.* = @as([*c]const u8, @ptrCast(@alignCast(body))); + return 0; +} +pub fn spa_pod_is_array(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool(((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Array)))) and (@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) >= @sizeOf(struct_spa_pod_array_body))); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/atomic.h:22:27: warning: TODO implement translation of stmt class AtomicExprClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:318:22: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_body_get_array(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_arr: [*c]struct_spa_pod_array, arg_arr_body: [*c]?*const anyopaque) callconv(.c) c_int; +pub fn spa_pod_array_body_get_values(arg_arr: [*c]const struct_spa_pod_array, arg_body: ?*const anyopaque, arg_n_values: [*c]u32, arg_val_size: [*c]u32, arg_val_type: [*c]u32) callconv(.c) ?*const anyopaque { + var arr = arg_arr; + _ = &arr; + var body = arg_body; + _ = &body; + var n_values = arg_n_values; + _ = &n_values; + var val_size = arg_val_size; + _ = &val_size; + var val_type = arg_val_type; + _ = &val_type; + var child_size: u32 = arr.*.body.child.size; + _ = &child_size; + n_values.* = @as(u32, @bitCast(@as(c_uint, @truncate(if (child_size != 0) (@as(c_ulong, @bitCast(@as(c_ulong, arr.*.pod.size))) -% @sizeOf(struct_spa_pod_array_body)) / @as(c_ulong, @bitCast(@as(c_ulong, child_size))) else @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 0)))))))); + val_size.* = child_size; + val_type.* = arr.*.body.child.type; + return body; +} +pub fn spa_pod_body_get_array_values(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_n_values: [*c]u32, arg_val_size: [*c]u32, arg_val_type: [*c]u32) callconv(.c) ?*const anyopaque { + var pod = arg_pod; + _ = &pod; + var body = arg_body; + _ = &body; + var n_values = arg_n_values; + _ = &n_values; + var val_size = arg_val_size; + _ = &val_size; + var val_type = arg_val_type; + _ = &val_type; + var arr: struct_spa_pod_array = undefined; + _ = &arr; + if (spa_pod_body_get_array(pod, body, &arr, &body) < @as(c_int, 0)) return null; + return spa_pod_array_body_get_values(&arr, body, n_values, val_size, val_type); +} +pub fn spa_pod_is_choice(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool(((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Choice)))) and (@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) >= @sizeOf(struct_spa_pod_choice_body))); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/atomic.h:22:27: warning: TODO implement translation of stmt class AtomicExprClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:352:22: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_body_get_choice(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_choice: [*c]struct_spa_pod_choice, arg_choice_body: [*c]?*const anyopaque) callconv(.c) c_int; +pub fn spa_pod_choice_body_get_values(arg_pod: [*c]const struct_spa_pod_choice, arg_body: ?*const anyopaque, arg_n_values: [*c]u32, arg_choice: [*c]u32, arg_val_size: [*c]u32, arg_val_type: [*c]u32) callconv(.c) ?*const anyopaque { + var pod = arg_pod; + _ = &pod; + var body = arg_body; + _ = &body; + var n_values = arg_n_values; + _ = &n_values; + var choice = arg_choice; + _ = &choice; + var val_size = arg_val_size; + _ = &val_size; + var val_type = arg_val_type; + _ = &val_type; + var child_size: u32 = pod.*.body.child.size; + _ = &child_size; + val_size.* = child_size; + val_type.* = pod.*.body.child.type; + n_values.* = @as(u32, @bitCast(@as(c_uint, @truncate(if (child_size != 0) (@as(c_ulong, @bitCast(@as(c_ulong, pod.*.pod.size))) -% @sizeOf(struct_spa_pod_choice_body)) / @as(c_ulong, @bitCast(@as(c_ulong, child_size))) else @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 0)))))))); + choice.* = pod.*.body.type; + if (choice.* == @as(u32, @bitCast(SPA_CHOICE_None))) { + n_values.* = blk: { + var _min_a: @TypeOf(@as(c_uint, 1)) = @as(c_uint, 1); + _ = &_min_a; + var _min_b: @TypeOf(n_values.*) = n_values.*; + _ = &_min_b; + break :blk if (__builtin_expect(@as(c_long, @intFromBool(!!(_min_a <= _min_b))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) _min_a else _min_b; + }; + } + return body; +} +pub fn spa_pod_is_struct(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Struct)))); +} +pub fn spa_pod_is_object(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool(((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Object)))) and (@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) >= @sizeOf(struct_spa_pod_object_body))); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/atomic.h:22:27: warning: TODO implement translation of stmt class AtomicExprClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:388:22: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_body_get_object(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_object: [*c]struct_spa_pod_object, arg_object_body: [*c]?*const anyopaque) callconv(.c) c_int; +pub fn spa_pod_is_sequence(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + return @intFromBool(((@as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size < (@as(c_uint, 1) << @intCast(20))) and (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Sequence)))) and (@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) >= @sizeOf(struct_spa_pod_sequence_body))); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/atomic.h:22:27: warning: TODO implement translation of stmt class AtomicExprClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:404:22: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_body_get_sequence(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_seq: [*c]struct_spa_pod_sequence, arg_seq_body: [*c]?*const anyopaque) callconv(.c) c_int; +pub const struct_spa_pod_parser_state = extern struct { + offset: u32 = @import("std").mem.zeroes(u32), + flags: u32 = @import("std").mem.zeroes(u32), + frame: [*c]struct_spa_pod_frame = @import("std").mem.zeroes([*c]struct_spa_pod_frame), +}; +pub const struct_spa_pod_parser = extern struct { + data: ?*const anyopaque = @import("std").mem.zeroes(?*const anyopaque), + size: u32 = @import("std").mem.zeroes(u32), + _padding: u32 = @import("std").mem.zeroes(u32), + state: struct_spa_pod_parser_state = @import("std").mem.zeroes(struct_spa_pod_parser_state), +}; +pub fn spa_pod_parser_init(arg_parser: [*c]struct_spa_pod_parser, arg_data: ?*const anyopaque, arg_size: u32) callconv(.c) void { + var parser = arg_parser; + _ = &parser; + var data = arg_data; + _ = &data; + var size = arg_size; + _ = &size; + parser.* = struct_spa_pod_parser{ + .data = data, + .size = size, + ._padding = @as(u32, @bitCast(@as(c_int, 0))), + .state = struct_spa_pod_parser_state{ + .offset = @as(u32, @bitCast(@as(c_int, 0))), + .flags = @as(u32, @bitCast(@as(c_int, 0))), + .frame = null, + }, + }; +} +pub fn spa_pod_parser_pod(arg_parser: [*c]struct_spa_pod_parser, arg_pod: [*c]const struct_spa_pod) callconv(.c) void { + var parser = arg_parser; + _ = &parser; + var pod = arg_pod; + _ = &pod; + spa_pod_parser_init(parser, @as(?*const anyopaque, @ptrCast(pod)), @as(u32, @bitCast(@as(c_uint, @truncate(@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size)))))))); +} +pub fn spa_pod_parser_init_pod_body(arg_parser: [*c]struct_spa_pod_parser, arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque) callconv(.c) void { + var parser = arg_parser; + _ = &parser; + var pod = arg_pod; + _ = &pod; + var body = arg_body; + _ = &body; + spa_pod_parser_init(parser, @as(?*const anyopaque, @ptrCast(@as([*c]const struct_spa_pod, @ptrFromInt(@as(usize, @intCast(@intFromPtr(body))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(-%@sizeOf(struct_spa_pod))))))))), @as(u32, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) +% @sizeOf(struct_spa_pod)))))); +} +pub fn spa_pod_parser_init_from_data(arg_parser: [*c]struct_spa_pod_parser, arg_data: ?*const anyopaque, arg_maxsize: u32, arg_offset: u32, arg_size: u32) callconv(.c) void { + var parser = arg_parser; + _ = &parser; + var data = arg_data; + _ = &data; + var maxsize = arg_maxsize; + _ = &maxsize; + var offset = arg_offset; + _ = &offset; + var size = arg_size; + _ = &size; + var offs: usize = undefined; + _ = &offs; + var sz: usize = undefined; + _ = &sz; + offs = @as(usize, @bitCast(@as(c_ulong, blk: { + var _min_a: @TypeOf(offset) = offset; + _ = &_min_a; + var _min_b: @TypeOf(maxsize) = maxsize; + _ = &_min_b; + break :blk if (__builtin_expect(@as(c_long, @intFromBool(!!(_min_a <= _min_b))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) _min_a else _min_b; + }))); + sz = blk: { + var _min_a: @TypeOf(@as(usize, @bitCast(@as(c_ulong, maxsize))) -% offs) = @as(usize, @bitCast(@as(c_ulong, maxsize))) -% offs; + _ = &_min_a; + var _min_b: @TypeOf(size) = size; + _ = &_min_b; + break :blk if (__builtin_expect(@as(c_long, @intFromBool(!!(_min_a <= @as(@TypeOf(@as(usize, @bitCast(@as(c_ulong, maxsize))) -% offs), @bitCast(@as(c_ulong, _min_b)))))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) _min_a else @as(@TypeOf(@as(usize, @bitCast(@as(c_ulong, maxsize))) -% offs), @bitCast(@as(c_ulong, _min_b))); + }; + spa_pod_parser_init(parser, @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(offs)))))), @as(u32, @bitCast(@as(c_uint, @truncate(sz))))); +} +pub fn spa_pod_parser_get_state(arg_parser: [*c]struct_spa_pod_parser, arg_state: [*c]struct_spa_pod_parser_state) callconv(.c) void { + var parser = arg_parser; + _ = &parser; + var state = arg_state; + _ = &state; + state.* = parser.*.state; +} +pub fn spa_pod_parser_reset(arg_parser: [*c]struct_spa_pod_parser, arg_state: [*c]struct_spa_pod_parser_state) callconv(.c) void { + var parser = arg_parser; + _ = &parser; + var state = arg_state; + _ = &state; + parser.*.state = state.*; +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:245:21: warning: TODO implement translation of stmt class GCCAsmStmtClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/parser.h:87:1: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_parser_read_header(arg_parser: [*c]struct_spa_pod_parser, arg_offset: u32, arg_size: u32, arg_header: ?*anyopaque, arg_header_size: u32, arg_pod_offset: u32, arg_body: [*c]?*const anyopaque) callconv(.c) c_int; +pub fn spa_pod_parser_deref(arg_parser: [*c]struct_spa_pod_parser, arg_offset: u32, arg_size: u32) callconv(.c) [*c]struct_spa_pod { + var parser = arg_parser; + _ = &parser; + var offset = arg_offset; + _ = &offset; + var size = arg_size; + _ = &size; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if (spa_pod_parser_read_header(parser, offset, size, @as(?*anyopaque, @ptrCast(&pod)), @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod))))), @as(u32, @bitCast(@as(c_int, 0))), &body) < @as(c_int, 0)) return null; + return @as([*c]struct_spa_pod, @ptrFromInt(@as(usize, @intCast(@intFromPtr(body))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(-%@sizeOf(struct_spa_pod))))))); +} +pub fn spa_pod_parser_frame(arg_parser: [*c]struct_spa_pod_parser, arg_frame: [*c]struct_spa_pod_frame) callconv(.c) [*c]struct_spa_pod { + var parser = arg_parser; + _ = &parser; + var frame = arg_frame; + _ = &frame; + return @as([*c]struct_spa_pod, @ptrFromInt(@as(usize, @intCast(@intFromPtr(parser.*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, frame.*.offset))))))); +} +pub fn spa_pod_parser_push(arg_parser: [*c]struct_spa_pod_parser, arg_frame: [*c]struct_spa_pod_frame, arg_pod: [*c]const struct_spa_pod, arg_offset: u32) callconv(.c) void { + var parser = arg_parser; + _ = &parser; + var frame = arg_frame; + _ = &frame; + var pod = arg_pod; + _ = &pod; + var offset = arg_offset; + _ = &offset; + frame.*.pod = pod.*; + frame.*.offset = offset; + frame.*.parent = parser.*.state.frame; + frame.*.flags = parser.*.state.flags; + parser.*.state.frame = frame; +} +pub fn spa_pod_parser_get_header(arg_parser: [*c]struct_spa_pod_parser, arg_header: ?*anyopaque, arg_header_size: u32, arg_pod_offset: u32, arg_body: [*c]?*const anyopaque) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var header = arg_header; + _ = &header; + var header_size = arg_header_size; + _ = &header_size; + var pod_offset = arg_pod_offset; + _ = &pod_offset; + var body = arg_body; + _ = &body; + var f: [*c]struct_spa_pod_frame = parser.*.state.frame; + _ = &f; + var size: u32 = @as(u32, @bitCast(@as(c_uint, @truncate(if (f != null) @as(u64, @bitCast(@as(c_ulong, f.*.offset))) +% (@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, (&f.*.pod).*.size)))) else @as(u64, @bitCast(@as(c_ulong, parser.*.size))))))); + _ = &size; + return spa_pod_parser_read_header(parser, parser.*.state.offset, size, header, header_size, pod_offset, body); +} +pub fn spa_pod_parser_current_body(arg_parser: [*c]struct_spa_pod_parser, arg_pod: [*c]struct_spa_pod, arg_body: [*c]?*const anyopaque) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var pod = arg_pod; + _ = &pod; + var body = arg_body; + _ = &body; + return spa_pod_parser_get_header(parser, @as(?*anyopaque, @ptrCast(pod)), @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod))))), @as(u32, @bitCast(@as(c_int, 0))), body); +} +pub fn spa_pod_parser_current(arg_parser: [*c]struct_spa_pod_parser) callconv(.c) [*c]struct_spa_pod { + var parser = arg_parser; + _ = &parser; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if (spa_pod_parser_current_body(parser, &pod, &body) < @as(c_int, 0)) return null; + return @as([*c]struct_spa_pod, @ptrFromInt(@as(usize, @intCast(@intFromPtr(body))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(-%@sizeOf(struct_spa_pod))))))); +} +pub fn spa_pod_parser_advance(arg_parser: [*c]struct_spa_pod_parser, arg_pod: [*c]const struct_spa_pod) callconv(.c) void { + var parser = arg_parser; + _ = &parser; + var pod = arg_pod; + _ = &pod; + parser.*.state.offset +%= @as(u32, @bitCast(@as(c_uint, @truncate((((@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size)))) -% @as(u64, @bitCast(@as(c_long, @as(c_int, 1))))) | @as(@TypeOf(@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size)))), @bitCast(@as(c_long, @as(c_int, 8) - @as(c_int, 1))))) +% @as(u64, @bitCast(@as(c_long, @as(c_int, 1)))))))); +} +pub fn spa_pod_parser_next_body(arg_parser: [*c]struct_spa_pod_parser, arg_pod: [*c]struct_spa_pod, arg_body: [*c]?*const anyopaque) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var pod = arg_pod; + _ = &pod; + var body = arg_body; + _ = &body; + if (spa_pod_parser_current_body(parser, pod, body) < @as(c_int, 0)) return -@as(c_int, 22); + spa_pod_parser_advance(parser, pod); + return 0; +} +pub fn spa_pod_parser_next(arg_parser: [*c]struct_spa_pod_parser) callconv(.c) [*c]struct_spa_pod { + var parser = arg_parser; + _ = &parser; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if (spa_pod_parser_current_body(parser, &pod, &body) < @as(c_int, 0)) return null; + spa_pod_parser_advance(parser, &pod); + return @as([*c]struct_spa_pod, @ptrFromInt(@as(usize, @intCast(@intFromPtr(body))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(-%@sizeOf(struct_spa_pod))))))); +} +pub fn spa_pod_parser_restart(arg_parser: [*c]struct_spa_pod_parser, arg_frame: [*c]struct_spa_pod_frame) callconv(.c) void { + var parser = arg_parser; + _ = &parser; + var frame = arg_frame; + _ = &frame; + parser.*.state.offset = frame.*.offset; +} +pub fn spa_pod_parser_unpush(arg_parser: [*c]struct_spa_pod_parser, arg_frame: [*c]struct_spa_pod_frame) callconv(.c) void { + var parser = arg_parser; + _ = &parser; + var frame = arg_frame; + _ = &frame; + spa_pod_parser_restart(parser, frame); + parser.*.state.frame = frame.*.parent; +} +pub fn spa_pod_parser_pop(arg_parser: [*c]struct_spa_pod_parser, arg_frame: [*c]struct_spa_pod_frame) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var frame = arg_frame; + _ = &frame; + spa_pod_parser_unpush(parser, frame); + spa_pod_parser_advance(parser, &frame.*.pod); + return 0; +} +pub fn spa_pod_parser_get_bool(arg_parser: [*c]struct_spa_pod_parser, arg_value: [*c]bool) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var value = arg_value; + _ = &value; + var res: c_int = undefined; + _ = &res; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if ((blk: { + const tmp = spa_pod_parser_current_body(parser, &pod, &body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + if ((blk: { + const tmp = spa_pod_body_get_bool(&pod, body, value); + res = tmp; + break :blk tmp; + }) >= @as(c_int, 0)) { + spa_pod_parser_advance(parser, &pod); + } + return res; +} +pub fn spa_pod_parser_get_id(arg_parser: [*c]struct_spa_pod_parser, arg_value: [*c]u32) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var value = arg_value; + _ = &value; + var res: c_int = undefined; + _ = &res; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if ((blk: { + const tmp = spa_pod_parser_current_body(parser, &pod, &body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + if ((blk: { + const tmp = spa_pod_body_get_id(&pod, body, value); + res = tmp; + break :blk tmp; + }) >= @as(c_int, 0)) { + spa_pod_parser_advance(parser, &pod); + } + return res; +} +pub fn spa_pod_parser_get_int(arg_parser: [*c]struct_spa_pod_parser, arg_value: [*c]i32) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var value = arg_value; + _ = &value; + var res: c_int = undefined; + _ = &res; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if ((blk: { + const tmp = spa_pod_parser_current_body(parser, &pod, &body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + if ((blk: { + const tmp = spa_pod_body_get_int(&pod, body, value); + res = tmp; + break :blk tmp; + }) >= @as(c_int, 0)) { + spa_pod_parser_advance(parser, &pod); + } + return res; +} +pub fn spa_pod_parser_get_long(arg_parser: [*c]struct_spa_pod_parser, arg_value: [*c]i64) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var value = arg_value; + _ = &value; + var res: c_int = undefined; + _ = &res; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if ((blk: { + const tmp = spa_pod_parser_current_body(parser, &pod, &body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + if ((blk: { + const tmp = spa_pod_body_get_long(&pod, body, value); + res = tmp; + break :blk tmp; + }) >= @as(c_int, 0)) { + spa_pod_parser_advance(parser, &pod); + } + return res; +} +pub fn spa_pod_parser_get_float(arg_parser: [*c]struct_spa_pod_parser, arg_value: [*c]f32) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var value = arg_value; + _ = &value; + var res: c_int = undefined; + _ = &res; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if ((blk: { + const tmp = spa_pod_parser_current_body(parser, &pod, &body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + if ((blk: { + const tmp = spa_pod_body_get_float(&pod, body, value); + res = tmp; + break :blk tmp; + }) >= @as(c_int, 0)) { + spa_pod_parser_advance(parser, &pod); + } + return res; +} +pub fn spa_pod_parser_get_double(arg_parser: [*c]struct_spa_pod_parser, arg_value: [*c]f64) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var value = arg_value; + _ = &value; + var res: c_int = undefined; + _ = &res; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if ((blk: { + const tmp = spa_pod_parser_current_body(parser, &pod, &body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + if ((blk: { + const tmp = spa_pod_body_get_double(&pod, body, value); + res = tmp; + break :blk tmp; + }) >= @as(c_int, 0)) { + spa_pod_parser_advance(parser, &pod); + } + return res; +} +pub fn spa_pod_parser_get_string(arg_parser: [*c]struct_spa_pod_parser, arg_value: [*c][*c]const u8) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var value = arg_value; + _ = &value; + var res: c_int = undefined; + _ = &res; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if ((blk: { + const tmp = spa_pod_parser_current_body(parser, &pod, &body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + if ((blk: { + const tmp = spa_pod_body_get_string(&pod, body, value); + res = tmp; + break :blk tmp; + }) >= @as(c_int, 0)) { + spa_pod_parser_advance(parser, &pod); + } + return res; +} +pub fn spa_pod_parser_get_bytes(arg_parser: [*c]struct_spa_pod_parser, arg_value: [*c]?*const anyopaque, arg_len: [*c]u32) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var value = arg_value; + _ = &value; + var len = arg_len; + _ = &len; + var res: c_int = undefined; + _ = &res; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if ((blk: { + const tmp = spa_pod_parser_current_body(parser, &pod, &body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + if ((blk: { + const tmp = spa_pod_body_get_bytes(&pod, body, value, len); + res = tmp; + break :blk tmp; + }) >= @as(c_int, 0)) { + spa_pod_parser_advance(parser, &pod); + } + return res; +} +pub fn spa_pod_parser_get_pointer(arg_parser: [*c]struct_spa_pod_parser, arg_type: [*c]u32, arg_value: [*c]?*const anyopaque) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var @"type" = arg_type; + _ = &@"type"; + var value = arg_value; + _ = &value; + var res: c_int = undefined; + _ = &res; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if ((blk: { + const tmp = spa_pod_parser_current_body(parser, &pod, &body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + if ((blk: { + const tmp = spa_pod_body_get_pointer(&pod, body, @"type", value); + res = tmp; + break :blk tmp; + }) >= @as(c_int, 0)) { + spa_pod_parser_advance(parser, &pod); + } + return res; +} +pub fn spa_pod_parser_get_fd(arg_parser: [*c]struct_spa_pod_parser, arg_value: [*c]i64) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var value = arg_value; + _ = &value; + var res: c_int = undefined; + _ = &res; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if ((blk: { + const tmp = spa_pod_parser_current_body(parser, &pod, &body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + if ((blk: { + const tmp = spa_pod_body_get_fd(&pod, body, value); + res = tmp; + break :blk tmp; + }) >= @as(c_int, 0)) { + spa_pod_parser_advance(parser, &pod); + } + return res; +} +pub fn spa_pod_parser_get_rectangle(arg_parser: [*c]struct_spa_pod_parser, arg_value: [*c]struct_spa_rectangle) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var value = arg_value; + _ = &value; + var res: c_int = undefined; + _ = &res; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if ((blk: { + const tmp = spa_pod_parser_current_body(parser, &pod, &body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + if ((blk: { + const tmp = spa_pod_body_get_rectangle(&pod, body, value); + res = tmp; + break :blk tmp; + }) >= @as(c_int, 0)) { + spa_pod_parser_advance(parser, &pod); + } + return res; +} +pub fn spa_pod_parser_get_fraction(arg_parser: [*c]struct_spa_pod_parser, arg_value: [*c]struct_spa_fraction) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var value = arg_value; + _ = &value; + var res: c_int = undefined; + _ = &res; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if ((blk: { + const tmp = spa_pod_parser_current_body(parser, &pod, &body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + if ((blk: { + const tmp = spa_pod_body_get_fraction(&pod, body, value); + res = tmp; + break :blk tmp; + }) >= @as(c_int, 0)) { + spa_pod_parser_advance(parser, &pod); + } + return res; +} +pub fn spa_pod_parser_get_pod_body(arg_parser: [*c]struct_spa_pod_parser, arg_value: [*c]struct_spa_pod, arg_body: [*c]?*const anyopaque) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var value = arg_value; + _ = &value; + var body = arg_body; + _ = &body; + var res: c_int = undefined; + _ = &res; + if ((blk: { + const tmp = spa_pod_parser_current_body(parser, value, body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + spa_pod_parser_advance(parser, value); + return 0; +} +pub fn spa_pod_parser_get_pod(arg_parser: [*c]struct_spa_pod_parser, arg_value: [*c][*c]struct_spa_pod) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var value = arg_value; + _ = &value; + var res: c_int = undefined; + _ = &res; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if ((blk: { + const tmp = spa_pod_parser_get_pod_body(parser, &pod, &body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + value.* = @as([*c]struct_spa_pod, @ptrFromInt(@as(usize, @intCast(@intFromPtr(body))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(-%@sizeOf(struct_spa_pod))))))); + return 0; +} +pub fn spa_pod_parser_init_struct_body(arg_parser: [*c]struct_spa_pod_parser, arg_frame: [*c]struct_spa_pod_frame, arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var frame = arg_frame; + _ = &frame; + var pod = arg_pod; + _ = &pod; + var body = arg_body; + _ = &body; + if (!(spa_pod_is_struct(pod) != 0)) return -@as(c_int, 22); + spa_pod_parser_init_pod_body(parser, pod, body); + spa_pod_parser_push(parser, frame, pod, parser.*.state.offset); + parser.*.state.offset +%= @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_struct))))); + return 0; +} +pub fn spa_pod_parser_push_struct_body(arg_parser: [*c]struct_spa_pod_parser, arg_frame: [*c]struct_spa_pod_frame, arg_str: [*c]struct_spa_pod, arg_str_body: [*c]?*const anyopaque) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var frame = arg_frame; + _ = &frame; + var str = arg_str; + _ = &str; + var str_body = arg_str_body; + _ = &str_body; + var res: c_int = undefined; + _ = &res; + if ((blk: { + const tmp = spa_pod_parser_current_body(parser, str, str_body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + if (!(spa_pod_is_struct(str) != 0)) return -@as(c_int, 22); + spa_pod_parser_push(parser, frame, str, parser.*.state.offset); + parser.*.state.offset +%= @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_struct))))); + return 0; +} +pub fn spa_pod_parser_push_struct(arg_parser: [*c]struct_spa_pod_parser, arg_frame: [*c]struct_spa_pod_frame) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var frame = arg_frame; + _ = &frame; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + return spa_pod_parser_push_struct_body(parser, frame, &pod, &body); +} +pub fn spa_pod_parser_init_object_body(arg_parser: [*c]struct_spa_pod_parser, arg_frame: [*c]struct_spa_pod_frame, arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_object: [*c]struct_spa_pod_object, arg_object_body: [*c]?*const anyopaque) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var frame = arg_frame; + _ = &frame; + var pod = arg_pod; + _ = &pod; + var body = arg_body; + _ = &body; + var object = arg_object; + _ = &object; + var object_body = arg_object_body; + _ = &object_body; + var res: c_int = undefined; + _ = &res; + if (!(spa_pod_is_object(pod) != 0)) return -@as(c_int, 22); + spa_pod_parser_init_pod_body(parser, pod, body); + if ((blk: { + const tmp = spa_pod_body_get_object(pod, body, object, object_body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + spa_pod_parser_push(parser, frame, pod, parser.*.state.offset); + parser.*.state.offset +%= @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_object))))); + return 0; +} +pub fn spa_pod_parser_push_object_body(arg_parser: [*c]struct_spa_pod_parser, arg_frame: [*c]struct_spa_pod_frame, arg_object: [*c]struct_spa_pod_object, arg_object_body: [*c]?*const anyopaque) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var frame = arg_frame; + _ = &frame; + var object = arg_object; + _ = &object; + var object_body = arg_object_body; + _ = &object_body; + var res: c_int = undefined; + _ = &res; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if ((blk: { + const tmp = spa_pod_parser_current_body(parser, &pod, &body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + if ((blk: { + const tmp = spa_pod_body_get_object(&pod, body, object, object_body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + spa_pod_parser_push(parser, frame, &pod, parser.*.state.offset); + parser.*.state.offset +%= @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_object))))); + return 0; +} +pub fn spa_pod_parser_push_object(arg_parser: [*c]struct_spa_pod_parser, arg_frame: [*c]struct_spa_pod_frame, arg_type: u32, arg_id: [*c]u32) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var frame = arg_frame; + _ = &frame; + var @"type" = arg_type; + _ = &@"type"; + var id = arg_id; + _ = &id; + var res: c_int = undefined; + _ = &res; + var obj: struct_spa_pod_object = undefined; + _ = &obj; + var obj_body: ?*const anyopaque = undefined; + _ = &obj_body; + if ((blk: { + const tmp = spa_pod_parser_push_object_body(parser, frame, &obj, &obj_body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + if (@"type" != obj.body.type) { + spa_pod_parser_unpush(parser, frame); + return -@as(c_int, 71); + } + if (id != @as([*c]u32, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + id.* = obj.body.id; + } + return 0; +} +pub fn spa_pod_parser_get_prop_body(arg_parser: [*c]struct_spa_pod_parser, arg_prop: [*c]struct_spa_pod_prop, arg_body: [*c]?*const anyopaque) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var prop = arg_prop; + _ = ∝ + var body = arg_body; + _ = &body; + var res: c_int = undefined; + _ = &res; + if ((blk: { + const tmp = spa_pod_parser_get_header(parser, @as(?*anyopaque, @ptrCast(prop)), @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_prop))))), @as(u32, @bitCast(@as(c_uint, @truncate(@offsetOf(struct_spa_pod_prop, "value"))))), body); + res = tmp; + break :blk tmp; + }) >= @as(c_int, 0)) { + parser.*.state.offset +%= @as(u32, @bitCast(@as(c_uint, @truncate((((@sizeOf(struct_spa_pod_prop) +% @as(c_ulong, @bitCast(@as(c_ulong, prop.*.value.size)))) -% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1))))) | @as(@TypeOf(@sizeOf(struct_spa_pod_prop) +% @as(c_ulong, @bitCast(@as(c_ulong, prop.*.value.size)))), @bitCast(@as(c_long, @as(c_int, 8) - @as(c_int, 1))))) +% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + } + return res; +} +pub fn spa_pod_parser_push_sequence_body(arg_parser: [*c]struct_spa_pod_parser, arg_frame: [*c]struct_spa_pod_frame, arg_seq: [*c]struct_spa_pod_sequence, arg_seq_body: [*c]?*const anyopaque) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var frame = arg_frame; + _ = &frame; + var seq = arg_seq; + _ = &seq; + var seq_body = arg_seq_body; + _ = &seq_body; + var res: c_int = undefined; + _ = &res; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if ((blk: { + const tmp = spa_pod_parser_current_body(parser, &pod, &body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + if ((blk: { + const tmp = spa_pod_body_get_sequence(&pod, body, seq, seq_body); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + spa_pod_parser_push(parser, frame, &pod, parser.*.state.offset); + parser.*.state.offset +%= @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_sequence))))); + return 0; +} +pub fn spa_pod_parser_get_control_body(arg_parser: [*c]struct_spa_pod_parser, arg_control: [*c]struct_spa_pod_control, arg_body: [*c]?*const anyopaque) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var control = arg_control; + _ = &control; + var body = arg_body; + _ = &body; + var res: c_int = undefined; + _ = &res; + if ((blk: { + const tmp = spa_pod_parser_get_header(parser, @as(?*anyopaque, @ptrCast(control)), @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_control))))), @as(u32, @bitCast(@as(c_uint, @truncate(@offsetOf(struct_spa_pod_control, "value"))))), body); + res = tmp; + break :blk tmp; + }) >= @as(c_int, 0)) { + parser.*.state.offset +%= @as(u32, @bitCast(@as(c_uint, @truncate((((@sizeOf(struct_spa_pod_control) +% @as(c_ulong, @bitCast(@as(c_ulong, control.*.value.size)))) -% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1))))) | @as(@TypeOf(@sizeOf(struct_spa_pod_control) +% @as(c_ulong, @bitCast(@as(c_ulong, control.*.value.size)))), @bitCast(@as(c_long, @as(c_int, 8) - @as(c_int, 1))))) +% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))); + } + return res; +} +pub fn spa_pod_parser_object_find_prop(arg_parser: [*c]struct_spa_pod_parser, arg_key: u32, arg_prop: [*c]struct_spa_pod_prop, arg_body: [*c]?*const anyopaque) callconv(.c) c_int { + var parser = arg_parser; + _ = &parser; + var key = arg_key; + _ = &key; + var prop = arg_prop; + _ = ∝ + var body = arg_body; + _ = &body; + var start_offset: u32 = undefined; + _ = &start_offset; + var f: [*c]struct_spa_pod_frame = parser.*.state.frame; + _ = &f; + if ((f == @as([*c]struct_spa_pod_frame, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) or (f.*.pod.type != @as(u32, @bitCast(SPA_TYPE_Object)))) return -@as(c_int, 22); + start_offset = f.*.offset; + while (spa_pod_parser_get_prop_body(parser, prop, body) >= @as(c_int, 0)) { + if (prop.*.key == key) return 0; + } + spa_pod_parser_restart(parser, f); + parser.*.state.offset +%= @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_object))))); + while ((parser.*.state.offset != start_offset) and (spa_pod_parser_get_prop_body(parser, prop, body) >= @as(c_int, 0))) { + if (prop.*.key == key) return 0; + } + body.* = null; + return -@as(c_int, 2); +} +pub fn spa_pod_parser_body_can_collect(arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_type: u8) callconv(.c) bool { + var pod = arg_pod; + _ = &pod; + var body = arg_body; + _ = &body; + var @"type" = arg_type; + _ = &@"type"; + var choice: struct_spa_pod_choice = undefined; + _ = &choice; + if (pod == @as([*c]const struct_spa_pod, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return @as(c_int, 0) != 0; + if (pod.*.type == @as(u32, @bitCast(SPA_TYPE_Choice))) { + if (!(spa_pod_is_choice(pod) != 0)) return @as(c_int, 0) != 0; + if ((@as(c_int, @bitCast(@as(c_uint, @"type"))) == @as(c_int, 'V')) or (@as(c_int, @bitCast(@as(c_uint, @"type"))) == @as(c_int, 'W'))) return @as(c_int, 1) != 0; + if (spa_pod_body_get_choice(pod, body, &choice, &body) < @as(c_int, 0)) return @as(c_int, 0) != 0; + if (choice.body.type != @as(u32, @bitCast(SPA_CHOICE_None))) return @as(c_int, 0) != 0; + pod = &choice.body.child; + } + while (true) { + switch (@as(c_int, @bitCast(@as(c_uint, @"type")))) { + @as(c_int, 80), @as(c_int, 81) => return @as(c_int, 1) != 0, + @as(c_int, 98) => return spa_pod_is_bool(pod) != 0, + @as(c_int, 73) => return spa_pod_is_id(pod) != 0, + @as(c_int, 105) => return spa_pod_is_int(pod) != 0, + @as(c_int, 108) => return spa_pod_is_long(pod) != 0, + @as(c_int, 102) => return spa_pod_is_float(pod) != 0, + @as(c_int, 100) => return spa_pod_is_double(pod) != 0, + @as(c_int, 115) => return (spa_pod_is_string(pod) != 0) or (spa_pod_is_none(pod) != 0), + @as(c_int, 83) => return spa_pod_is_string(pod) != 0, + @as(c_int, 121) => return spa_pod_is_bytes(pod) != 0, + @as(c_int, 82) => return spa_pod_is_rectangle(pod) != 0, + @as(c_int, 70) => return spa_pod_is_fraction(pod) != 0, + @as(c_int, 66) => return spa_pod_is_bitmap(pod) != 0, + @as(c_int, 97) => return spa_pod_is_array(pod) != 0, + @as(c_int, 112) => return spa_pod_is_pointer(pod) != 0, + @as(c_int, 104) => return spa_pod_is_fd(pod) != 0, + @as(c_int, 84), @as(c_int, 85) => return (spa_pod_is_struct(pod) != 0) or (spa_pod_is_none(pod) != 0), + @as(c_int, 78), @as(c_int, 79) => return (spa_pod_is_object(pod) != 0) or (spa_pod_is_none(pod) != 0), + else => return @as(c_int, 0) != 0, + } + break; + } + return false; +} +pub fn spa_pod_parser_can_collect(arg_pod: [*c]const struct_spa_pod, arg_type: u8) callconv(.c) bool { + var pod = arg_pod; + _ = &pod; + var @"type" = arg_type; + _ = &@"type"; + return spa_pod_parser_body_can_collect(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), @"type"); +} +// /home/mason/.cache/zig/p/N-V-__8AAN5NhBR0oTsvnwjPdeNiiDLtEsfXRHd1fv-R3TOv/lib/include/__stdarg_va_arg.h:20:26: warning: unsupported stmt class VAArgExprClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/parser.h:787:24: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_parser_getv(arg_parser: [*c]struct_spa_pod_parser, arg_args: [*c]struct___va_list_tag_26) callconv(.c) c_int; +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/parser.h:840:24: warning: TODO unable to translate variadic function, demoted to extern +pub extern fn spa_pod_parser_get(parser: [*c]struct_spa_pod_parser, ...) c_int; +pub const SPA_MEDIA_TYPE_unknown: c_int = 0; +pub const SPA_MEDIA_TYPE_audio: c_int = 1; +pub const SPA_MEDIA_TYPE_video: c_int = 2; +pub const SPA_MEDIA_TYPE_image: c_int = 3; +pub const SPA_MEDIA_TYPE_binary: c_int = 4; +pub const SPA_MEDIA_TYPE_stream: c_int = 5; +pub const SPA_MEDIA_TYPE_application: c_int = 6; +pub const enum_spa_media_type = c_uint; +pub const SPA_MEDIA_SUBTYPE_unknown: c_int = 0; +pub const SPA_MEDIA_SUBTYPE_raw: c_int = 1; +pub const SPA_MEDIA_SUBTYPE_dsp: c_int = 2; +pub const SPA_MEDIA_SUBTYPE_iec958: c_int = 3; +pub const SPA_MEDIA_SUBTYPE_dsd: c_int = 4; +pub const SPA_MEDIA_SUBTYPE_START_Audio: c_int = 65536; +pub const SPA_MEDIA_SUBTYPE_mp3: c_int = 65537; +pub const SPA_MEDIA_SUBTYPE_aac: c_int = 65538; +pub const SPA_MEDIA_SUBTYPE_vorbis: c_int = 65539; +pub const SPA_MEDIA_SUBTYPE_wma: c_int = 65540; +pub const SPA_MEDIA_SUBTYPE_ra: c_int = 65541; +pub const SPA_MEDIA_SUBTYPE_sbc: c_int = 65542; +pub const SPA_MEDIA_SUBTYPE_adpcm: c_int = 65543; +pub const SPA_MEDIA_SUBTYPE_g723: c_int = 65544; +pub const SPA_MEDIA_SUBTYPE_g726: c_int = 65545; +pub const SPA_MEDIA_SUBTYPE_g729: c_int = 65546; +pub const SPA_MEDIA_SUBTYPE_amr: c_int = 65547; +pub const SPA_MEDIA_SUBTYPE_gsm: c_int = 65548; +pub const SPA_MEDIA_SUBTYPE_alac: c_int = 65549; +pub const SPA_MEDIA_SUBTYPE_flac: c_int = 65550; +pub const SPA_MEDIA_SUBTYPE_ape: c_int = 65551; +pub const SPA_MEDIA_SUBTYPE_opus: c_int = 65552; +pub const SPA_MEDIA_SUBTYPE_ac3: c_int = 65553; +pub const SPA_MEDIA_SUBTYPE_eac3: c_int = 65554; +pub const SPA_MEDIA_SUBTYPE_truehd: c_int = 65555; +pub const SPA_MEDIA_SUBTYPE_dts: c_int = 65556; +pub const SPA_MEDIA_SUBTYPE_mpegh: c_int = 65557; +pub const SPA_MEDIA_SUBTYPE_START_Video: c_int = 131072; +pub const SPA_MEDIA_SUBTYPE_h264: c_int = 131073; +pub const SPA_MEDIA_SUBTYPE_mjpg: c_int = 131074; +pub const SPA_MEDIA_SUBTYPE_dv: c_int = 131075; +pub const SPA_MEDIA_SUBTYPE_mpegts: c_int = 131076; +pub const SPA_MEDIA_SUBTYPE_h263: c_int = 131077; +pub const SPA_MEDIA_SUBTYPE_mpeg1: c_int = 131078; +pub const SPA_MEDIA_SUBTYPE_mpeg2: c_int = 131079; +pub const SPA_MEDIA_SUBTYPE_mpeg4: c_int = 131080; +pub const SPA_MEDIA_SUBTYPE_xvid: c_int = 131081; +pub const SPA_MEDIA_SUBTYPE_vc1: c_int = 131082; +pub const SPA_MEDIA_SUBTYPE_vp8: c_int = 131083; +pub const SPA_MEDIA_SUBTYPE_vp9: c_int = 131084; +pub const SPA_MEDIA_SUBTYPE_bayer: c_int = 131085; +pub const SPA_MEDIA_SUBTYPE_h265: c_int = 131086; +pub const SPA_MEDIA_SUBTYPE_START_Image: c_int = 196608; +pub const SPA_MEDIA_SUBTYPE_jpeg: c_int = 196609; +pub const SPA_MEDIA_SUBTYPE_START_Binary: c_int = 262144; +pub const SPA_MEDIA_SUBTYPE_START_Stream: c_int = 327680; +pub const SPA_MEDIA_SUBTYPE_midi: c_int = 327681; +pub const SPA_MEDIA_SUBTYPE_START_Application: c_int = 393216; +pub const SPA_MEDIA_SUBTYPE_control: c_int = 393217; +pub const enum_spa_media_subtype = c_uint; +pub const SPA_FORMAT_START: c_int = 0; +pub const SPA_FORMAT_mediaType: c_int = 1; +pub const SPA_FORMAT_mediaSubtype: c_int = 2; +pub const SPA_FORMAT_START_Audio: c_int = 65536; +pub const SPA_FORMAT_AUDIO_format: c_int = 65537; +pub const SPA_FORMAT_AUDIO_flags: c_int = 65538; +pub const SPA_FORMAT_AUDIO_rate: c_int = 65539; +pub const SPA_FORMAT_AUDIO_channels: c_int = 65540; +pub const SPA_FORMAT_AUDIO_position: c_int = 65541; +pub const SPA_FORMAT_AUDIO_iec958Codec: c_int = 65542; +pub const SPA_FORMAT_AUDIO_bitorder: c_int = 65543; +pub const SPA_FORMAT_AUDIO_interleave: c_int = 65544; +pub const SPA_FORMAT_AUDIO_bitrate: c_int = 65545; +pub const SPA_FORMAT_AUDIO_blockAlign: c_int = 65546; +pub const SPA_FORMAT_AUDIO_AAC_streamFormat: c_int = 65547; +pub const SPA_FORMAT_AUDIO_WMA_profile: c_int = 65548; +pub const SPA_FORMAT_AUDIO_AMR_bandMode: c_int = 65549; +pub const SPA_FORMAT_AUDIO_MP3_channelMode: c_int = 65550; +pub const SPA_FORMAT_AUDIO_DTS_extType: c_int = 65551; +pub const SPA_FORMAT_START_Video: c_int = 131072; +pub const SPA_FORMAT_VIDEO_format: c_int = 131073; +pub const SPA_FORMAT_VIDEO_modifier: c_int = 131074; +pub const SPA_FORMAT_VIDEO_size: c_int = 131075; +pub const SPA_FORMAT_VIDEO_framerate: c_int = 131076; +pub const SPA_FORMAT_VIDEO_maxFramerate: c_int = 131077; +pub const SPA_FORMAT_VIDEO_views: c_int = 131078; +pub const SPA_FORMAT_VIDEO_interlaceMode: c_int = 131079; +pub const SPA_FORMAT_VIDEO_pixelAspectRatio: c_int = 131080; +pub const SPA_FORMAT_VIDEO_multiviewMode: c_int = 131081; +pub const SPA_FORMAT_VIDEO_multiviewFlags: c_int = 131082; +pub const SPA_FORMAT_VIDEO_chromaSite: c_int = 131083; +pub const SPA_FORMAT_VIDEO_colorRange: c_int = 131084; +pub const SPA_FORMAT_VIDEO_colorMatrix: c_int = 131085; +pub const SPA_FORMAT_VIDEO_transferFunction: c_int = 131086; +pub const SPA_FORMAT_VIDEO_colorPrimaries: c_int = 131087; +pub const SPA_FORMAT_VIDEO_profile: c_int = 131088; +pub const SPA_FORMAT_VIDEO_level: c_int = 131089; +pub const SPA_FORMAT_VIDEO_H264_streamFormat: c_int = 131090; +pub const SPA_FORMAT_VIDEO_H264_alignment: c_int = 131091; +pub const SPA_FORMAT_VIDEO_H265_streamFormat: c_int = 131092; +pub const SPA_FORMAT_VIDEO_H265_alignment: c_int = 131093; +pub const SPA_FORMAT_START_Image: c_int = 196608; +pub const SPA_FORMAT_START_Binary: c_int = 262144; +pub const SPA_FORMAT_START_Stream: c_int = 327680; +pub const SPA_FORMAT_START_Application: c_int = 393216; +pub const SPA_FORMAT_CONTROL_types: c_int = 393217; +pub const enum_spa_format = c_uint; +pub fn spa_format_parse(arg_format: [*c]const struct_spa_pod, arg_media_type: [*c]u32, arg_media_subtype: [*c]u32) callconv(.c) c_int { + var format = arg_format; + _ = &format; + var media_type = arg_media_type; + _ = &media_type; + var media_subtype = arg_media_subtype; + _ = &media_subtype; + return blk: { + var _p: struct_spa_pod_parser = undefined; + _ = &_p; + spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod)))))))); + break :blk blk_1: { + var _f: struct_spa_pod_frame = undefined; + _ = &_f; + var _res: c_int = undefined; + _ = &_res; + if ((blk_2: { + const tmp = spa_pod_parser_push_object(&_p, &_f, @as(u32, @bitCast(SPA_TYPE_OBJECT_Format)), null); + _res = tmp; + break :blk_2 tmp; + }) == @as(c_int, 0)) { + _res = spa_pod_parser_get(&_p, SPA_FORMAT_mediaType, "I", media_type, SPA_FORMAT_mediaSubtype, "I", media_subtype, @as(c_int, 0)); + _ = spa_pod_parser_pop(&_p, &_f); + } + break :blk_1 _res; + }; + }; +} +pub const SPA_VIDEO_CHROMA_SITE_UNKNOWN: c_int = 0; +pub const SPA_VIDEO_CHROMA_SITE_NONE: c_int = 1; +pub const SPA_VIDEO_CHROMA_SITE_H_COSITED: c_int = 2; +pub const SPA_VIDEO_CHROMA_SITE_V_COSITED: c_int = 4; +pub const SPA_VIDEO_CHROMA_SITE_ALT_LINE: c_int = 8; +pub const SPA_VIDEO_CHROMA_SITE_COSITED: c_int = 6; +pub const SPA_VIDEO_CHROMA_SITE_JPEG: c_int = 1; +pub const SPA_VIDEO_CHROMA_SITE_MPEG2: c_int = 2; +pub const SPA_VIDEO_CHROMA_SITE_DV: c_int = 14; +pub const enum_spa_video_chroma_site = c_uint; +pub const SPA_VIDEO_COLOR_RANGE_UNKNOWN: c_int = 0; +pub const SPA_VIDEO_COLOR_RANGE_0_255: c_int = 1; +pub const SPA_VIDEO_COLOR_RANGE_16_235: c_int = 2; +pub const enum_spa_video_color_range = c_uint; +pub const SPA_VIDEO_COLOR_MATRIX_UNKNOWN: c_int = 0; +pub const SPA_VIDEO_COLOR_MATRIX_RGB: c_int = 1; +pub const SPA_VIDEO_COLOR_MATRIX_FCC: c_int = 2; +pub const SPA_VIDEO_COLOR_MATRIX_BT709: c_int = 3; +pub const SPA_VIDEO_COLOR_MATRIX_BT601: c_int = 4; +pub const SPA_VIDEO_COLOR_MATRIX_SMPTE240M: c_int = 5; +pub const SPA_VIDEO_COLOR_MATRIX_BT2020: c_int = 6; +pub const enum_spa_video_color_matrix = c_uint; +pub const SPA_VIDEO_TRANSFER_UNKNOWN: c_int = 0; +pub const SPA_VIDEO_TRANSFER_GAMMA10: c_int = 1; +pub const SPA_VIDEO_TRANSFER_GAMMA18: c_int = 2; +pub const SPA_VIDEO_TRANSFER_GAMMA20: c_int = 3; +pub const SPA_VIDEO_TRANSFER_GAMMA22: c_int = 4; +pub const SPA_VIDEO_TRANSFER_BT709: c_int = 5; +pub const SPA_VIDEO_TRANSFER_SMPTE240M: c_int = 6; +pub const SPA_VIDEO_TRANSFER_SRGB: c_int = 7; +pub const SPA_VIDEO_TRANSFER_GAMMA28: c_int = 8; +pub const SPA_VIDEO_TRANSFER_LOG100: c_int = 9; +pub const SPA_VIDEO_TRANSFER_LOG316: c_int = 10; +pub const SPA_VIDEO_TRANSFER_BT2020_12: c_int = 11; +pub const SPA_VIDEO_TRANSFER_ADOBERGB: c_int = 12; +pub const SPA_VIDEO_TRANSFER_BT2020_10: c_int = 13; +pub const SPA_VIDEO_TRANSFER_SMPTE2084: c_int = 14; +pub const SPA_VIDEO_TRANSFER_ARIB_STD_B67: c_int = 15; +pub const SPA_VIDEO_TRANSFER_BT601: c_int = 16; +pub const enum_spa_video_transfer_function = c_uint; +pub const SPA_VIDEO_COLOR_PRIMARIES_UNKNOWN: c_int = 0; +pub const SPA_VIDEO_COLOR_PRIMARIES_BT709: c_int = 1; +pub const SPA_VIDEO_COLOR_PRIMARIES_BT470M: c_int = 2; +pub const SPA_VIDEO_COLOR_PRIMARIES_BT470BG: c_int = 3; +pub const SPA_VIDEO_COLOR_PRIMARIES_SMPTE170M: c_int = 4; +pub const SPA_VIDEO_COLOR_PRIMARIES_SMPTE240M: c_int = 5; +pub const SPA_VIDEO_COLOR_PRIMARIES_FILM: c_int = 6; +pub const SPA_VIDEO_COLOR_PRIMARIES_BT2020: c_int = 7; +pub const SPA_VIDEO_COLOR_PRIMARIES_ADOBERGB: c_int = 8; +pub const SPA_VIDEO_COLOR_PRIMARIES_SMPTEST428: c_int = 9; +pub const SPA_VIDEO_COLOR_PRIMARIES_SMPTERP431: c_int = 10; +pub const SPA_VIDEO_COLOR_PRIMARIES_SMPTEEG432: c_int = 11; +pub const SPA_VIDEO_COLOR_PRIMARIES_EBU3213: c_int = 12; +pub const enum_spa_video_color_primaries = c_uint; +pub const struct_spa_video_colorimetry = extern struct { + range: enum_spa_video_color_range = @import("std").mem.zeroes(enum_spa_video_color_range), + matrix: enum_spa_video_color_matrix = @import("std").mem.zeroes(enum_spa_video_color_matrix), + transfer: enum_spa_video_transfer_function = @import("std").mem.zeroes(enum_spa_video_transfer_function), + primaries: enum_spa_video_color_primaries = @import("std").mem.zeroes(enum_spa_video_color_primaries), +}; +pub const SPA_VIDEO_MULTIVIEW_MODE_NONE: c_int = -1; +pub const SPA_VIDEO_MULTIVIEW_MODE_MONO: c_int = 0; +pub const SPA_VIDEO_MULTIVIEW_MODE_LEFT: c_int = 1; +pub const SPA_VIDEO_MULTIVIEW_MODE_RIGHT: c_int = 2; +pub const SPA_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE: c_int = 3; +pub const SPA_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE_QUINCUNX: c_int = 4; +pub const SPA_VIDEO_MULTIVIEW_MODE_COLUMN_INTERLEAVED: c_int = 5; +pub const SPA_VIDEO_MULTIVIEW_MODE_ROW_INTERLEAVED: c_int = 6; +pub const SPA_VIDEO_MULTIVIEW_MODE_TOP_BOTTOM: c_int = 7; +pub const SPA_VIDEO_MULTIVIEW_MODE_CHECKERBOARD: c_int = 8; +pub const SPA_VIDEO_MULTIVIEW_MODE_FRAME_BY_FRAME: c_int = 32; +pub const SPA_VIDEO_MULTIVIEW_MODE_MULTIVIEW_FRAME_BY_FRAME: c_int = 33; +pub const SPA_VIDEO_MULTIVIEW_MODE_SEPARATED: c_int = 34; +pub const enum_spa_video_multiview_mode = c_int; +pub const SPA_VIDEO_MULTIVIEW_FLAGS_NONE: c_int = 0; +pub const SPA_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST: c_int = 1; +pub const SPA_VIDEO_MULTIVIEW_FLAGS_LEFT_FLIPPED: c_int = 2; +pub const SPA_VIDEO_MULTIVIEW_FLAGS_LEFT_FLOPPED: c_int = 4; +pub const SPA_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLIPPED: c_int = 8; +pub const SPA_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLOPPED: c_int = 16; +pub const SPA_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT: c_int = 16384; +pub const SPA_VIDEO_MULTIVIEW_FLAGS_MIXED_MONO: c_int = 32768; +pub const enum_spa_video_multiview_flags = c_uint; +pub const SPA_VIDEO_FORMAT_UNKNOWN: c_int = 0; +pub const SPA_VIDEO_FORMAT_ENCODED: c_int = 1; +pub const SPA_VIDEO_FORMAT_I420: c_int = 2; +pub const SPA_VIDEO_FORMAT_YV12: c_int = 3; +pub const SPA_VIDEO_FORMAT_YUY2: c_int = 4; +pub const SPA_VIDEO_FORMAT_UYVY: c_int = 5; +pub const SPA_VIDEO_FORMAT_AYUV: c_int = 6; +pub const SPA_VIDEO_FORMAT_RGBx: c_int = 7; +pub const SPA_VIDEO_FORMAT_BGRx: c_int = 8; +pub const SPA_VIDEO_FORMAT_xRGB: c_int = 9; +pub const SPA_VIDEO_FORMAT_xBGR: c_int = 10; +pub const SPA_VIDEO_FORMAT_RGBA: c_int = 11; +pub const SPA_VIDEO_FORMAT_BGRA: c_int = 12; +pub const SPA_VIDEO_FORMAT_ARGB: c_int = 13; +pub const SPA_VIDEO_FORMAT_ABGR: c_int = 14; +pub const SPA_VIDEO_FORMAT_RGB: c_int = 15; +pub const SPA_VIDEO_FORMAT_BGR: c_int = 16; +pub const SPA_VIDEO_FORMAT_Y41B: c_int = 17; +pub const SPA_VIDEO_FORMAT_Y42B: c_int = 18; +pub const SPA_VIDEO_FORMAT_YVYU: c_int = 19; +pub const SPA_VIDEO_FORMAT_Y444: c_int = 20; +pub const SPA_VIDEO_FORMAT_v210: c_int = 21; +pub const SPA_VIDEO_FORMAT_v216: c_int = 22; +pub const SPA_VIDEO_FORMAT_NV12: c_int = 23; +pub const SPA_VIDEO_FORMAT_NV21: c_int = 24; +pub const SPA_VIDEO_FORMAT_GRAY8: c_int = 25; +pub const SPA_VIDEO_FORMAT_GRAY16_BE: c_int = 26; +pub const SPA_VIDEO_FORMAT_GRAY16_LE: c_int = 27; +pub const SPA_VIDEO_FORMAT_v308: c_int = 28; +pub const SPA_VIDEO_FORMAT_RGB16: c_int = 29; +pub const SPA_VIDEO_FORMAT_BGR16: c_int = 30; +pub const SPA_VIDEO_FORMAT_RGB15: c_int = 31; +pub const SPA_VIDEO_FORMAT_BGR15: c_int = 32; +pub const SPA_VIDEO_FORMAT_UYVP: c_int = 33; +pub const SPA_VIDEO_FORMAT_A420: c_int = 34; +pub const SPA_VIDEO_FORMAT_RGB8P: c_int = 35; +pub const SPA_VIDEO_FORMAT_YUV9: c_int = 36; +pub const SPA_VIDEO_FORMAT_YVU9: c_int = 37; +pub const SPA_VIDEO_FORMAT_IYU1: c_int = 38; +pub const SPA_VIDEO_FORMAT_ARGB64: c_int = 39; +pub const SPA_VIDEO_FORMAT_AYUV64: c_int = 40; +pub const SPA_VIDEO_FORMAT_r210: c_int = 41; +pub const SPA_VIDEO_FORMAT_I420_10BE: c_int = 42; +pub const SPA_VIDEO_FORMAT_I420_10LE: c_int = 43; +pub const SPA_VIDEO_FORMAT_I422_10BE: c_int = 44; +pub const SPA_VIDEO_FORMAT_I422_10LE: c_int = 45; +pub const SPA_VIDEO_FORMAT_Y444_10BE: c_int = 46; +pub const SPA_VIDEO_FORMAT_Y444_10LE: c_int = 47; +pub const SPA_VIDEO_FORMAT_GBR: c_int = 48; +pub const SPA_VIDEO_FORMAT_GBR_10BE: c_int = 49; +pub const SPA_VIDEO_FORMAT_GBR_10LE: c_int = 50; +pub const SPA_VIDEO_FORMAT_NV16: c_int = 51; +pub const SPA_VIDEO_FORMAT_NV24: c_int = 52; +pub const SPA_VIDEO_FORMAT_NV12_64Z32: c_int = 53; +pub const SPA_VIDEO_FORMAT_A420_10BE: c_int = 54; +pub const SPA_VIDEO_FORMAT_A420_10LE: c_int = 55; +pub const SPA_VIDEO_FORMAT_A422_10BE: c_int = 56; +pub const SPA_VIDEO_FORMAT_A422_10LE: c_int = 57; +pub const SPA_VIDEO_FORMAT_A444_10BE: c_int = 58; +pub const SPA_VIDEO_FORMAT_A444_10LE: c_int = 59; +pub const SPA_VIDEO_FORMAT_NV61: c_int = 60; +pub const SPA_VIDEO_FORMAT_P010_10BE: c_int = 61; +pub const SPA_VIDEO_FORMAT_P010_10LE: c_int = 62; +pub const SPA_VIDEO_FORMAT_IYU2: c_int = 63; +pub const SPA_VIDEO_FORMAT_VYUY: c_int = 64; +pub const SPA_VIDEO_FORMAT_GBRA: c_int = 65; +pub const SPA_VIDEO_FORMAT_GBRA_10BE: c_int = 66; +pub const SPA_VIDEO_FORMAT_GBRA_10LE: c_int = 67; +pub const SPA_VIDEO_FORMAT_GBR_12BE: c_int = 68; +pub const SPA_VIDEO_FORMAT_GBR_12LE: c_int = 69; +pub const SPA_VIDEO_FORMAT_GBRA_12BE: c_int = 70; +pub const SPA_VIDEO_FORMAT_GBRA_12LE: c_int = 71; +pub const SPA_VIDEO_FORMAT_I420_12BE: c_int = 72; +pub const SPA_VIDEO_FORMAT_I420_12LE: c_int = 73; +pub const SPA_VIDEO_FORMAT_I422_12BE: c_int = 74; +pub const SPA_VIDEO_FORMAT_I422_12LE: c_int = 75; +pub const SPA_VIDEO_FORMAT_Y444_12BE: c_int = 76; +pub const SPA_VIDEO_FORMAT_Y444_12LE: c_int = 77; +pub const SPA_VIDEO_FORMAT_RGBA_F16: c_int = 78; +pub const SPA_VIDEO_FORMAT_RGBA_F32: c_int = 79; +pub const SPA_VIDEO_FORMAT_xRGB_210LE: c_int = 80; +pub const SPA_VIDEO_FORMAT_xBGR_210LE: c_int = 81; +pub const SPA_VIDEO_FORMAT_RGBx_102LE: c_int = 82; +pub const SPA_VIDEO_FORMAT_BGRx_102LE: c_int = 83; +pub const SPA_VIDEO_FORMAT_ARGB_210LE: c_int = 84; +pub const SPA_VIDEO_FORMAT_ABGR_210LE: c_int = 85; +pub const SPA_VIDEO_FORMAT_RGBA_102LE: c_int = 86; +pub const SPA_VIDEO_FORMAT_BGRA_102LE: c_int = 87; +pub const SPA_VIDEO_FORMAT_DSP_F32: c_int = 79; +pub const enum_spa_video_format = c_uint; +pub const SPA_VIDEO_FLAG_NONE: c_int = 0; +pub const SPA_VIDEO_FLAG_VARIABLE_FPS: c_int = 1; +pub const SPA_VIDEO_FLAG_PREMULTIPLIED_ALPHA: c_int = 2; +pub const SPA_VIDEO_FLAG_MODIFIER: c_int = 4; +pub const SPA_VIDEO_FLAG_MODIFIER_FIXATION_REQUIRED: c_int = 8; +pub const enum_spa_video_flags = c_uint; +pub const SPA_VIDEO_INTERLACE_MODE_PROGRESSIVE: c_int = 0; +pub const SPA_VIDEO_INTERLACE_MODE_INTERLEAVED: c_int = 1; +pub const SPA_VIDEO_INTERLACE_MODE_MIXED: c_int = 2; +pub const SPA_VIDEO_INTERLACE_MODE_FIELDS: c_int = 3; +pub const enum_spa_video_interlace_mode = c_uint; +pub const struct_spa_video_info_raw = extern struct { + format: enum_spa_video_format = @import("std").mem.zeroes(enum_spa_video_format), + flags: u32 = @import("std").mem.zeroes(u32), + modifier: u64 = @import("std").mem.zeroes(u64), + size: struct_spa_rectangle = @import("std").mem.zeroes(struct_spa_rectangle), + framerate: struct_spa_fraction = @import("std").mem.zeroes(struct_spa_fraction), + max_framerate: struct_spa_fraction = @import("std").mem.zeroes(struct_spa_fraction), + views: u32 = @import("std").mem.zeroes(u32), + interlace_mode: enum_spa_video_interlace_mode = @import("std").mem.zeroes(enum_spa_video_interlace_mode), + pixel_aspect_ratio: struct_spa_fraction = @import("std").mem.zeroes(struct_spa_fraction), + multiview_mode: enum_spa_video_multiview_mode = @import("std").mem.zeroes(enum_spa_video_multiview_mode), + multiview_flags: enum_spa_video_multiview_flags = @import("std").mem.zeroes(enum_spa_video_multiview_flags), + chroma_site: enum_spa_video_chroma_site = @import("std").mem.zeroes(enum_spa_video_chroma_site), + color_range: enum_spa_video_color_range = @import("std").mem.zeroes(enum_spa_video_color_range), + color_matrix: enum_spa_video_color_matrix = @import("std").mem.zeroes(enum_spa_video_color_matrix), + transfer_function: enum_spa_video_transfer_function = @import("std").mem.zeroes(enum_spa_video_transfer_function), + color_primaries: enum_spa_video_color_primaries = @import("std").mem.zeroes(enum_spa_video_color_primaries), +}; +pub const struct_spa_video_info_dsp = extern struct { + format: enum_spa_video_format = @import("std").mem.zeroes(enum_spa_video_format), + flags: u32 = @import("std").mem.zeroes(u32), + modifier: u64 = @import("std").mem.zeroes(u64), +}; +pub const SPA_H264_STREAM_FORMAT_UNKNOWN: c_int = 0; +pub const SPA_H264_STREAM_FORMAT_AVC: c_int = 1; +pub const SPA_H264_STREAM_FORMAT_AVC3: c_int = 2; +pub const SPA_H264_STREAM_FORMAT_BYTESTREAM: c_int = 3; +pub const enum_spa_h264_stream_format = c_uint; +pub const SPA_H264_ALIGNMENT_UNKNOWN: c_int = 0; +pub const SPA_H264_ALIGNMENT_AU: c_int = 1; +pub const SPA_H264_ALIGNMENT_NAL: c_int = 2; +pub const enum_spa_h264_alignment = c_uint; +pub const struct_spa_video_info_h264 = extern struct { + size: struct_spa_rectangle = @import("std").mem.zeroes(struct_spa_rectangle), + framerate: struct_spa_fraction = @import("std").mem.zeroes(struct_spa_fraction), + max_framerate: struct_spa_fraction = @import("std").mem.zeroes(struct_spa_fraction), + stream_format: enum_spa_h264_stream_format = @import("std").mem.zeroes(enum_spa_h264_stream_format), + alignment: enum_spa_h264_alignment = @import("std").mem.zeroes(enum_spa_h264_alignment), +}; +pub const struct_spa_video_info_mjpg = extern struct { + size: struct_spa_rectangle = @import("std").mem.zeroes(struct_spa_rectangle), + framerate: struct_spa_fraction = @import("std").mem.zeroes(struct_spa_fraction), + max_framerate: struct_spa_fraction = @import("std").mem.zeroes(struct_spa_fraction), +}; +const union_unnamed_37 = extern union { + raw: struct_spa_video_info_raw, + dsp: struct_spa_video_info_dsp, + h264: struct_spa_video_info_h264, + mjpg: struct_spa_video_info_mjpg, +}; +pub const struct_spa_video_info = extern struct { + media_type: u32 = @import("std").mem.zeroes(u32), + media_subtype: u32 = @import("std").mem.zeroes(u32), + info: union_unnamed_37 = @import("std").mem.zeroes(union_unnamed_37), +}; +pub fn spa_pod_is_inside(arg_pod: ?*const anyopaque, arg_size: u32, arg_iter: ?*const anyopaque) callconv(.c) bool { + var pod = arg_pod; + _ = &pod; + var size = arg_size; + _ = &size; + var iter = arg_iter; + _ = &iter; + var remaining: usize = undefined; + _ = &remaining; + return (@as(c_int, @intFromBool(spa_ptr_inside_and_aligned(pod, @as(usize, @bitCast(@as(c_ulong, size))), iter, @sizeOf(struct_spa_pod), @alignOf(struct_spa_pod), &remaining))) != 0) and (remaining >= @as(usize, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(iter)))).*.size)))); +} +pub fn spa_pod_next(arg_iter: ?*const anyopaque) callconv(.c) ?*anyopaque { + var iter = arg_iter; + _ = &iter; + return @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(iter))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast((((@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(iter)))).*.size)))) -% @as(u64, @bitCast(@as(c_long, @as(c_int, 1))))) | @as(@TypeOf(@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(iter)))).*.size)))), @bitCast(@as(c_long, @as(c_int, 8) - @as(c_int, 1))))) +% @as(u64, @bitCast(@as(c_long, @as(c_int, 1)))))))))); +} +pub fn spa_pod_prop_first(arg_body: [*c]const struct_spa_pod_object_body) callconv(.c) [*c]struct_spa_pod_prop { + var body = arg_body; + _ = &body; + return @as([*c]struct_spa_pod_prop, @ptrFromInt(@as(usize, @intCast(@intFromPtr(body))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod_object_body))))))); +} +pub fn spa_pod_prop_is_inside(arg_body: [*c]const struct_spa_pod_object_body, arg_size: u32, arg_iter: [*c]const struct_spa_pod_prop) callconv(.c) bool { + var body = arg_body; + _ = &body; + var size = arg_size; + _ = &size; + var iter = arg_iter; + _ = &iter; + var remaining: usize = undefined; + _ = &remaining; + return (@as(c_int, @intFromBool(spa_ptr_inside_and_aligned(@as(?*const anyopaque, @ptrCast(body)), @as(usize, @bitCast(@as(c_ulong, size))), @as(?*const anyopaque, @ptrCast(iter)), @sizeOf(struct_spa_pod_prop), @alignOf(struct_spa_pod_prop), &remaining))) != 0) and (remaining >= @as(usize, @bitCast(@as(c_ulong, iter.*.value.size)))); +} +pub fn spa_pod_prop_next(arg_iter: [*c]const struct_spa_pod_prop) callconv(.c) [*c]struct_spa_pod_prop { + var iter = arg_iter; + _ = &iter; + return @as([*c]struct_spa_pod_prop, @ptrFromInt(@as(usize, @intCast(@intFromPtr(iter))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast((((@sizeOf(struct_spa_pod_prop) +% @as(c_ulong, @bitCast(@as(c_ulong, iter.*.value.size)))) -% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1))))) | @as(@TypeOf(@sizeOf(struct_spa_pod_prop) +% @as(c_ulong, @bitCast(@as(c_ulong, iter.*.value.size)))), @bitCast(@as(c_long, @as(c_int, 8) - @as(c_int, 1))))) +% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))))); +} +pub fn spa_pod_control_first(arg_body: [*c]const struct_spa_pod_sequence_body) callconv(.c) [*c]struct_spa_pod_control { + var body = arg_body; + _ = &body; + return @as([*c]struct_spa_pod_control, @ptrFromInt(@as(usize, @intCast(@intFromPtr(body))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod_sequence_body))))))); +} +pub fn spa_pod_control_is_inside(arg_body: [*c]const struct_spa_pod_sequence_body, arg_size: u32, arg_iter: [*c]const struct_spa_pod_control) callconv(.c) bool { + var body = arg_body; + _ = &body; + var size = arg_size; + _ = &size; + var iter = arg_iter; + _ = &iter; + var remaining: usize = undefined; + _ = &remaining; + return (@as(c_int, @intFromBool(spa_ptr_inside_and_aligned(@as(?*const anyopaque, @ptrCast(body)), @as(usize, @bitCast(@as(c_ulong, size))), @as(?*const anyopaque, @ptrCast(iter)), @sizeOf(struct_spa_pod_control), @alignOf(struct_spa_pod_control), &remaining))) != 0) and (remaining >= @as(usize, @bitCast(@as(c_ulong, iter.*.value.size)))); +} +pub fn spa_pod_control_next(arg_iter: [*c]const struct_spa_pod_control) callconv(.c) [*c]struct_spa_pod_control { + var iter = arg_iter; + _ = &iter; + return @as([*c]struct_spa_pod_control, @ptrFromInt(@as(usize, @intCast(@intFromPtr(iter))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast((((@sizeOf(struct_spa_pod_control) +% @as(c_ulong, @bitCast(@as(c_ulong, iter.*.value.size)))) -% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1))))) | @as(@TypeOf(@sizeOf(struct_spa_pod_control) +% @as(c_ulong, @bitCast(@as(c_ulong, iter.*.value.size)))), @bitCast(@as(c_long, @as(c_int, 8) - @as(c_int, 1))))) +% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))))))); +} +pub fn spa_pod_from_data(arg_data: ?*anyopaque, arg_maxsize: usize, arg_offset: off_t, arg_size: usize) callconv(.c) ?*anyopaque { + var data = arg_data; + _ = &data; + var maxsize = arg_maxsize; + _ = &maxsize; + var offset = arg_offset; + _ = &offset; + var size = arg_size; + _ = &size; + var pod: struct_spa_pod = undefined; + _ = &pod; + var body: ?*const anyopaque = undefined; + _ = &body; + if (spa_pod_body_from_data(data, maxsize, offset, size, &pod, &body) < @as(c_int, 0)) return @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); + return @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(offset)))))); +} +pub fn spa_pod_get_bool(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]bool) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var value = arg_value; + _ = &value; + return spa_pod_body_get_bool(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); +} +pub fn spa_pod_get_id(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]u32) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var value = arg_value; + _ = &value; + return spa_pod_body_get_id(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); +} +pub fn spa_pod_get_int(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]i32) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var value = arg_value; + _ = &value; + return spa_pod_body_get_int(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); +} +pub fn spa_pod_get_long(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]i64) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var value = arg_value; + _ = &value; + return spa_pod_body_get_long(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); +} +pub fn spa_pod_get_float(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]f32) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var value = arg_value; + _ = &value; + return spa_pod_body_get_float(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); +} +pub fn spa_pod_get_double(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]f64) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var value = arg_value; + _ = &value; + return spa_pod_body_get_double(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); +} +pub fn spa_pod_get_string(arg_pod: [*c]const struct_spa_pod, arg_value: [*c][*c]const u8) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var value = arg_value; + _ = &value; + return spa_pod_body_get_string(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); +} +pub fn spa_pod_copy_string(arg_pod: [*c]const struct_spa_pod, arg_maxlen: usize, arg_dest: [*c]u8) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var maxlen = arg_maxlen; + _ = &maxlen; + var dest = arg_dest; + _ = &dest; + return spa_pod_body_copy_string(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), dest, maxlen); +} +pub fn spa_pod_get_bytes(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]?*const anyopaque, arg_len: [*c]u32) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var value = arg_value; + _ = &value; + var len = arg_len; + _ = &len; + return spa_pod_body_get_bytes(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value, len); +} +pub fn spa_pod_get_pointer(arg_pod: [*c]const struct_spa_pod, arg_type: [*c]u32, arg_value: [*c]?*const anyopaque) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var @"type" = arg_type; + _ = &@"type"; + var value = arg_value; + _ = &value; + return spa_pod_body_get_pointer(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), @"type", value); +} +pub fn spa_pod_get_fd(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]i64) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var value = arg_value; + _ = &value; + return spa_pod_body_get_fd(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); +} +pub fn spa_pod_get_rectangle(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]struct_spa_rectangle) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var value = arg_value; + _ = &value; + return spa_pod_body_get_rectangle(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); +} +pub fn spa_pod_get_fraction(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]struct_spa_fraction) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var value = arg_value; + _ = &value; + return spa_pod_body_get_fraction(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); +} +pub fn spa_pod_get_array_full(arg_pod: [*c]const struct_spa_pod, arg_n_values: [*c]u32, arg_val_size: [*c]u32, arg_val_type: [*c]u32) callconv(.c) ?*anyopaque { + var pod = arg_pod; + _ = &pod; + var n_values = arg_n_values; + _ = &n_values; + var val_size = arg_val_size; + _ = &val_size; + var val_type = arg_val_type; + _ = &val_type; + return @as(?*anyopaque, @ptrCast(@constCast(@volatileCast(spa_pod_body_get_array_values(pod, @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), n_values, val_size, val_type))))); +} +pub fn spa_pod_get_array(arg_pod: [*c]const struct_spa_pod, arg_n_values: [*c]u32) callconv(.c) ?*anyopaque { + var pod = arg_pod; + _ = &pod; + var n_values = arg_n_values; + _ = &n_values; + var size: u32 = undefined; + _ = &size; + var @"type": u32 = undefined; + _ = &@"type"; + return spa_pod_get_array_full(pod, n_values, &size, &@"type"); +} +pub fn spa_pod_copy_array_full(arg_pod: [*c]const struct_spa_pod, arg_type: u32, arg_size: u32, arg_values: ?*anyopaque, arg_max_values: u32) callconv(.c) u32 { + var pod = arg_pod; + _ = &pod; + var @"type" = arg_type; + _ = &@"type"; + var size = arg_size; + _ = &size; + var values = arg_values; + _ = &values; + var max_values = arg_max_values; + _ = &max_values; + var n_values: u32 = undefined; + _ = &n_values; + var val_size: u32 = undefined; + _ = &val_size; + var val_type: u32 = undefined; + _ = &val_type; + var v: ?*const anyopaque = spa_pod_get_array_full(pod, &n_values, &val_size, &val_type); + _ = &v; + if ((((v == @as(?*const anyopaque, @ptrCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0)))))) or (max_values == @as(u32, @bitCast(@as(c_int, 0))))) or (val_type != @"type")) or (val_size != size)) return 0; + n_values = blk: { + var _min_a: @TypeOf(n_values) = n_values; + _ = &_min_a; + var _min_b: @TypeOf(max_values) = max_values; + _ = &_min_b; + break :blk if (__builtin_expect(@as(c_long, @intFromBool(!!(_min_a <= _min_b))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) _min_a else _min_b; + }; + _ = memcpy(values, v, @as(c_ulong, @bitCast(@as(c_ulong, val_size *% n_values)))); + return n_values; +} +pub fn spa_pod_get_values(arg_pod: [*c]const struct_spa_pod, arg_n_vals: [*c]u32, arg_choice: [*c]u32) callconv(.c) [*c]struct_spa_pod { + var pod = arg_pod; + _ = &pod; + var n_vals = arg_n_vals; + _ = &n_vals; + var choice = arg_choice; + _ = &choice; + if (spa_pod_is_choice(pod) != 0) { + var p: [*c]const struct_spa_pod_choice = @as([*c]const struct_spa_pod_choice, @ptrCast(@alignCast(pod))); + _ = &p; + var @"type": u32 = undefined; + _ = &@"type"; + var size: u32 = undefined; + _ = &size; + _ = spa_pod_choice_body_get_values(p, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(p))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), n_vals, choice, &size, &@"type"); + return @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(&p.*.body.child)))); + } else { + n_vals.* = 1; + choice.* = @as(u32, @bitCast(SPA_CHOICE_None)); + return @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))); + } + return null; +} +pub fn spa_pod_is_object_type(arg_pod: [*c]const struct_spa_pod, arg_type: u32) callconv(.c) bool { + var pod = arg_pod; + _ = &pod; + var @"type" = arg_type; + _ = &@"type"; + return ((pod != null) and (spa_pod_is_object(pod) != 0)) and (@as([*c]struct_spa_pod_object, @ptrCast(@constCast(@volatileCast(pod)))).*.body.type == @"type"); +} +pub fn spa_pod_is_object_id(arg_pod: [*c]const struct_spa_pod, arg_id: u32) callconv(.c) bool { + var pod = arg_pod; + _ = &pod; + var id = arg_id; + _ = &id; + return ((pod != null) and (spa_pod_is_object(pod) != 0)) and (@as([*c]struct_spa_pod_object, @ptrCast(@constCast(@volatileCast(pod)))).*.body.id == id); +} +pub fn spa_pod_object_find_prop(arg_pod: [*c]const struct_spa_pod_object, arg_start: [*c]const struct_spa_pod_prop, arg_key: u32) callconv(.c) [*c]const struct_spa_pod_prop { + var pod = arg_pod; + _ = &pod; + var start = arg_start; + _ = &start; + var key = arg_key; + _ = &key; + var first: [*c]const struct_spa_pod_prop = undefined; + _ = &first; + var res: [*c]const struct_spa_pod_prop = undefined; + _ = &res; + first = spa_pod_prop_first(&pod.*.body); + start = if (start != null) @as([*c]const struct_spa_pod_prop, @ptrCast(@alignCast(spa_pod_prop_next(start)))) else first; + { + res = start; + while (spa_pod_prop_is_inside(&pod.*.body, pod.*.pod.size, res)) : (res = spa_pod_prop_next(res)) { + if (res.*.key == key) return res; + } + } + { + res = first; + while (res != start) : (res = spa_pod_prop_next(res)) { + if (res.*.key == key) return res; + } + } + return null; +} +pub fn spa_pod_find_prop(arg_pod: [*c]const struct_spa_pod, arg_start: [*c]const struct_spa_pod_prop, arg_key: u32) callconv(.c) [*c]const struct_spa_pod_prop { + var pod = arg_pod; + _ = &pod; + var start = arg_start; + _ = &start; + var key = arg_key; + _ = &key; + if (!(spa_pod_is_object(pod) != 0)) return null; + return spa_pod_object_find_prop(@as([*c]const struct_spa_pod_object, @ptrCast(@alignCast(pod))), start, key); +} +pub fn spa_pod_object_has_props(arg_pod: [*c]const struct_spa_pod_object) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var res: [*c]struct_spa_pod_prop = undefined; + _ = &res; + { + res = spa_pod_prop_first(&pod.*.body); + while (spa_pod_prop_is_inside(&pod.*.body, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size, res)) : (res = spa_pod_prop_next(res)) return 1; + } + return 0; +} +pub fn spa_pod_object_fixate(arg_pod: [*c]struct_spa_pod_object) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var res: [*c]struct_spa_pod_prop = undefined; + _ = &res; + { + res = spa_pod_prop_first(&pod.*.body); + while (spa_pod_prop_is_inside(&pod.*.body, @as([*c]struct_spa_pod, @ptrCast(@alignCast(pod))).*.size, res)) : (res = spa_pod_prop_next(res)) { + if ((spa_pod_is_choice(&res.*.value) != 0) and !((res.*.flags & (@as(c_uint, 1) << @intCast(4))) == (@as(c_uint, 1) << @intCast(4)))) { + @as([*c]struct_spa_pod_choice, @ptrCast(@alignCast(&res.*.value))).*.body.type = @as(u32, @bitCast(SPA_CHOICE_None)); + } + } + } + return 0; +} +pub fn spa_pod_object_is_fixated(arg_pod: [*c]const struct_spa_pod_object) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + var res: [*c]struct_spa_pod_prop = undefined; + _ = &res; + { + res = spa_pod_prop_first(&pod.*.body); + while (spa_pod_prop_is_inside(&pod.*.body, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size, res)) : (res = spa_pod_prop_next(res)) { + if ((spa_pod_is_choice(&res.*.value) != 0) and (@as([*c]struct_spa_pod_choice, @ptrCast(@alignCast(&res.*.value))).*.body.type != @as(u32, @bitCast(SPA_CHOICE_None)))) return 0; + } + } + return 1; +} +pub fn spa_pod_fixate(arg_pod: [*c]struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + if (!(spa_pod_is_object(pod) != 0)) return -@as(c_int, 22); + return spa_pod_object_fixate(@as([*c]struct_spa_pod_object, @ptrCast(@alignCast(pod)))); +} +pub fn spa_pod_is_fixated(arg_pod: [*c]const struct_spa_pod) callconv(.c) c_int { + var pod = arg_pod; + _ = &pod; + if (!(spa_pod_is_object(pod) != 0)) return -@as(c_int, 22); + return spa_pod_object_is_fixated(@as([*c]const struct_spa_pod_object, @ptrCast(@alignCast(pod)))); +} +pub const struct_spa_pod_builder_state = extern struct { + offset: u32 = @import("std").mem.zeroes(u32), + flags: u32 = @import("std").mem.zeroes(u32), + frame: [*c]struct_spa_pod_frame = @import("std").mem.zeroes([*c]struct_spa_pod_frame), +}; +pub const struct_spa_pod_builder = extern struct { + data: ?*anyopaque = @import("std").mem.zeroes(?*anyopaque), + size: u32 = @import("std").mem.zeroes(u32), + _padding: u32 = @import("std").mem.zeroes(u32), + state: struct_spa_pod_builder_state = @import("std").mem.zeroes(struct_spa_pod_builder_state), + callbacks: struct_spa_callbacks = @import("std").mem.zeroes(struct_spa_callbacks), +}; +pub const struct_spa_pod_builder_callbacks = extern struct { + version: u32 = @import("std").mem.zeroes(u32), + overflow: ?*const fn (?*anyopaque, u32) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32) callconv(.c) c_int), +}; +pub fn spa_pod_builder_get_state(arg_builder: [*c]struct_spa_pod_builder, arg_state: [*c]struct_spa_pod_builder_state) callconv(.c) void { + var builder = arg_builder; + _ = &builder; + var state = arg_state; + _ = &state; + state.* = builder.*.state; +} +pub fn spa_pod_builder_corrupted(arg_builder: [*c]const struct_spa_pod_builder) callconv(.c) bool { + var builder = arg_builder; + _ = &builder; + return builder.*.state.offset > builder.*.size; +} +pub fn spa_pod_builder_set_callbacks(arg_builder: [*c]struct_spa_pod_builder, arg_callbacks: [*c]const struct_spa_pod_builder_callbacks, arg_data: ?*anyopaque) callconv(.c) void { + var builder = arg_builder; + _ = &builder; + var callbacks = arg_callbacks; + _ = &callbacks; + var data = arg_data; + _ = &data; + builder.*.callbacks = struct_spa_callbacks{ + .funcs = @as(?*const anyopaque, @ptrCast(callbacks)), + .data = data, + }; +} +pub fn spa_pod_builder_reset(arg_builder: [*c]struct_spa_pod_builder, arg_state: [*c]struct_spa_pod_builder_state) callconv(.c) void { + var builder = arg_builder; + _ = &builder; + var state = arg_state; + _ = &state; + var f: [*c]struct_spa_pod_frame = undefined; + _ = &f; + var size: u32 = builder.*.state.offset -% state.*.offset; + _ = &size; + builder.*.state = state.*; + { + f = builder.*.state.frame; + while (f != null) : (f = f.*.parent) { + f.*.pod.size -%= blk: { + var _min_a: @TypeOf(size) = size; + _ = &_min_a; + var _min_b: @TypeOf(f.*.pod.size) = f.*.pod.size; + _ = &_min_b; + break :blk if (__builtin_expect(@as(c_long, @intFromBool(!!(_min_a <= _min_b))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) _min_a else _min_b; + }; + } + } +} +pub fn spa_pod_builder_init(arg_builder: [*c]struct_spa_pod_builder, arg_data: ?*anyopaque, arg_size: u32) callconv(.c) void { + var builder = arg_builder; + _ = &builder; + var data = arg_data; + _ = &data; + var size = arg_size; + _ = &size; + builder.* = struct_spa_pod_builder{ + .data = data, + .size = size, + ._padding = @as(u32, @bitCast(@as(c_int, 0))), + .state = struct_spa_pod_builder_state{ + .offset = @as(u32, @bitCast(@as(c_int, 0))), + .flags = @as(u32, @bitCast(@as(c_int, 0))), + .frame = null, + }, + .callbacks = struct_spa_callbacks{ + .funcs = null, + .data = @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))), + }, + }; +} +pub fn spa_pod_builder_deref_fallback(arg_builder: [*c]struct_spa_pod_builder, arg_offset: u32, arg_fallback: [*c]struct_spa_pod) callconv(.c) [*c]struct_spa_pod { + var builder = arg_builder; + _ = &builder; + var offset = arg_offset; + _ = &offset; + var fallback = arg_fallback; + _ = &fallback; + var size: u32 = builder.*.size; + _ = &size; + if ((@as(c_ulong, @bitCast(@as(c_ulong, offset))) +% @as(c_ulong, 8)) <= @as(c_ulong, @bitCast(@as(c_ulong, size)))) { + var pod: [*c]struct_spa_pod = @as([*c]struct_spa_pod, @ptrFromInt(@as(usize, @intCast(@intFromPtr(builder.*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, offset))))))); + _ = &pod; + if (((@as(u64, @bitCast(@as(c_ulong, offset))) +% (@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, pod.*.size))))) <= @as(u64, @bitCast(@as(c_ulong, size)))) and (pod.*.size < (@as(c_uint, 1) << @intCast(20)))) return pod; + } + return fallback; +} +pub fn spa_pod_builder_deref(arg_builder: [*c]struct_spa_pod_builder, arg_offset: u32) callconv(.c) [*c]struct_spa_pod { + var builder = arg_builder; + _ = &builder; + var offset = arg_offset; + _ = &offset; + return spa_pod_builder_deref_fallback(builder, offset, null); +} +pub fn spa_pod_builder_frame(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame) callconv(.c) [*c]struct_spa_pod { + var builder = arg_builder; + _ = &builder; + var frame = arg_frame; + _ = &frame; + if ((@as(u64, @bitCast(@as(c_ulong, frame.*.offset))) +% (@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, (&frame.*.pod).*.size))))) <= @as(u64, @bitCast(@as(c_ulong, builder.*.size)))) return @as([*c]struct_spa_pod, @ptrFromInt(@as(usize, @intCast(@intFromPtr(builder.*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, frame.*.offset))))))); + return null; +} +pub fn spa_pod_builder_push(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame, arg_pod: [*c]const struct_spa_pod, arg_offset: u32) callconv(.c) void { + var builder = arg_builder; + _ = &builder; + var frame = arg_frame; + _ = &frame; + var pod = arg_pod; + _ = &pod; + var offset = arg_offset; + _ = &offset; + frame.*.pod = pod.*; + frame.*.offset = offset; + frame.*.parent = builder.*.state.frame; + frame.*.flags = builder.*.state.flags; + builder.*.state.frame = frame; + if ((frame.*.pod.type == @as(u32, @bitCast(SPA_TYPE_Array))) or (frame.*.pod.type == @as(u32, @bitCast(SPA_TYPE_Choice)))) { + builder.*.state.flags = @as(u32, @bitCast((@as(c_int, 1) << @intCast(1)) | (@as(c_int, 1) << @intCast(0)))); + } +} +pub fn spa_pod_builder_raw(arg_builder: [*c]struct_spa_pod_builder, arg_data: ?*const anyopaque, arg_size: u32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var data = arg_data; + _ = &data; + var size = arg_size; + _ = &size; + var res: c_int = 0; + _ = &res; + var f: [*c]struct_spa_pod_frame = undefined; + _ = &f; + var offset: u32 = builder.*.state.offset; + _ = &offset; + var data_offset: usize = @as(usize, @bitCast(@as(c_long, -@as(c_int, 1)))); + _ = &data_offset; + var total_size: u64 = @as(u64, @bitCast(@as(c_ulong, offset))) +% @as(u64, @bitCast(@as(c_ulong, size))); + _ = &total_size; + if (total_size > @as(u64, @bitCast(@as(c_ulong, builder.*.size)))) { + if (total_size > @as(u64, @bitCast(@as(c_ulong, @as(c_uint, 4294967295))))) return -@as(c_int, 28); + if (spa_ptrinside(builder.*.data, @as(usize, @bitCast(@as(c_ulong, builder.*.size))), data, @as(usize, @bitCast(@as(c_ulong, size))), null)) { + data_offset = @as(usize, @bitCast(@as(isize, @intCast(@intFromPtr(data))) - @as(isize, @intCast(@intFromPtr(builder.*.data))))); + } + res = -@as(c_int, 28); + if (offset <= builder.*.size) { + { + var _f: [*c]const struct_spa_pod_builder_callbacks = @as([*c]const struct_spa_pod_builder_callbacks, @ptrCast(@alignCast((&builder.*.callbacks).*.funcs))); + _ = &_f; + if (__builtin_expect(@as(c_long, @intFromBool(!!(((_f != null) and ((@as(c_int, 0) == @as(c_int, 0)) or (_f.*.version > @as(u32, @bitCast(@as(c_int, 0) - @as(c_int, 1)))))) and (_f.*.overflow != null)))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) { + res = _f.*.overflow.?((&builder.*.callbacks).*.data, @as(u32, @bitCast(@as(c_uint, @truncate(total_size))))); + } + _ = &res; + } + } + } + if ((res == @as(c_int, 0)) and (data != null)) { + if (data_offset != @as(usize, @bitCast(@as(c_long, -@as(c_int, 1))))) { + data = @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(builder.*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(data_offset)))))); + } + _ = memcpy(@as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(builder.*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, offset))))))), data, @as(c_ulong, @bitCast(@as(c_ulong, size)))); + } + builder.*.state.offset = @as(u32, @bitCast(@as(c_uint, @truncate(total_size)))); + { + f = builder.*.state.frame; + while (f != null) : (f = f.*.parent) { + f.*.pod.size +%= size; + } + } + return res; +} +pub fn spa_pod_builder_remove(arg_builder: [*c]struct_spa_pod_builder, arg_size: u32) callconv(.c) void { + var builder = arg_builder; + _ = &builder; + var size = arg_size; + _ = &size; + var f: [*c]struct_spa_pod_frame = undefined; + _ = &f; + builder.*.state.offset -%= blk: { + var _min_a: @TypeOf(size) = size; + _ = &_min_a; + var _min_b: @TypeOf(builder.*.state.offset) = builder.*.state.offset; + _ = &_min_b; + break :blk if (__builtin_expect(@as(c_long, @intFromBool(!!(_min_a <= _min_b))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) _min_a else _min_b; + }; + { + f = builder.*.state.frame; + while (f != null) : (f = f.*.parent) { + f.*.pod.size -%= blk: { + var _min_a: @TypeOf(size) = size; + _ = &_min_a; + var _min_b: @TypeOf(f.*.pod.size) = f.*.pod.size; + _ = &_min_b; + break :blk if (__builtin_expect(@as(c_long, @intFromBool(!!(_min_a <= _min_b))), @as(c_long, @bitCast(@as(c_long, @as(c_int, 1))))) != 0) _min_a else _min_b; + }; + } + } +} +pub fn spa_pod_builder_pad(arg_builder: [*c]struct_spa_pod_builder, arg_size: u32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var size = arg_size; + _ = &size; + var zeroes: u64 = 0; + _ = &zeroes; + if (builder.*.state.flags == @as(u32, @bitCast(@as(c_int, 1) << @intCast(0)))) return 0; + size = (((size -% @as(u32, @bitCast(@as(c_int, 1)))) | @as(@TypeOf(size), @bitCast(@as(c_int, 8) - @as(c_int, 1)))) +% @as(u32, @bitCast(@as(c_int, 1)))) -% size; + return if (size != 0) spa_pod_builder_raw(builder, @as(?*const anyopaque, @ptrCast(&zeroes)), size) else @as(c_int, 0); +} +pub fn spa_pod_builder_raw_padded(arg_builder: [*c]struct_spa_pod_builder, arg_data: ?*const anyopaque, arg_size: u32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var data = arg_data; + _ = &data; + var size = arg_size; + _ = &size; + var r: c_int = undefined; + _ = &r; + var res: c_int = spa_pod_builder_raw(builder, data, size); + _ = &res; + if ((blk: { + const tmp = spa_pod_builder_pad(builder, size); + r = tmp; + break :blk tmp; + }) < @as(c_int, 0)) { + res = r; + } + return res; +} +pub fn spa_pod_builder_pop(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame) callconv(.c) ?*anyopaque { + var builder = arg_builder; + _ = &builder; + var frame = arg_frame; + _ = &frame; + var pod: [*c]struct_spa_pod = undefined; + _ = &pod; + if ((builder.*.state.flags & @as(u32, @bitCast(@as(c_int, 1) << @intCast(1)))) == @as(u32, @bitCast(@as(c_int, 1) << @intCast(1)))) { + const p: struct_spa_pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_int, 0))), + .type = @as(u32, @bitCast(SPA_TYPE_None)), + }; + _ = &p; + _ = spa_pod_builder_raw(builder, @as(?*const anyopaque, @ptrCast(&p)), @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod)))))); + } + if ((blk: { + const tmp = spa_pod_builder_frame(builder, frame); + pod = tmp; + break :blk tmp; + }) != @as([*c]struct_spa_pod, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + pod.* = frame.*.pod; + } + builder.*.state.frame = frame.*.parent; + builder.*.state.flags = frame.*.flags; + _ = spa_pod_builder_pad(builder, builder.*.state.offset); + return @as(?*anyopaque, @ptrCast(pod)); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:27:50: warning: ignoring StaticAssert declaration +pub fn spa_pod_builder_primitive_body(arg_builder: [*c]struct_spa_pod_builder, arg_p: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_body_size: u32, arg_suffix: [*c]const u8, arg_suffix_size: u32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var p = arg_p; + _ = &p; + var body = arg_body; + _ = &body; + var body_size = arg_body_size; + _ = &body_size; + var suffix = arg_suffix; + _ = &suffix; + var suffix_size = arg_suffix_size; + _ = &suffix_size; + var res: c_int = 0; + _ = &res; + var r: c_int = undefined; + _ = &r; + var size: u32 = @as(u32, @bitCast(@as(c_uint, @truncate(((@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(p)))).*.size)))) -% @as(u64, @bitCast(@as(c_ulong, body_size)))) -% @as(u64, @bitCast(@as(c_ulong, suffix_size))))))); + _ = &size; + if (builder.*.state.flags != @as(u32, @bitCast(@as(c_int, 1) << @intCast(0)))) { + { + _ = blk: { + const ref = &builder.*.state.flags; + ref.* &= @as(u32, @bitCast(~@as(@TypeOf(builder.*.state.flags), @bitCast(@as(c_int, 1) << @intCast(1))))); + break :blk ref.*; + }; + } + res = spa_pod_builder_raw(builder, @as(?*const anyopaque, @ptrCast(p)), size); + } + if ((body_size > @as(u32, @bitCast(@as(c_int, 0)))) and ((blk: { + const tmp = spa_pod_builder_raw(builder, body, body_size); + r = tmp; + break :blk tmp; + }) < @as(c_int, 0))) { + res = r; + } + if ((suffix_size > @as(u32, @bitCast(@as(c_int, 0)))) and ((blk: { + const tmp = spa_pod_builder_raw(builder, @as(?*const anyopaque, @ptrCast(suffix)), suffix_size); + r = tmp; + break :blk tmp; + }) < @as(c_int, 0))) { + res = r; + } + if ((blk: { + const tmp = spa_pod_builder_pad(builder, builder.*.state.offset); + r = tmp; + break :blk tmp; + }) < @as(c_int, 0)) { + res = r; + } + return res; +} +pub fn spa_pod_builder_primitive(arg_builder: [*c]struct_spa_pod_builder, arg_p: [*c]const struct_spa_pod) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var p = arg_p; + _ = &p; + return spa_pod_builder_primitive_body(builder, p, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(p))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), p.*.size, null, @as(u32, @bitCast(@as(c_int, 0)))); +} +pub fn spa_pod_builder_none(arg_builder: [*c]struct_spa_pod_builder) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + const p: struct_spa_pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_int, 0))), + .type = @as(u32, @bitCast(SPA_TYPE_None)), + }; + _ = &p; + return spa_pod_builder_primitive(builder, &p); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:27:50: warning: ignoring StaticAssert declaration +pub fn spa_pod_builder_child(arg_builder: [*c]struct_spa_pod_builder, arg_size: u32, arg_type: u32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var size = arg_size; + _ = &size; + var @"type" = arg_type; + _ = &@"type"; + const p: struct_spa_pod = struct_spa_pod{ + .size = size, + .type = @"type", + }; + _ = &p; + { + _ = blk: { + const ref = &builder.*.state.flags; + ref.* &= @as(u32, @bitCast(~@as(@TypeOf(builder.*.state.flags), @bitCast(@as(c_int, 1) << @intCast(1))))); + break :blk ref.*; + }; + } + return spa_pod_builder_raw(builder, @as(?*const anyopaque, @ptrCast(&p)), @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod)))))); +} +pub fn spa_pod_builder_bool(arg_builder: [*c]struct_spa_pod_builder, arg_val: bool) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var val = arg_val; + _ = &val; + const p: struct_spa_pod_bool = struct_spa_pod_bool{ + .pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(u32))))), + .type = @as(u32, @bitCast(SPA_TYPE_Bool)), + }, + .value = if (@as(c_int, @intFromBool(val)) != 0) @as(c_int, 1) else @as(c_int, 0), + ._padding = @as(c_int, 0), + }; + _ = &p; + return spa_pod_builder_primitive(builder, &p.pod); +} +pub fn spa_pod_builder_id(arg_builder: [*c]struct_spa_pod_builder, arg_val: u32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var val = arg_val; + _ = &val; + const p: struct_spa_pod_id = struct_spa_pod_id{ + .pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(u32))))), + .type = @as(u32, @bitCast(SPA_TYPE_Id)), + }, + .value = val, + ._padding = @as(c_int, 0), + }; + _ = &p; + return spa_pod_builder_primitive(builder, &p.pod); +} +pub fn spa_pod_builder_int(arg_builder: [*c]struct_spa_pod_builder, arg_val: i32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var val = arg_val; + _ = &val; + const p: struct_spa_pod_int = struct_spa_pod_int{ + .pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(i32))))), + .type = @as(u32, @bitCast(SPA_TYPE_Int)), + }, + .value = val, + ._padding = @as(c_int, 0), + }; + _ = &p; + return spa_pod_builder_primitive(builder, &p.pod); +} +pub fn spa_pod_builder_long(arg_builder: [*c]struct_spa_pod_builder, arg_val: i64) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var val = arg_val; + _ = &val; + const p: struct_spa_pod_long = struct_spa_pod_long{ + .pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(i64))))), + .type = @as(u32, @bitCast(SPA_TYPE_Long)), + }, + .value = val, + }; + _ = &p; + return spa_pod_builder_primitive(builder, &p.pod); +} +pub fn spa_pod_builder_float(arg_builder: [*c]struct_spa_pod_builder, arg_val: f32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var val = arg_val; + _ = &val; + const p: struct_spa_pod_float = struct_spa_pod_float{ + .pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(f32))))), + .type = @as(u32, @bitCast(SPA_TYPE_Float)), + }, + .value = val, + ._padding = @as(c_int, 0), + }; + _ = &p; + return spa_pod_builder_primitive(builder, &p.pod); +} +pub fn spa_pod_builder_double(arg_builder: [*c]struct_spa_pod_builder, arg_val: f64) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var val = arg_val; + _ = &val; + const p: struct_spa_pod_double = struct_spa_pod_double{ + .pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(f64))))), + .type = @as(u32, @bitCast(SPA_TYPE_Double)), + }, + .value = val, + }; + _ = &p; + return spa_pod_builder_primitive(builder, &p.pod); +} +pub fn spa_pod_builder_write_string(arg_builder: [*c]struct_spa_pod_builder, arg_str: [*c]const u8, arg_len: u32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var str = arg_str; + _ = &str; + var len = arg_len; + _ = &len; + var r: c_int = undefined; + _ = &r; + var res: c_int = undefined; + _ = &res; + res = spa_pod_builder_raw(builder, @as(?*const anyopaque, @ptrCast(str)), len); + if ((blk: { + const tmp = spa_pod_builder_raw(builder, @as(?*const anyopaque, @ptrCast("")), @as(u32, @bitCast(@as(c_int, 1)))); + r = tmp; + break :blk tmp; + }) < @as(c_int, 0)) { + res = r; + } + if ((blk: { + const tmp = spa_pod_builder_pad(builder, builder.*.state.offset); + r = tmp; + break :blk tmp; + }) < @as(c_int, 0)) { + res = r; + } + return res; +} +pub fn spa_pod_builder_string_len(arg_builder: [*c]struct_spa_pod_builder, arg_str: [*c]const u8, arg_len: u32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var str = arg_str; + _ = &str; + var len = arg_len; + _ = &len; + const p: struct_spa_pod_string = struct_spa_pod_string{ + .pod = struct_spa_pod{ + .size = len +% @as(u32, @bitCast(@as(c_int, 1))), + .type = @as(u32, @bitCast(SPA_TYPE_String)), + }, + }; + _ = &p; + return spa_pod_builder_primitive_body(builder, &p.pod, @as(?*const anyopaque, @ptrCast(str)), len, "", @as(u32, @bitCast(@as(c_int, 1)))); +} +pub fn spa_pod_builder_string(arg_builder: [*c]struct_spa_pod_builder, arg_str: [*c]const u8) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var str = arg_str; + _ = &str; + var len: u32 = @as(u32, @bitCast(@as(c_uint, @truncate(if (str != null) strlen(str) else @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 0)))))))); + _ = &len; + return spa_pod_builder_string_len(builder, if (str != null) str else "", len); +} +pub fn spa_pod_builder_bytes(arg_builder: [*c]struct_spa_pod_builder, arg_bytes: ?*const anyopaque, arg_len: u32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var bytes = arg_bytes; + _ = &bytes; + var len = arg_len; + _ = &len; + const p: struct_spa_pod_bytes = struct_spa_pod_bytes{ + .pod = struct_spa_pod{ + .size = len, + .type = @as(u32, @bitCast(SPA_TYPE_Bytes)), + }, + }; + _ = &p; + return spa_pod_builder_primitive_body(builder, &p.pod, bytes, len, null, @as(u32, @bitCast(@as(c_int, 0)))); +} +pub fn spa_pod_builder_reserve_bytes(arg_builder: [*c]struct_spa_pod_builder, arg_len: u32) callconv(.c) ?*anyopaque { + var builder = arg_builder; + _ = &builder; + var len = arg_len; + _ = &len; + var offset: u32 = builder.*.state.offset; + _ = &offset; + if (spa_pod_builder_bytes(builder, null, len) < @as(c_int, 0)) return @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); + return @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(builder.*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, @bitCast(@as(c_ulong, offset))) +% @sizeOf(struct_spa_pod))))))); +} +pub fn spa_pod_builder_pointer(arg_builder: [*c]struct_spa_pod_builder, arg_type: u32, arg_val: ?*const anyopaque) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var @"type" = arg_type; + _ = &@"type"; + var val = arg_val; + _ = &val; + const p: struct_spa_pod_pointer = struct_spa_pod_pointer{ + .pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_pointer_body))))), + .type = @as(u32, @bitCast(SPA_TYPE_Pointer)), + }, + .body = struct_spa_pod_pointer_body{ + .type = @"type", + ._padding = @as(u32, @bitCast(@as(c_int, 0))), + .value = val, + }, + }; + _ = &p; + return spa_pod_builder_primitive(builder, &p.pod); +} +pub fn spa_pod_builder_fd(arg_builder: [*c]struct_spa_pod_builder, arg_fd: i64) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var fd = arg_fd; + _ = &fd; + const p: struct_spa_pod_fd = struct_spa_pod_fd{ + .pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(i64))))), + .type = @as(u32, @bitCast(SPA_TYPE_Fd)), + }, + .value = fd, + }; + _ = &p; + return spa_pod_builder_primitive(builder, &p.pod); +} +pub fn spa_pod_builder_rectangle(arg_builder: [*c]struct_spa_pod_builder, arg_width: u32, arg_height: u32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var width = arg_width; + _ = &width; + var height = arg_height; + _ = &height; + const p: struct_spa_pod_rectangle = struct_spa_pod_rectangle{ + .pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_rectangle))))), + .type = @as(u32, @bitCast(SPA_TYPE_Rectangle)), + }, + .value = struct_spa_rectangle{ + .width = width, + .height = height, + }, + }; + _ = &p; + return spa_pod_builder_primitive(builder, &p.pod); +} +pub fn spa_pod_builder_fraction(arg_builder: [*c]struct_spa_pod_builder, arg_num: u32, arg_denom: u32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var num = arg_num; + _ = # + var denom = arg_denom; + _ = &denom; + const p: struct_spa_pod_fraction = struct_spa_pod_fraction{ + .pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_fraction))))), + .type = @as(u32, @bitCast(SPA_TYPE_Fraction)), + }, + .value = struct_spa_fraction{ + .num = num, + .denom = denom, + }, + }; + _ = &p; + return spa_pod_builder_primitive(builder, &p.pod); +} +pub fn spa_pod_builder_push_array(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var frame = arg_frame; + _ = &frame; + const p: struct_spa_pod_array = struct_spa_pod_array{ + .pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_array_body) -% @sizeOf(struct_spa_pod))))), + .type = @as(u32, @bitCast(SPA_TYPE_Array)), + }, + .body = struct_spa_pod_array_body{ + .child = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_int, 0))), + .type = @as(u32, @bitCast(@as(c_int, 0))), + }, + }, + }; + _ = &p; + var offset: u32 = builder.*.state.offset; + _ = &offset; + var res: c_int = spa_pod_builder_raw(builder, @as(?*const anyopaque, @ptrCast(&p)), @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_array) -% @sizeOf(struct_spa_pod)))))); + _ = &res; + spa_pod_builder_push(builder, frame, &p.pod, offset); + return res; +} +pub fn spa_pod_builder_array(arg_builder: [*c]struct_spa_pod_builder, arg_child_size: u32, arg_child_type: u32, arg_n_elems: u32, arg_elems: ?*const anyopaque) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var child_size = arg_child_size; + _ = &child_size; + var child_type = arg_child_type; + _ = &child_type; + var n_elems = arg_n_elems; + _ = &n_elems; + var elems = arg_elems; + _ = &elems; + const p: struct_spa_pod_array = struct_spa_pod_array{ + .pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_array_body) +% @as(c_ulong, @bitCast(@as(c_ulong, n_elems *% child_size))))))), + .type = @as(u32, @bitCast(SPA_TYPE_Array)), + }, + .body = struct_spa_pod_array_body{ + .child = struct_spa_pod{ + .size = child_size, + .type = child_type, + }, + }, + }; + _ = &p; + return spa_pod_builder_primitive_body(builder, &p.pod, elems, n_elems *% child_size, null, @as(u32, @bitCast(@as(c_int, 0)))); +} +pub fn spa_pod_builder_push_choice(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame, arg_type: u32, arg_flags: u32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var frame = arg_frame; + _ = &frame; + var @"type" = arg_type; + _ = &@"type"; + var flags = arg_flags; + _ = &flags; + const p: struct_spa_pod_choice = struct_spa_pod_choice{ + .pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_choice_body) -% @sizeOf(struct_spa_pod))))), + .type = @as(u32, @bitCast(SPA_TYPE_Choice)), + }, + .body = struct_spa_pod_choice_body{ + .type = @"type", + .flags = flags, + .child = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_int, 0))), + .type = @as(u32, @bitCast(@as(c_int, 0))), + }, + }, + }; + _ = &p; + var offset: u32 = builder.*.state.offset; + _ = &offset; + var res: c_int = spa_pod_builder_raw(builder, @as(?*const anyopaque, @ptrCast(&p)), @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_choice) -% @sizeOf(struct_spa_pod)))))); + _ = &res; + spa_pod_builder_push(builder, frame, &p.pod, offset); + return res; +} +pub fn spa_pod_builder_push_struct(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var frame = arg_frame; + _ = &frame; + const p: struct_spa_pod_struct = struct_spa_pod_struct{ + .pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_int, 0))), + .type = @as(u32, @bitCast(SPA_TYPE_Struct)), + }, + }; + _ = &p; + var offset: u32 = builder.*.state.offset; + _ = &offset; + var res: c_int = spa_pod_builder_raw(builder, @as(?*const anyopaque, @ptrCast(&p)), @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_struct)))))); + _ = &res; + spa_pod_builder_push(builder, frame, &p.pod, offset); + return res; +} +pub fn spa_pod_builder_push_object(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame, arg_type: u32, arg_id: u32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var frame = arg_frame; + _ = &frame; + var @"type" = arg_type; + _ = &@"type"; + var id = arg_id; + _ = &id; + const p: struct_spa_pod_object = struct_spa_pod_object{ + .pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_object_body))))), + .type = @as(u32, @bitCast(SPA_TYPE_Object)), + }, + .body = struct_spa_pod_object_body{ + .type = @"type", + .id = id, + }, + }; + _ = &p; + var offset: u32 = builder.*.state.offset; + _ = &offset; + var res: c_int = spa_pod_builder_raw(builder, @as(?*const anyopaque, @ptrCast(&p)), @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_object)))))); + _ = &res; + spa_pod_builder_push(builder, frame, &p.pod, offset); + return res; +} +pub fn spa_pod_builder_prop(arg_builder: [*c]struct_spa_pod_builder, arg_key: u32, arg_flags: u32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var key = arg_key; + _ = &key; + var flags = arg_flags; + _ = &flags; + const struct_unnamed_38 = extern struct { + key: u32 = @import("std").mem.zeroes(u32), + flags: u32 = @import("std").mem.zeroes(u32), + }; + _ = &struct_unnamed_38; + const p: struct_unnamed_38 = struct_unnamed_38{ + .key = key, + .flags = flags, + }; + _ = &p; + return spa_pod_builder_raw(builder, @as(?*const anyopaque, @ptrCast(&p)), @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_unnamed_38)))))); +} +pub fn spa_pod_builder_push_sequence(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame, arg_unit: u32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var frame = arg_frame; + _ = &frame; + var unit = arg_unit; + _ = &unit; + const p: struct_spa_pod_sequence = struct_spa_pod_sequence{ + .pod = struct_spa_pod{ + .size = @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_sequence_body))))), + .type = @as(u32, @bitCast(SPA_TYPE_Sequence)), + }, + .body = struct_spa_pod_sequence_body{ + .unit = unit, + .pad = @as(u32, @bitCast(@as(c_int, 0))), + }, + }; + _ = &p; + var offset: u32 = builder.*.state.offset; + _ = &offset; + var res: c_int = spa_pod_builder_raw(builder, @as(?*const anyopaque, @ptrCast(&p)), @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod_sequence)))))); + _ = &res; + spa_pod_builder_push(builder, frame, &p.pod, offset); + return res; +} +pub fn spa_pod_builder_control(arg_builder: [*c]struct_spa_pod_builder, arg_offset: u32, arg_type: u32) callconv(.c) c_int { + var builder = arg_builder; + _ = &builder; + var offset = arg_offset; + _ = &offset; + var @"type" = arg_type; + _ = &@"type"; + const struct_unnamed_39 = extern struct { + offset: u32 = @import("std").mem.zeroes(u32), + type: u32 = @import("std").mem.zeroes(u32), + }; + _ = &struct_unnamed_39; + const p: struct_unnamed_39 = struct_unnamed_39{ + .offset = offset, + .type = @"type", + }; + _ = &p; + return spa_pod_builder_raw(builder, @as(?*const anyopaque, @ptrCast(&p)), @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_unnamed_39)))))); +} +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:73:27: warning: TODO implement translation of stmt class AttributedStmtClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:489:30: warning: unable to translate function, demoted to extern +pub extern fn spa_choice_from_id_flags(arg_id: u8, arg_flags: [*c]u32) callconv(.c) u32; +pub fn spa_choice_from_id(arg_id: u8) callconv(.c) u32 { + var id = arg_id; + _ = &id; + var flags: u32 = 0; + _ = &flags; + return spa_choice_from_id_flags(id, &flags); +} +// /home/mason/.cache/zig/p/N-V-__8AAN5NhBR0oTsvnwjPdeNiiDLtEsfXRHd1fv-R3TOv/lib/include/__stdarg_va_arg.h:20:26: warning: unsupported stmt class VAArgExprClass + +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:621:1: warning: unable to translate function, demoted to extern +pub extern fn spa_pod_builder_addv(arg_builder: [*c]struct_spa_pod_builder, arg_args: [*c]struct___va_list_tag_26) callconv(.c) c_int; +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:685:25: warning: TODO unable to translate variadic function, demoted to extern +pub extern fn spa_pod_builder_add(builder: [*c]struct_spa_pod_builder, ...) c_int; +pub fn spa_pod_copy(arg_pod: [*c]const struct_spa_pod) callconv(.c) [*c]struct_spa_pod { + var pod = arg_pod; + _ = &pod; + var size: usize = undefined; + _ = &size; + var c: [*c]struct_spa_pod = undefined; + _ = &c; + size = @as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size))); + if ((blk: { + const tmp = @as([*c]struct_spa_pod, @ptrCast(@alignCast(malloc(size)))); + c = tmp; + break :blk tmp; + }) == @as([*c]struct_spa_pod, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return null; + return @as([*c]struct_spa_pod, @ptrCast(@alignCast(memcpy(@as(?*anyopaque, @ptrCast(c)), @as(?*const anyopaque, @ptrCast(pod)), size)))); +} +pub fn spa_format_video_raw_parse(arg_format: [*c]const struct_spa_pod, arg_info: [*c]struct_spa_video_info_raw) callconv(.c) c_int { + var format = arg_format; + _ = &format; + var info = arg_info; + _ = &info; + info.*.flags = @as(u32, @bitCast(SPA_VIDEO_FLAG_NONE)); + var mod_prop: [*c]const struct_spa_pod_prop = undefined; + _ = &mod_prop; + if ((blk: { + const tmp = spa_pod_find_prop(format, null, @as(u32, @bitCast(SPA_FORMAT_VIDEO_modifier))); + mod_prop = tmp; + break :blk tmp; + }) != @as([*c]const struct_spa_pod_prop, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + info.*.flags |= @as(u32, @bitCast(SPA_VIDEO_FLAG_MODIFIER)); + if ((mod_prop.*.flags & (@as(c_uint, 1) << @intCast(4))) == (@as(c_uint, 1) << @intCast(4))) { + info.*.flags |= @as(u32, @bitCast(SPA_VIDEO_FLAG_MODIFIER_FIXATION_REQUIRED)); + } + } + return blk: { + var _p: struct_spa_pod_parser = undefined; + _ = &_p; + spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod)))))))); + break :blk blk_1: { + var _f: struct_spa_pod_frame = undefined; + _ = &_f; + var _res: c_int = undefined; + _ = &_res; + if ((blk_2: { + const tmp = spa_pod_parser_push_object(&_p, &_f, @as(u32, @bitCast(SPA_TYPE_OBJECT_Format)), null); + _res = tmp; + break :blk_2 tmp; + }) == @as(c_int, 0)) { + _res = spa_pod_parser_get(&_p, SPA_FORMAT_VIDEO_format, "?I", &info.*.format, SPA_FORMAT_VIDEO_modifier, "?l", &info.*.modifier, SPA_FORMAT_VIDEO_size, "?R", &info.*.size, SPA_FORMAT_VIDEO_framerate, "?F", &info.*.framerate, SPA_FORMAT_VIDEO_maxFramerate, "?F", &info.*.max_framerate, SPA_FORMAT_VIDEO_views, "?i", &info.*.views, SPA_FORMAT_VIDEO_interlaceMode, "?I", &info.*.interlace_mode, SPA_FORMAT_VIDEO_pixelAspectRatio, "?F", &info.*.pixel_aspect_ratio, SPA_FORMAT_VIDEO_multiviewMode, "?I", &info.*.multiview_mode, SPA_FORMAT_VIDEO_multiviewFlags, "?I", &info.*.multiview_flags, SPA_FORMAT_VIDEO_chromaSite, "?I", &info.*.chroma_site, SPA_FORMAT_VIDEO_colorRange, "?I", &info.*.color_range, SPA_FORMAT_VIDEO_colorMatrix, "?I", &info.*.color_matrix, SPA_FORMAT_VIDEO_transferFunction, "?I", &info.*.transfer_function, SPA_FORMAT_VIDEO_colorPrimaries, "?I", &info.*.color_primaries, @as(c_int, 0)); + _ = spa_pod_parser_pop(&_p, &_f); + } + break :blk_1 _res; + }; + }; +} +pub fn spa_format_video_raw_build(arg_builder: [*c]struct_spa_pod_builder, arg_id: u32, arg_info: [*c]const struct_spa_video_info_raw) callconv(.c) [*c]struct_spa_pod { + var builder = arg_builder; + _ = &builder; + var id = arg_id; + _ = &id; + var info = arg_info; + _ = &info; + var f: struct_spa_pod_frame = undefined; + _ = &f; + _ = spa_pod_builder_push_object(builder, &f, @as(u32, @bitCast(SPA_TYPE_OBJECT_Format)), id); + _ = spa_pod_builder_add(builder, SPA_FORMAT_mediaType, "I", SPA_MEDIA_TYPE_video, SPA_FORMAT_mediaSubtype, "I", SPA_MEDIA_SUBTYPE_raw, @as(c_int, 0)); + if (info.*.format != @as(c_uint, @bitCast(SPA_VIDEO_FORMAT_UNKNOWN))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_format, "I", info.*.format, @as(c_int, 0)); + } + if ((info.*.size.width != @as(u32, @bitCast(@as(c_int, 0)))) and (info.*.size.height != @as(u32, @bitCast(@as(c_int, 0))))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_size, "R", &info.*.size, @as(c_int, 0)); + } + if (info.*.framerate.denom != @as(u32, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_framerate, "F", &info.*.framerate, @as(c_int, 0)); + } + if ((info.*.modifier != @as(u64, @bitCast(@as(c_long, @as(c_int, 0))))) or ((info.*.flags & @as(u32, @bitCast(SPA_VIDEO_FLAG_MODIFIER))) != 0)) { + _ = spa_pod_builder_prop(builder, @as(u32, @bitCast(SPA_FORMAT_VIDEO_modifier)), @as(c_uint, 1) << @intCast(3)); + _ = spa_pod_builder_long(builder, @as(i64, @bitCast(info.*.modifier))); + } + if (info.*.max_framerate.denom != @as(u32, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_maxFramerate, "F", &info.*.max_framerate, @as(c_int, 0)); + } + if (info.*.views != @as(u32, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_views, "i", info.*.views, @as(c_int, 0)); + } + if (info.*.interlace_mode != @as(c_uint, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_interlaceMode, "I", info.*.interlace_mode, @as(c_int, 0)); + } + if (info.*.pixel_aspect_ratio.denom != @as(u32, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_pixelAspectRatio, "F", &info.*.pixel_aspect_ratio, @as(c_int, 0)); + } + if (info.*.multiview_mode != @as(c_int, 0)) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_multiviewMode, "I", info.*.multiview_mode, @as(c_int, 0)); + } + if (info.*.multiview_flags != @as(c_uint, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_multiviewFlags, "I", info.*.multiview_flags, @as(c_int, 0)); + } + if (info.*.chroma_site != @as(c_uint, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_chromaSite, "I", info.*.chroma_site, @as(c_int, 0)); + } + if (info.*.color_range != @as(c_uint, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_colorRange, "I", info.*.color_range, @as(c_int, 0)); + } + if (info.*.color_matrix != @as(c_uint, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_colorMatrix, "I", info.*.color_matrix, @as(c_int, 0)); + } + if (info.*.transfer_function != @as(c_uint, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_transferFunction, "I", info.*.transfer_function, @as(c_int, 0)); + } + if (info.*.color_primaries != @as(c_uint, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_colorPrimaries, "I", info.*.color_primaries, @as(c_int, 0)); + } + return @as([*c]struct_spa_pod, @ptrCast(@alignCast(spa_pod_builder_pop(builder, &f)))); +} +pub fn spa_format_video_is_rgb(arg_format: enum_spa_video_format) callconv(.c) bool { + var format = arg_format; + _ = &format; + while (true) { + switch (format) { + @as(c_uint, @bitCast(@as(c_int, 7))), @as(c_uint, @bitCast(@as(c_int, 8))), @as(c_uint, @bitCast(@as(c_int, 9))), @as(c_uint, @bitCast(@as(c_int, 10))), @as(c_uint, @bitCast(@as(c_int, 11))), @as(c_uint, @bitCast(@as(c_int, 12))), @as(c_uint, @bitCast(@as(c_int, 13))), @as(c_uint, @bitCast(@as(c_int, 14))), @as(c_uint, @bitCast(@as(c_int, 15))), @as(c_uint, @bitCast(@as(c_int, 16))), @as(c_uint, @bitCast(@as(c_int, 25))), @as(c_uint, @bitCast(@as(c_int, 26))), @as(c_uint, @bitCast(@as(c_int, 27))), @as(c_uint, @bitCast(@as(c_int, 29))), @as(c_uint, @bitCast(@as(c_int, 30))), @as(c_uint, @bitCast(@as(c_int, 31))), @as(c_uint, @bitCast(@as(c_int, 32))), @as(c_uint, @bitCast(@as(c_int, 35))), @as(c_uint, @bitCast(@as(c_int, 39))), @as(c_uint, @bitCast(@as(c_int, 41))), @as(c_uint, @bitCast(@as(c_int, 48))), @as(c_uint, @bitCast(@as(c_int, 49))), @as(c_uint, @bitCast(@as(c_int, 50))), @as(c_uint, @bitCast(@as(c_int, 65))), @as(c_uint, @bitCast(@as(c_int, 66))), @as(c_uint, @bitCast(@as(c_int, 67))), @as(c_uint, @bitCast(@as(c_int, 68))), @as(c_uint, @bitCast(@as(c_int, 69))), @as(c_uint, @bitCast(@as(c_int, 70))), @as(c_uint, @bitCast(@as(c_int, 71))), @as(c_uint, @bitCast(@as(c_int, 78))), @as(c_uint, @bitCast(@as(c_int, 79))), @as(c_uint, @bitCast(@as(c_int, 80))), @as(c_uint, @bitCast(@as(c_int, 81))), @as(c_uint, @bitCast(@as(c_int, 82))), @as(c_uint, @bitCast(@as(c_int, 83))), @as(c_uint, @bitCast(@as(c_int, 84))), @as(c_uint, @bitCast(@as(c_int, 85))), @as(c_uint, @bitCast(@as(c_int, 86))), @as(c_uint, @bitCast(@as(c_int, 87))) => return @as(c_int, 1) != 0, + else => return @as(c_int, 0) != 0, + } + break; + } + return false; +} +pub fn spa_format_video_dsp_parse(arg_format: [*c]const struct_spa_pod, arg_info: [*c]struct_spa_video_info_dsp) callconv(.c) c_int { + var format = arg_format; + _ = &format; + var info = arg_info; + _ = &info; + info.*.flags = @as(u32, @bitCast(SPA_VIDEO_FLAG_NONE)); + var mod_prop: [*c]const struct_spa_pod_prop = undefined; + _ = &mod_prop; + if ((blk: { + const tmp = spa_pod_find_prop(format, null, @as(u32, @bitCast(SPA_FORMAT_VIDEO_modifier))); + mod_prop = tmp; + break :blk tmp; + }) != @as([*c]const struct_spa_pod_prop, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + info.*.flags |= @as(u32, @bitCast(SPA_VIDEO_FLAG_MODIFIER)); + if ((mod_prop.*.flags & (@as(c_uint, 1) << @intCast(4))) == (@as(c_uint, 1) << @intCast(4))) { + info.*.flags |= @as(u32, @bitCast(SPA_VIDEO_FLAG_MODIFIER_FIXATION_REQUIRED)); + } + } + return blk: { + var _p: struct_spa_pod_parser = undefined; + _ = &_p; + spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod)))))))); + break :blk blk_1: { + var _f: struct_spa_pod_frame = undefined; + _ = &_f; + var _res: c_int = undefined; + _ = &_res; + if ((blk_2: { + const tmp = spa_pod_parser_push_object(&_p, &_f, @as(u32, @bitCast(SPA_TYPE_OBJECT_Format)), null); + _res = tmp; + break :blk_2 tmp; + }) == @as(c_int, 0)) { + _res = spa_pod_parser_get(&_p, SPA_FORMAT_VIDEO_format, "?I", &info.*.format, SPA_FORMAT_VIDEO_modifier, "?l", &info.*.modifier, @as(c_int, 0)); + _ = spa_pod_parser_pop(&_p, &_f); + } + break :blk_1 _res; + }; + }; +} +pub fn spa_format_video_dsp_build(arg_builder: [*c]struct_spa_pod_builder, arg_id: u32, arg_info: [*c]const struct_spa_video_info_dsp) callconv(.c) [*c]struct_spa_pod { + var builder = arg_builder; + _ = &builder; + var id = arg_id; + _ = &id; + var info = arg_info; + _ = &info; + var f: struct_spa_pod_frame = undefined; + _ = &f; + _ = spa_pod_builder_push_object(builder, &f, @as(u32, @bitCast(SPA_TYPE_OBJECT_Format)), id); + _ = spa_pod_builder_add(builder, SPA_FORMAT_mediaType, "I", SPA_MEDIA_TYPE_video, SPA_FORMAT_mediaSubtype, "I", SPA_MEDIA_SUBTYPE_dsp, @as(c_int, 0)); + if (info.*.format != @as(c_uint, @bitCast(SPA_VIDEO_FORMAT_UNKNOWN))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_format, "I", info.*.format, @as(c_int, 0)); + } + if ((info.*.modifier != @as(u64, @bitCast(@as(c_long, @as(c_int, 0))))) or ((info.*.flags & @as(u32, @bitCast(SPA_VIDEO_FLAG_MODIFIER))) != 0)) { + _ = spa_pod_builder_prop(builder, @as(u32, @bitCast(SPA_FORMAT_VIDEO_modifier)), @as(c_uint, 1) << @intCast(3)); + _ = spa_pod_builder_long(builder, @as(i64, @bitCast(info.*.modifier))); + } + return @as([*c]struct_spa_pod, @ptrCast(@alignCast(spa_pod_builder_pop(builder, &f)))); +} +pub fn spa_format_video_h264_parse(arg_format: [*c]const struct_spa_pod, arg_info: [*c]struct_spa_video_info_h264) callconv(.c) c_int { + var format = arg_format; + _ = &format; + var info = arg_info; + _ = &info; + return blk: { + var _p: struct_spa_pod_parser = undefined; + _ = &_p; + spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod)))))))); + break :blk blk_1: { + var _f: struct_spa_pod_frame = undefined; + _ = &_f; + var _res: c_int = undefined; + _ = &_res; + if ((blk_2: { + const tmp = spa_pod_parser_push_object(&_p, &_f, @as(u32, @bitCast(SPA_TYPE_OBJECT_Format)), null); + _res = tmp; + break :blk_2 tmp; + }) == @as(c_int, 0)) { + _res = spa_pod_parser_get(&_p, SPA_FORMAT_VIDEO_size, "?R", &info.*.size, SPA_FORMAT_VIDEO_framerate, "?F", &info.*.framerate, SPA_FORMAT_VIDEO_maxFramerate, "?F", &info.*.max_framerate, SPA_FORMAT_VIDEO_H264_streamFormat, "?I", &info.*.stream_format, SPA_FORMAT_VIDEO_H264_alignment, "?I", &info.*.alignment, @as(c_int, 0)); + _ = spa_pod_parser_pop(&_p, &_f); + } + break :blk_1 _res; + }; + }; +} +pub fn spa_format_video_h264_build(arg_builder: [*c]struct_spa_pod_builder, arg_id: u32, arg_info: [*c]const struct_spa_video_info_h264) callconv(.c) [*c]struct_spa_pod { + var builder = arg_builder; + _ = &builder; + var id = arg_id; + _ = &id; + var info = arg_info; + _ = &info; + var f: struct_spa_pod_frame = undefined; + _ = &f; + _ = spa_pod_builder_push_object(builder, &f, @as(u32, @bitCast(SPA_TYPE_OBJECT_Format)), id); + _ = spa_pod_builder_add(builder, SPA_FORMAT_mediaType, "I", SPA_MEDIA_TYPE_video, SPA_FORMAT_mediaSubtype, "I", SPA_MEDIA_SUBTYPE_h264, @as(c_int, 0)); + if ((info.*.size.width != @as(u32, @bitCast(@as(c_int, 0)))) and (info.*.size.height != @as(u32, @bitCast(@as(c_int, 0))))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_size, "R", &info.*.size, @as(c_int, 0)); + } + if (info.*.framerate.denom != @as(u32, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_framerate, "F", &info.*.framerate, @as(c_int, 0)); + } + if (info.*.max_framerate.denom != @as(u32, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_maxFramerate, "F", &info.*.max_framerate, @as(c_int, 0)); + } + if (info.*.stream_format != @as(c_uint, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_H264_streamFormat, "I", info.*.stream_format, @as(c_int, 0)); + } + if (info.*.alignment != @as(c_uint, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_H264_alignment, "I", info.*.alignment, @as(c_int, 0)); + } + return @as([*c]struct_spa_pod, @ptrCast(@alignCast(spa_pod_builder_pop(builder, &f)))); +} +pub const SPA_H265_STREAM_FORMAT_UNKNOWN: c_int = 0; +pub const SPA_H265_STREAM_FORMAT_HVC1: c_int = 1; +pub const SPA_H265_STREAM_FORMAT_HEV1: c_int = 2; +pub const SPA_H265_STREAM_FORMAT_BYTESTREAM: c_int = 3; +pub const enum_spa_h265_stream_format = c_uint; +pub const SPA_H265_ALIGNMENT_UNKNOWN: c_int = 0; +pub const SPA_H265_ALIGNMENT_AU: c_int = 1; +pub const SPA_H265_ALIGNMENT_NAL: c_int = 2; +pub const enum_spa_h265_alignment = c_uint; +pub const struct_spa_video_info_h265 = extern struct { + size: struct_spa_rectangle = @import("std").mem.zeroes(struct_spa_rectangle), + framerate: struct_spa_fraction = @import("std").mem.zeroes(struct_spa_fraction), + max_framerate: struct_spa_fraction = @import("std").mem.zeroes(struct_spa_fraction), + stream_format: enum_spa_h265_stream_format = @import("std").mem.zeroes(enum_spa_h265_stream_format), + alignment: enum_spa_h265_alignment = @import("std").mem.zeroes(enum_spa_h265_alignment), +}; +pub fn spa_format_video_h265_parse(arg_format: [*c]const struct_spa_pod, arg_info: [*c]struct_spa_video_info_h265) callconv(.c) c_int { + var format = arg_format; + _ = &format; + var info = arg_info; + _ = &info; + return blk: { + var _p: struct_spa_pod_parser = undefined; + _ = &_p; + spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod)))))))); + break :blk blk_1: { + var _f: struct_spa_pod_frame = undefined; + _ = &_f; + var _res: c_int = undefined; + _ = &_res; + if ((blk_2: { + const tmp = spa_pod_parser_push_object(&_p, &_f, @as(u32, @bitCast(SPA_TYPE_OBJECT_Format)), null); + _res = tmp; + break :blk_2 tmp; + }) == @as(c_int, 0)) { + _res = spa_pod_parser_get(&_p, SPA_FORMAT_VIDEO_size, "?R", &info.*.size, SPA_FORMAT_VIDEO_framerate, "?F", &info.*.framerate, SPA_FORMAT_VIDEO_maxFramerate, "?F", &info.*.max_framerate, SPA_FORMAT_VIDEO_H265_streamFormat, "?I", &info.*.stream_format, SPA_FORMAT_VIDEO_H265_alignment, "?I", &info.*.alignment, @as(c_int, 0)); + _ = spa_pod_parser_pop(&_p, &_f); + } + break :blk_1 _res; + }; + }; +} +pub fn spa_format_video_h265_build(arg_builder: [*c]struct_spa_pod_builder, arg_id: u32, arg_info: [*c]const struct_spa_video_info_h265) callconv(.c) [*c]struct_spa_pod { + var builder = arg_builder; + _ = &builder; + var id = arg_id; + _ = &id; + var info = arg_info; + _ = &info; + var f: struct_spa_pod_frame = undefined; + _ = &f; + _ = spa_pod_builder_push_object(builder, &f, @as(u32, @bitCast(SPA_TYPE_OBJECT_Format)), id); + _ = spa_pod_builder_add(builder, SPA_FORMAT_mediaType, "I", SPA_MEDIA_TYPE_video, SPA_FORMAT_mediaSubtype, "I", SPA_MEDIA_SUBTYPE_h265, @as(c_int, 0)); + if ((info.*.size.width != @as(u32, @bitCast(@as(c_int, 0)))) and (info.*.size.height != @as(u32, @bitCast(@as(c_int, 0))))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_size, "R", &info.*.size, @as(c_int, 0)); + } + if (info.*.framerate.denom != @as(u32, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_framerate, "F", &info.*.framerate, @as(c_int, 0)); + } + if (info.*.max_framerate.denom != @as(u32, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_maxFramerate, "F", &info.*.max_framerate, @as(c_int, 0)); + } + if (info.*.stream_format != @as(c_uint, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_H265_streamFormat, "I", info.*.stream_format, @as(c_int, 0)); + } + if (info.*.alignment != @as(c_uint, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_H265_alignment, "I", info.*.alignment, @as(c_int, 0)); + } + return @as([*c]struct_spa_pod, @ptrCast(@alignCast(spa_pod_builder_pop(builder, &f)))); +} +pub fn spa_format_video_mjpg_parse(arg_format: [*c]const struct_spa_pod, arg_info: [*c]struct_spa_video_info_mjpg) callconv(.c) c_int { + var format = arg_format; + _ = &format; + var info = arg_info; + _ = &info; + return blk: { + var _p: struct_spa_pod_parser = undefined; + _ = &_p; + spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod)))))))); + break :blk blk_1: { + var _f: struct_spa_pod_frame = undefined; + _ = &_f; + var _res: c_int = undefined; + _ = &_res; + if ((blk_2: { + const tmp = spa_pod_parser_push_object(&_p, &_f, @as(u32, @bitCast(SPA_TYPE_OBJECT_Format)), null); + _res = tmp; + break :blk_2 tmp; + }) == @as(c_int, 0)) { + _res = spa_pod_parser_get(&_p, SPA_FORMAT_VIDEO_size, "?R", &info.*.size, SPA_FORMAT_VIDEO_framerate, "?F", &info.*.framerate, SPA_FORMAT_VIDEO_maxFramerate, "?F", &info.*.max_framerate, @as(c_int, 0)); + _ = spa_pod_parser_pop(&_p, &_f); + } + break :blk_1 _res; + }; + }; +} +pub fn spa_format_video_mjpg_build(arg_builder: [*c]struct_spa_pod_builder, arg_id: u32, arg_info: [*c]const struct_spa_video_info_mjpg) callconv(.c) [*c]struct_spa_pod { + var builder = arg_builder; + _ = &builder; + var id = arg_id; + _ = &id; + var info = arg_info; + _ = &info; + var f: struct_spa_pod_frame = undefined; + _ = &f; + _ = spa_pod_builder_push_object(builder, &f, @as(u32, @bitCast(SPA_TYPE_OBJECT_Format)), id); + _ = spa_pod_builder_add(builder, SPA_FORMAT_mediaType, "I", SPA_MEDIA_TYPE_video, SPA_FORMAT_mediaSubtype, "I", SPA_MEDIA_SUBTYPE_mjpg, @as(c_int, 0)); + if ((info.*.size.width != @as(u32, @bitCast(@as(c_int, 0)))) and (info.*.size.height != @as(u32, @bitCast(@as(c_int, 0))))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_size, "R", &info.*.size, @as(c_int, 0)); + } + if (info.*.framerate.denom != @as(u32, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_framerate, "F", &info.*.framerate, @as(c_int, 0)); + } + if (info.*.max_framerate.denom != @as(u32, @bitCast(@as(c_int, 0)))) { + _ = spa_pod_builder_add(builder, SPA_FORMAT_VIDEO_maxFramerate, "F", &info.*.max_framerate, @as(c_int, 0)); + } + return @as([*c]struct_spa_pod, @ptrCast(@alignCast(spa_pod_builder_pop(builder, &f)))); +} +pub fn spa_format_video_parse(arg_format: [*c]const struct_spa_pod, arg_info: [*c]struct_spa_video_info) callconv(.c) c_int { + var format = arg_format; + _ = &format; + var info = arg_info; + _ = &info; + var res: c_int = undefined; + _ = &res; + if ((blk: { + const tmp = spa_format_parse(format, &info.*.media_type, &info.*.media_subtype); + res = tmp; + break :blk tmp; + }) < @as(c_int, 0)) return res; + if (info.*.media_type != @as(u32, @bitCast(SPA_MEDIA_TYPE_video))) return -@as(c_int, 22); + while (true) { + switch (info.*.media_subtype) { + @as(u32, @bitCast(@as(c_int, 1))) => return spa_format_video_raw_parse(format, &info.*.info.raw), + @as(u32, @bitCast(@as(c_int, 2))) => return spa_format_video_dsp_parse(format, &info.*.info.dsp), + @as(u32, @bitCast(@as(c_int, 131073))) => return spa_format_video_h264_parse(format, &info.*.info.h264), + @as(u32, @bitCast(@as(c_int, 131074))) => return spa_format_video_mjpg_parse(format, &info.*.info.mjpg), + else => {}, + } + break; + } + return -@as(c_int, 95); +} +pub fn spa_format_video_build(arg_builder: [*c]struct_spa_pod_builder, arg_id: u32, arg_info: [*c]const struct_spa_video_info) callconv(.c) [*c]struct_spa_pod { + var builder = arg_builder; + _ = &builder; + var id = arg_id; + _ = &id; + var info = arg_info; + _ = &info; + while (true) { + switch (info.*.media_subtype) { + @as(u32, @bitCast(@as(c_int, 1))) => return spa_format_video_raw_build(builder, id, &info.*.info.raw), + @as(u32, @bitCast(@as(c_int, 2))) => return spa_format_video_dsp_build(builder, id, &info.*.info.dsp), + @as(u32, @bitCast(@as(c_int, 131073))) => return spa_format_video_h264_build(builder, id, &info.*.info.h264), + @as(u32, @bitCast(@as(c_int, 131074))) => return spa_format_video_mjpg_build(builder, id, &info.*.info.mjpg), + else => {}, + } + break; + } + __errno_location().* = 95; + return null; +} +pub const _ISupper: c_int = 256; +pub const _ISlower: c_int = 512; +pub const _ISalpha: c_int = 1024; +pub const _ISdigit: c_int = 2048; +pub const _ISxdigit: c_int = 4096; +pub const _ISspace: c_int = 8192; +pub const _ISprint: c_int = 16384; +pub const _ISgraph: c_int = 32768; +pub const _ISblank: c_int = 1; +pub const _IScntrl: c_int = 2; +pub const _ISpunct: c_int = 4; +pub const _ISalnum: c_int = 8; +const enum_unnamed_40 = c_uint; +pub extern fn __ctype_b_loc() [*c][*c]const c_ushort; +pub extern fn __ctype_tolower_loc() [*c][*c]const __int32_t; +pub extern fn __ctype_toupper_loc() [*c][*c]const __int32_t; +pub extern fn isalnum(c_int) c_int; +pub extern fn isalpha(c_int) c_int; +pub extern fn iscntrl(c_int) c_int; +pub extern fn isdigit(c_int) c_int; +pub extern fn islower(c_int) c_int; +pub extern fn isgraph(c_int) c_int; +pub extern fn isprint(c_int) c_int; +pub extern fn ispunct(c_int) c_int; +pub extern fn isspace(c_int) c_int; +pub extern fn isupper(c_int) c_int; +pub extern fn isxdigit(c_int) c_int; +pub extern fn tolower(__c: c_int) c_int; +pub extern fn toupper(__c: c_int) c_int; +pub extern fn isblank(c_int) c_int; +pub extern fn isascii(__c: c_int) c_int; +pub extern fn toascii(__c: c_int) c_int; +pub extern fn _toupper(c_int) c_int; +pub extern fn _tolower(c_int) c_int; +pub extern fn isalnum_l(c_int, locale_t) c_int; +pub extern fn isalpha_l(c_int, locale_t) c_int; +pub extern fn iscntrl_l(c_int, locale_t) c_int; +pub extern fn isdigit_l(c_int, locale_t) c_int; +pub extern fn islower_l(c_int, locale_t) c_int; +pub extern fn isgraph_l(c_int, locale_t) c_int; +pub extern fn isprint_l(c_int, locale_t) c_int; +pub extern fn ispunct_l(c_int, locale_t) c_int; +pub extern fn isspace_l(c_int, locale_t) c_int; +pub extern fn isupper_l(c_int, locale_t) c_int; +pub extern fn isxdigit_l(c_int, locale_t) c_int; +pub extern fn isblank_l(c_int, locale_t) c_int; +pub extern fn __tolower_l(__c: c_int, __l: locale_t) c_int; +pub extern fn tolower_l(__c: c_int, __l: locale_t) c_int; +pub extern fn __toupper_l(__c: c_int, __l: locale_t) c_int; +pub extern fn toupper_l(__c: c_int, __l: locale_t) c_int; +pub const struct_spa_debug_context = extern struct { + log: ?*const fn ([*c]struct_spa_debug_context, [*c]const u8, ...) callconv(.c) void = @import("std").mem.zeroes(?*const fn ([*c]struct_spa_debug_context, [*c]const u8, ...) callconv(.c) void), +}; +pub fn spa_debugc_error_location(arg_c: [*c]struct_spa_debug_context, arg_loc: [*c]struct_spa_error_location) callconv(.c) void { + var c = arg_c; + _ = &c; + var loc = arg_loc; + _ = &loc; + var i: c_int = undefined; + _ = &i; + var skip: c_int = if (loc.*.col > @as(c_int, 80)) loc.*.col - @as(c_int, 40) else @as(c_int, 0); + _ = &skip; + var lc: c_int = (loc.*.col - skip) - @as(c_int, 1); + _ = &lc; + var buf: [80]u8 = undefined; + _ = &buf; + { + i = 0; + while ((@as(usize, @bitCast(@as(c_long, i))) < (@sizeOf([80]u8) -% @as(c_ulong, @bitCast(@as(c_long, @as(c_int, 1)))))) and (@as(usize, @bitCast(@as(c_long, i + skip))) < loc.*.len)) : (i += 1) { + var ch: u8 = (blk: { + const tmp = i + skip; + if (tmp >= 0) break :blk loc.*.location + @as(usize, @intCast(tmp)) else break :blk loc.*.location - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*; + _ = &ch; + if ((@as(c_int, @bitCast(@as(c_uint, ch))) == @as(c_int, '\n')) or (@as(c_int, @bitCast(@as(c_uint, ch))) == @as(c_int, '\x00'))) break; + buf[@as(c_uint, @intCast(i))] = @as(u8, @bitCast(@as(i8, @truncate(if ((@as(c_int, @bitCast(@as(c_uint, (blk: { + const tmp = @as(c_int, @bitCast(@as(c_uint, ch))); + if (tmp >= 0) break :blk __ctype_b_loc().* + @as(usize, @intCast(tmp)) else break :blk __ctype_b_loc().* - ~@as(usize, @bitCast(@as(isize, @intCast(tmp)) +% -1)); + }).*))) & @as(c_int, @bitCast(@as(c_uint, @as(c_ushort, @bitCast(@as(c_short, @truncate(_ISspace)))))))) != 0) @as(c_int, ' ') else @as(c_int, @bitCast(@as(c_uint, ch))))))); + } + } + buf[@as(c_uint, @intCast(i))] = '\x00'; + if (c != null) _ = c.*.log.?(c, "line:%6d | %s%s", loc.*.line, if (skip != 0) "..." else "", @as([*c]u8, @ptrCast(@alignCast(&buf[@as(usize, @intCast(0))])))) else _ = printf("line:%6d | %s%s\n", loc.*.line, if (skip != 0) "..." else "", @as([*c]u8, @ptrCast(@alignCast(&buf[@as(usize, @intCast(0))])))); + { + i = 0; + while (buf[@as(c_uint, @intCast(i))] != 0) : (i += 1) { + buf[@as(c_uint, @intCast(i))] = @as(u8, @bitCast(@as(i8, @truncate(if (i < lc) @as(c_int, '-') else if (i == lc) @as(c_int, '^') else @as(c_int, ' '))))); + } + } + if (c != null) _ = c.*.log.?(c, "column:%4d |-%s%s", loc.*.col, if (skip != 0) "---" else "", @as([*c]u8, @ptrCast(@alignCast(&buf[@as(usize, @intCast(0))])))) else _ = printf("column:%4d |-%s%s\n", loc.*.col, if (skip != 0) "---" else "", @as([*c]u8, @ptrCast(@alignCast(&buf[@as(usize, @intCast(0))])))); +} +pub const spa_type_direction: [3]struct_spa_type_info = [3]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_DIRECTION_INPUT)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Direction:Input", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_DIRECTION_OUTPUT)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Direction:Output", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_choice: [6]struct_spa_type_info = [6]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_CHOICE_None)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Choice:None", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_CHOICE_Range)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Choice:Range", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_CHOICE_Step)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Choice:Step", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_CHOICE_Enum)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Choice:Enum", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_CHOICE_Flags)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Choice:Flags", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const SPA_DEVICE_EVENT_ObjectConfig: c_int = 0; +pub const enum_spa_device_event = c_uint; +pub const SPA_EVENT_DEVICE_START: c_int = 0; +pub const SPA_EVENT_DEVICE_Object: c_int = 1; +pub const SPA_EVENT_DEVICE_Props: c_int = 2; +pub const enum_spa_event_device = c_uint; +pub const spa_type_device_event_id: [2]struct_spa_type_info = [2]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_DEVICE_EVENT_ObjectConfig)), + .parent = @as(u32, @bitCast(SPA_TYPE_EVENT_Device)), + .name = "Spa:Enum:DeviceEventId:ObjectConfig", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_device_event: [4]struct_spa_type_info = [4]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_EVENT_DEVICE_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Event:Device:", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_device_event_id[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_EVENT_DEVICE_Object)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Event:Device:Object", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_EVENT_DEVICE_Props)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_Props)), + .name = "Spa:Pod:Object:Event:Device:Props", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_io: [12]struct_spa_type_info = [12]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_IO_Invalid)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:IO:Invalid", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_IO_Buffers)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:IO:Buffers", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_IO_Range)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:IO:Range", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_IO_Clock)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:IO:Clock", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_IO_Latency)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:IO:Latency", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_IO_Control)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:IO:Control", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_IO_Notify)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:IO:Notify", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_IO_Position)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:IO:Position", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_IO_RateMatch)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:IO:RateMatch", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_IO_Memory)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:IO:Memory", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_IO_AsyncBuffers)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:IO:AsyncBuffers", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_node_event_id: [6]struct_spa_type_info = [6]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_NODE_EVENT_Error)), + .parent = @as(u32, @bitCast(SPA_TYPE_EVENT_Node)), + .name = "Spa:Pod:Object:Event:Node:Error", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_NODE_EVENT_Buffering)), + .parent = @as(u32, @bitCast(SPA_TYPE_EVENT_Node)), + .name = "Spa:Pod:Object:Event:Node:Buffering", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_NODE_EVENT_RequestRefresh)), + .parent = @as(u32, @bitCast(SPA_TYPE_EVENT_Node)), + .name = "Spa:Pod:Object:Event:Node:RequestRefresh", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_NODE_EVENT_RequestProcess)), + .parent = @as(u32, @bitCast(SPA_TYPE_EVENT_Node)), + .name = "Spa:Pod:Object:Event:Node:RequestProcess", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_NODE_EVENT_User)), + .parent = @as(u32, @bitCast(SPA_TYPE_EVENT_Node)), + .name = "Spa:Pod:Object:Event:Node:User", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_node_event: [3]struct_spa_type_info = [3]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_EVENT_NODE_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Event:Node:", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_node_event_id[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_EVENT_NODE_extra)), + .parent = @as(u32, @bitCast(SPA_TYPE_String)), + .name = "Spa:Pod:Object:Event:Node:extra", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_node_command_id: [13]struct_spa_type_info = [13]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_NODE_COMMAND_Suspend)), + .parent = @as(u32, @bitCast(SPA_TYPE_COMMAND_Node)), + .name = "Spa:Pod:Object:Command:Node:Suspend", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_NODE_COMMAND_Pause)), + .parent = @as(u32, @bitCast(SPA_TYPE_COMMAND_Node)), + .name = "Spa:Pod:Object:Command:Node:Pause", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_NODE_COMMAND_Start)), + .parent = @as(u32, @bitCast(SPA_TYPE_COMMAND_Node)), + .name = "Spa:Pod:Object:Command:Node:Start", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_NODE_COMMAND_Enable)), + .parent = @as(u32, @bitCast(SPA_TYPE_COMMAND_Node)), + .name = "Spa:Pod:Object:Command:Node:Enable", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_NODE_COMMAND_Disable)), + .parent = @as(u32, @bitCast(SPA_TYPE_COMMAND_Node)), + .name = "Spa:Pod:Object:Command:Node:Disable", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_NODE_COMMAND_Flush)), + .parent = @as(u32, @bitCast(SPA_TYPE_COMMAND_Node)), + .name = "Spa:Pod:Object:Command:Node:Flush", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_NODE_COMMAND_Drain)), + .parent = @as(u32, @bitCast(SPA_TYPE_COMMAND_Node)), + .name = "Spa:Pod:Object:Command:Node:Drain", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_NODE_COMMAND_Marker)), + .parent = @as(u32, @bitCast(SPA_TYPE_COMMAND_Node)), + .name = "Spa:Pod:Object:Command:Node:Marker", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_NODE_COMMAND_ParamBegin)), + .parent = @as(u32, @bitCast(SPA_TYPE_COMMAND_Node)), + .name = "Spa:Pod:Object:Command:Node:ParamBegin", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_NODE_COMMAND_ParamEnd)), + .parent = @as(u32, @bitCast(SPA_TYPE_COMMAND_Node)), + .name = "Spa:Pod:Object:Command:Node:ParamEnd", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_NODE_COMMAND_RequestProcess)), + .parent = @as(u32, @bitCast(SPA_TYPE_COMMAND_Node)), + .name = "Spa:Pod:Object:Command:Node:RequestProcess", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_NODE_COMMAND_User)), + .parent = @as(u32, @bitCast(SPA_TYPE_COMMAND_Node)), + .name = "Spa:Pod:Object:Command:Node:User", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_node_command: [3]struct_spa_type_info = [3]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_COMMAND_NODE_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Command:Node:", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_node_command_id[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_COMMAND_NODE_extra)), + .parent = @as(u32, @bitCast(SPA_TYPE_String)), + .name = "Spa:Pod:Object:Command:Node:extra", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const SPA_PROP_INFO_START: c_int = 0; +pub const SPA_PROP_INFO_id: c_int = 1; +pub const SPA_PROP_INFO_name: c_int = 2; +pub const SPA_PROP_INFO_type: c_int = 3; +pub const SPA_PROP_INFO_labels: c_int = 4; +pub const SPA_PROP_INFO_container: c_int = 5; +pub const SPA_PROP_INFO_params: c_int = 6; +pub const SPA_PROP_INFO_description: c_int = 7; +pub const enum_spa_prop_info = c_uint; +pub const SPA_PROP_START: c_int = 0; +pub const SPA_PROP_unknown: c_int = 1; +pub const SPA_PROP_START_Device: c_int = 256; +pub const SPA_PROP_device: c_int = 257; +pub const SPA_PROP_deviceName: c_int = 258; +pub const SPA_PROP_deviceFd: c_int = 259; +pub const SPA_PROP_card: c_int = 260; +pub const SPA_PROP_cardName: c_int = 261; +pub const SPA_PROP_minLatency: c_int = 262; +pub const SPA_PROP_maxLatency: c_int = 263; +pub const SPA_PROP_periods: c_int = 264; +pub const SPA_PROP_periodSize: c_int = 265; +pub const SPA_PROP_periodEvent: c_int = 266; +pub const SPA_PROP_live: c_int = 267; +pub const SPA_PROP_rate: c_int = 268; +pub const SPA_PROP_quality: c_int = 269; +pub const SPA_PROP_bluetoothAudioCodec: c_int = 270; +pub const SPA_PROP_bluetoothOffloadActive: c_int = 271; +pub const SPA_PROP_START_Audio: c_int = 65536; +pub const SPA_PROP_waveType: c_int = 65537; +pub const SPA_PROP_frequency: c_int = 65538; +pub const SPA_PROP_volume: c_int = 65539; +pub const SPA_PROP_mute: c_int = 65540; +pub const SPA_PROP_patternType: c_int = 65541; +pub const SPA_PROP_ditherType: c_int = 65542; +pub const SPA_PROP_truncate: c_int = 65543; +pub const SPA_PROP_channelVolumes: c_int = 65544; +pub const SPA_PROP_volumeBase: c_int = 65545; +pub const SPA_PROP_volumeStep: c_int = 65546; +pub const SPA_PROP_channelMap: c_int = 65547; +pub const SPA_PROP_monitorMute: c_int = 65548; +pub const SPA_PROP_monitorVolumes: c_int = 65549; +pub const SPA_PROP_latencyOffsetNsec: c_int = 65550; +pub const SPA_PROP_softMute: c_int = 65551; +pub const SPA_PROP_softVolumes: c_int = 65552; +pub const SPA_PROP_iec958Codecs: c_int = 65553; +pub const SPA_PROP_volumeRampSamples: c_int = 65554; +pub const SPA_PROP_volumeRampStepSamples: c_int = 65555; +pub const SPA_PROP_volumeRampTime: c_int = 65556; +pub const SPA_PROP_volumeRampStepTime: c_int = 65557; +pub const SPA_PROP_volumeRampScale: c_int = 65558; +pub const SPA_PROP_START_Video: c_int = 131072; +pub const SPA_PROP_brightness: c_int = 131073; +pub const SPA_PROP_contrast: c_int = 131074; +pub const SPA_PROP_saturation: c_int = 131075; +pub const SPA_PROP_hue: c_int = 131076; +pub const SPA_PROP_gamma: c_int = 131077; +pub const SPA_PROP_exposure: c_int = 131078; +pub const SPA_PROP_gain: c_int = 131079; +pub const SPA_PROP_sharpness: c_int = 131080; +pub const SPA_PROP_START_Other: c_int = 524288; +pub const SPA_PROP_params: c_int = 524289; +pub const SPA_PROP_START_CUSTOM: c_int = 16777216; +pub const enum_spa_prop = c_uint; +pub const spa_type_data_type: [7]struct_spa_type_info = [7]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_DATA_Invalid)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Data:Invalid", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_DATA_MemPtr)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Data:MemPtr", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_DATA_MemFd)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Data:Fd:MemFd", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_DATA_DmaBuf)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Data:Fd:DmaBuf", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_DATA_MemId)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Data:MemId", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_DATA_SyncObj)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Data:SyncObj", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_meta_videotransform_type: [9]struct_spa_type_info = [9]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_TRANSFORMATION_None)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Meta:Transformation:None", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_TRANSFORMATION_90)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Meta:Transformation:90", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_TRANSFORMATION_180)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Meta:Transformation:180", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_TRANSFORMATION_270)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Meta:Transformation:270", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_TRANSFORMATION_Flipped)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Meta:Transformation:Flipped", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_TRANSFORMATION_Flipped90)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Meta:Transformation:Flipped90", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_TRANSFORMATION_Flipped180)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Meta:Transformation:Flipped180", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_TRANSFORMATION_Flipped270)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Meta:Transformation:Flipped270", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_meta_type: [11]struct_spa_type_info = [11]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_Invalid)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pointer)), + .name = "Spa:Pointer:Meta:Invalid", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_Header)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pointer)), + .name = "Spa:Pointer:Meta:Header", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_VideoCrop)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pointer)), + .name = "Spa:Pointer:Meta:Region:VideoCrop", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_VideoDamage)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pointer)), + .name = "Spa:Pointer:Meta:Array:Region:VideoDamage", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_Bitmap)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pointer)), + .name = "Spa:Pointer:Meta:Bitmap", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_Cursor)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pointer)), + .name = "Spa:Pointer:Meta:Cursor", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_Control)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pointer)), + .name = "Spa:Pointer:Meta:Control", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_Busy)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pointer)), + .name = "Spa:Pointer:Meta:Busy", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_VideoTransform)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pointer)), + .name = "Spa:Pointer:Meta:VideoTransform", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_META_SyncTimeline)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pointer)), + .name = "Spa:Pointer:Meta:SyncTimeline", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_param: [20]struct_spa_type_info = [20]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_Invalid)), + .parent = @as(u32, @bitCast(SPA_TYPE_None)), + .name = "Spa:Enum:ParamId:Invalid", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PropInfo)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_PropInfo)), + .name = "Spa:Enum:ParamId:PropInfo", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_Props)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_Props)), + .name = "Spa:Enum:ParamId:Props", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_EnumFormat)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_Format)), + .name = "Spa:Enum:ParamId:EnumFormat", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_Format)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_Format)), + .name = "Spa:Enum:ParamId:Format", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_Buffers)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamBuffers)), + .name = "Spa:Enum:ParamId:Buffers", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_Meta)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamMeta)), + .name = "Spa:Enum:ParamId:Meta", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_IO)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamIO)), + .name = "Spa:Enum:ParamId:IO", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_EnumProfile)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamProfile)), + .name = "Spa:Enum:ParamId:EnumProfile", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_Profile)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamProfile)), + .name = "Spa:Enum:ParamId:Profile", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_EnumPortConfig)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamPortConfig)), + .name = "Spa:Enum:ParamId:EnumPortConfig", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PortConfig)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamPortConfig)), + .name = "Spa:Enum:ParamId:PortConfig", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_EnumRoute)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamRoute)), + .name = "Spa:Enum:ParamId:EnumRoute", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_Route)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamRoute)), + .name = "Spa:Enum:ParamId:Route", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_Control)), + .parent = @as(u32, @bitCast(SPA_TYPE_Sequence)), + .name = "Spa:Enum:ParamId:Control", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_Latency)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamLatency)), + .name = "Spa:Enum:ParamId:Latency", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_ProcessLatency)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamProcessLatency)), + .name = "Spa:Enum:ParamId:ProcessLatency", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_Tag)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamTag)), + .name = "Spa:Enum:ParamId:Tag", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PeerFormats)), + .parent = @as(u32, @bitCast(SPA_TYPE_Struct)), + .name = "Spa:Enum:ParamId:PeerFormats", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const SPA_AUDIO_FORMAT_UNKNOWN: c_int = 0; +pub const SPA_AUDIO_FORMAT_ENCODED: c_int = 1; +pub const SPA_AUDIO_FORMAT_START_Interleaved: c_int = 256; +pub const SPA_AUDIO_FORMAT_S8: c_int = 257; +pub const SPA_AUDIO_FORMAT_U8: c_int = 258; +pub const SPA_AUDIO_FORMAT_S16_LE: c_int = 259; +pub const SPA_AUDIO_FORMAT_S16_BE: c_int = 260; +pub const SPA_AUDIO_FORMAT_U16_LE: c_int = 261; +pub const SPA_AUDIO_FORMAT_U16_BE: c_int = 262; +pub const SPA_AUDIO_FORMAT_S24_32_LE: c_int = 263; +pub const SPA_AUDIO_FORMAT_S24_32_BE: c_int = 264; +pub const SPA_AUDIO_FORMAT_U24_32_LE: c_int = 265; +pub const SPA_AUDIO_FORMAT_U24_32_BE: c_int = 266; +pub const SPA_AUDIO_FORMAT_S32_LE: c_int = 267; +pub const SPA_AUDIO_FORMAT_S32_BE: c_int = 268; +pub const SPA_AUDIO_FORMAT_U32_LE: c_int = 269; +pub const SPA_AUDIO_FORMAT_U32_BE: c_int = 270; +pub const SPA_AUDIO_FORMAT_S24_LE: c_int = 271; +pub const SPA_AUDIO_FORMAT_S24_BE: c_int = 272; +pub const SPA_AUDIO_FORMAT_U24_LE: c_int = 273; +pub const SPA_AUDIO_FORMAT_U24_BE: c_int = 274; +pub const SPA_AUDIO_FORMAT_S20_LE: c_int = 275; +pub const SPA_AUDIO_FORMAT_S20_BE: c_int = 276; +pub const SPA_AUDIO_FORMAT_U20_LE: c_int = 277; +pub const SPA_AUDIO_FORMAT_U20_BE: c_int = 278; +pub const SPA_AUDIO_FORMAT_S18_LE: c_int = 279; +pub const SPA_AUDIO_FORMAT_S18_BE: c_int = 280; +pub const SPA_AUDIO_FORMAT_U18_LE: c_int = 281; +pub const SPA_AUDIO_FORMAT_U18_BE: c_int = 282; +pub const SPA_AUDIO_FORMAT_F32_LE: c_int = 283; +pub const SPA_AUDIO_FORMAT_F32_BE: c_int = 284; +pub const SPA_AUDIO_FORMAT_F64_LE: c_int = 285; +pub const SPA_AUDIO_FORMAT_F64_BE: c_int = 286; +pub const SPA_AUDIO_FORMAT_ULAW: c_int = 287; +pub const SPA_AUDIO_FORMAT_ALAW: c_int = 288; +pub const SPA_AUDIO_FORMAT_START_Planar: c_int = 512; +pub const SPA_AUDIO_FORMAT_U8P: c_int = 513; +pub const SPA_AUDIO_FORMAT_S16P: c_int = 514; +pub const SPA_AUDIO_FORMAT_S24_32P: c_int = 515; +pub const SPA_AUDIO_FORMAT_S32P: c_int = 516; +pub const SPA_AUDIO_FORMAT_S24P: c_int = 517; +pub const SPA_AUDIO_FORMAT_F32P: c_int = 518; +pub const SPA_AUDIO_FORMAT_F64P: c_int = 519; +pub const SPA_AUDIO_FORMAT_S8P: c_int = 520; +pub const SPA_AUDIO_FORMAT_START_Other: c_int = 1024; +pub const SPA_AUDIO_FORMAT_DSP_S32: c_int = 515; +pub const SPA_AUDIO_FORMAT_DSP_F32: c_int = 518; +pub const SPA_AUDIO_FORMAT_DSP_F64: c_int = 519; +pub const SPA_AUDIO_FORMAT_S16: c_int = 259; +pub const SPA_AUDIO_FORMAT_U16: c_int = 261; +pub const SPA_AUDIO_FORMAT_S24_32: c_int = 263; +pub const SPA_AUDIO_FORMAT_U24_32: c_int = 265; +pub const SPA_AUDIO_FORMAT_S32: c_int = 267; +pub const SPA_AUDIO_FORMAT_U32: c_int = 269; +pub const SPA_AUDIO_FORMAT_S24: c_int = 271; +pub const SPA_AUDIO_FORMAT_U24: c_int = 273; +pub const SPA_AUDIO_FORMAT_S20: c_int = 275; +pub const SPA_AUDIO_FORMAT_U20: c_int = 277; +pub const SPA_AUDIO_FORMAT_S18: c_int = 279; +pub const SPA_AUDIO_FORMAT_U18: c_int = 281; +pub const SPA_AUDIO_FORMAT_F32: c_int = 283; +pub const SPA_AUDIO_FORMAT_F64: c_int = 285; +pub const SPA_AUDIO_FORMAT_S16_OE: c_int = 260; +pub const SPA_AUDIO_FORMAT_U16_OE: c_int = 262; +pub const SPA_AUDIO_FORMAT_S24_32_OE: c_int = 264; +pub const SPA_AUDIO_FORMAT_U24_32_OE: c_int = 266; +pub const SPA_AUDIO_FORMAT_S32_OE: c_int = 268; +pub const SPA_AUDIO_FORMAT_U32_OE: c_int = 270; +pub const SPA_AUDIO_FORMAT_S24_OE: c_int = 272; +pub const SPA_AUDIO_FORMAT_U24_OE: c_int = 274; +pub const SPA_AUDIO_FORMAT_S20_OE: c_int = 276; +pub const SPA_AUDIO_FORMAT_U20_OE: c_int = 278; +pub const SPA_AUDIO_FORMAT_S18_OE: c_int = 280; +pub const SPA_AUDIO_FORMAT_U18_OE: c_int = 282; +pub const SPA_AUDIO_FORMAT_F32_OE: c_int = 284; +pub const SPA_AUDIO_FORMAT_F64_OE: c_int = 286; +pub const enum_spa_audio_format = c_uint; +pub const SPA_AUDIO_CHANNEL_UNKNOWN: c_int = 0; +pub const SPA_AUDIO_CHANNEL_NA: c_int = 1; +pub const SPA_AUDIO_CHANNEL_MONO: c_int = 2; +pub const SPA_AUDIO_CHANNEL_FL: c_int = 3; +pub const SPA_AUDIO_CHANNEL_FR: c_int = 4; +pub const SPA_AUDIO_CHANNEL_FC: c_int = 5; +pub const SPA_AUDIO_CHANNEL_LFE: c_int = 6; +pub const SPA_AUDIO_CHANNEL_SL: c_int = 7; +pub const SPA_AUDIO_CHANNEL_SR: c_int = 8; +pub const SPA_AUDIO_CHANNEL_FLC: c_int = 9; +pub const SPA_AUDIO_CHANNEL_FRC: c_int = 10; +pub const SPA_AUDIO_CHANNEL_RC: c_int = 11; +pub const SPA_AUDIO_CHANNEL_RL: c_int = 12; +pub const SPA_AUDIO_CHANNEL_RR: c_int = 13; +pub const SPA_AUDIO_CHANNEL_TC: c_int = 14; +pub const SPA_AUDIO_CHANNEL_TFL: c_int = 15; +pub const SPA_AUDIO_CHANNEL_TFC: c_int = 16; +pub const SPA_AUDIO_CHANNEL_TFR: c_int = 17; +pub const SPA_AUDIO_CHANNEL_TRL: c_int = 18; +pub const SPA_AUDIO_CHANNEL_TRC: c_int = 19; +pub const SPA_AUDIO_CHANNEL_TRR: c_int = 20; +pub const SPA_AUDIO_CHANNEL_RLC: c_int = 21; +pub const SPA_AUDIO_CHANNEL_RRC: c_int = 22; +pub const SPA_AUDIO_CHANNEL_FLW: c_int = 23; +pub const SPA_AUDIO_CHANNEL_FRW: c_int = 24; +pub const SPA_AUDIO_CHANNEL_LFE2: c_int = 25; +pub const SPA_AUDIO_CHANNEL_FLH: c_int = 26; +pub const SPA_AUDIO_CHANNEL_FCH: c_int = 27; +pub const SPA_AUDIO_CHANNEL_FRH: c_int = 28; +pub const SPA_AUDIO_CHANNEL_TFLC: c_int = 29; +pub const SPA_AUDIO_CHANNEL_TFRC: c_int = 30; +pub const SPA_AUDIO_CHANNEL_TSL: c_int = 31; +pub const SPA_AUDIO_CHANNEL_TSR: c_int = 32; +pub const SPA_AUDIO_CHANNEL_LLFE: c_int = 33; +pub const SPA_AUDIO_CHANNEL_RLFE: c_int = 34; +pub const SPA_AUDIO_CHANNEL_BC: c_int = 35; +pub const SPA_AUDIO_CHANNEL_BLC: c_int = 36; +pub const SPA_AUDIO_CHANNEL_BRC: c_int = 37; +pub const SPA_AUDIO_CHANNEL_START_Aux: c_int = 4096; +pub const SPA_AUDIO_CHANNEL_AUX0: c_int = 4096; +pub const SPA_AUDIO_CHANNEL_AUX1: c_int = 4097; +pub const SPA_AUDIO_CHANNEL_AUX2: c_int = 4098; +pub const SPA_AUDIO_CHANNEL_AUX3: c_int = 4099; +pub const SPA_AUDIO_CHANNEL_AUX4: c_int = 4100; +pub const SPA_AUDIO_CHANNEL_AUX5: c_int = 4101; +pub const SPA_AUDIO_CHANNEL_AUX6: c_int = 4102; +pub const SPA_AUDIO_CHANNEL_AUX7: c_int = 4103; +pub const SPA_AUDIO_CHANNEL_AUX8: c_int = 4104; +pub const SPA_AUDIO_CHANNEL_AUX9: c_int = 4105; +pub const SPA_AUDIO_CHANNEL_AUX10: c_int = 4106; +pub const SPA_AUDIO_CHANNEL_AUX11: c_int = 4107; +pub const SPA_AUDIO_CHANNEL_AUX12: c_int = 4108; +pub const SPA_AUDIO_CHANNEL_AUX13: c_int = 4109; +pub const SPA_AUDIO_CHANNEL_AUX14: c_int = 4110; +pub const SPA_AUDIO_CHANNEL_AUX15: c_int = 4111; +pub const SPA_AUDIO_CHANNEL_AUX16: c_int = 4112; +pub const SPA_AUDIO_CHANNEL_AUX17: c_int = 4113; +pub const SPA_AUDIO_CHANNEL_AUX18: c_int = 4114; +pub const SPA_AUDIO_CHANNEL_AUX19: c_int = 4115; +pub const SPA_AUDIO_CHANNEL_AUX20: c_int = 4116; +pub const SPA_AUDIO_CHANNEL_AUX21: c_int = 4117; +pub const SPA_AUDIO_CHANNEL_AUX22: c_int = 4118; +pub const SPA_AUDIO_CHANNEL_AUX23: c_int = 4119; +pub const SPA_AUDIO_CHANNEL_AUX24: c_int = 4120; +pub const SPA_AUDIO_CHANNEL_AUX25: c_int = 4121; +pub const SPA_AUDIO_CHANNEL_AUX26: c_int = 4122; +pub const SPA_AUDIO_CHANNEL_AUX27: c_int = 4123; +pub const SPA_AUDIO_CHANNEL_AUX28: c_int = 4124; +pub const SPA_AUDIO_CHANNEL_AUX29: c_int = 4125; +pub const SPA_AUDIO_CHANNEL_AUX30: c_int = 4126; +pub const SPA_AUDIO_CHANNEL_AUX31: c_int = 4127; +pub const SPA_AUDIO_CHANNEL_AUX32: c_int = 4128; +pub const SPA_AUDIO_CHANNEL_AUX33: c_int = 4129; +pub const SPA_AUDIO_CHANNEL_AUX34: c_int = 4130; +pub const SPA_AUDIO_CHANNEL_AUX35: c_int = 4131; +pub const SPA_AUDIO_CHANNEL_AUX36: c_int = 4132; +pub const SPA_AUDIO_CHANNEL_AUX37: c_int = 4133; +pub const SPA_AUDIO_CHANNEL_AUX38: c_int = 4134; +pub const SPA_AUDIO_CHANNEL_AUX39: c_int = 4135; +pub const SPA_AUDIO_CHANNEL_AUX40: c_int = 4136; +pub const SPA_AUDIO_CHANNEL_AUX41: c_int = 4137; +pub const SPA_AUDIO_CHANNEL_AUX42: c_int = 4138; +pub const SPA_AUDIO_CHANNEL_AUX43: c_int = 4139; +pub const SPA_AUDIO_CHANNEL_AUX44: c_int = 4140; +pub const SPA_AUDIO_CHANNEL_AUX45: c_int = 4141; +pub const SPA_AUDIO_CHANNEL_AUX46: c_int = 4142; +pub const SPA_AUDIO_CHANNEL_AUX47: c_int = 4143; +pub const SPA_AUDIO_CHANNEL_AUX48: c_int = 4144; +pub const SPA_AUDIO_CHANNEL_AUX49: c_int = 4145; +pub const SPA_AUDIO_CHANNEL_AUX50: c_int = 4146; +pub const SPA_AUDIO_CHANNEL_AUX51: c_int = 4147; +pub const SPA_AUDIO_CHANNEL_AUX52: c_int = 4148; +pub const SPA_AUDIO_CHANNEL_AUX53: c_int = 4149; +pub const SPA_AUDIO_CHANNEL_AUX54: c_int = 4150; +pub const SPA_AUDIO_CHANNEL_AUX55: c_int = 4151; +pub const SPA_AUDIO_CHANNEL_AUX56: c_int = 4152; +pub const SPA_AUDIO_CHANNEL_AUX57: c_int = 4153; +pub const SPA_AUDIO_CHANNEL_AUX58: c_int = 4154; +pub const SPA_AUDIO_CHANNEL_AUX59: c_int = 4155; +pub const SPA_AUDIO_CHANNEL_AUX60: c_int = 4156; +pub const SPA_AUDIO_CHANNEL_AUX61: c_int = 4157; +pub const SPA_AUDIO_CHANNEL_AUX62: c_int = 4158; +pub const SPA_AUDIO_CHANNEL_AUX63: c_int = 4159; +pub const SPA_AUDIO_CHANNEL_LAST_Aux: c_int = 8191; +pub const SPA_AUDIO_CHANNEL_START_Custom: c_int = 65536; +pub const enum_spa_audio_channel = c_uint; +pub const SPA_AUDIO_VOLUME_RAMP_INVALID: c_int = 0; +pub const SPA_AUDIO_VOLUME_RAMP_LINEAR: c_int = 1; +pub const SPA_AUDIO_VOLUME_RAMP_CUBIC: c_int = 2; +pub const enum_spa_audio_volume_ramp_scale = c_uint; +pub const struct_spa_audio_info_raw = extern struct { + format: enum_spa_audio_format = @import("std").mem.zeroes(enum_spa_audio_format), + flags: u32 = @import("std").mem.zeroes(u32), + rate: u32 = @import("std").mem.zeroes(u32), + channels: u32 = @import("std").mem.zeroes(u32), + position: [128]u32 = @import("std").mem.zeroes([128]u32), +}; +pub const spa_type_audio_format: [71]struct_spa_type_info = [71]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_UNKNOWN)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:UNKNOWN", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_ENCODED)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:ENCODED", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S8)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S8", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U8)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U8", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S16_LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S16LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S16_BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S16BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U16_LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U16LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U16_BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U16BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S24_32_LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S24_32LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S24_32_BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S24_32BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U24_32_LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U24_32LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U24_32_BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U24_32BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S32_LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S32LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S32_BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S32BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U32_LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U32LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U32_BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U32BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S24_LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S24LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S24_BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S24BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U24_LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U24LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U24_BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U24BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S20_LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S20LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S20_BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S20BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U20_LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U20LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U20_BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U20BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S18_LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S18LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S18_BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S18BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U18_LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U18LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U18_BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U18BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_F32_LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:F32LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_F32_BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:F32BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_F64_LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:F64LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_F64_BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:F64BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_ULAW)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:ULAW", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_ALAW)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:ALAW", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U8P)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U8P", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S16P)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S16P", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S24_32P)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S24_32P", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S32P)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S32P", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S24P)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S24P", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_F32P)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:F32P", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_F64P)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:F64P", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S8P)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S8P", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S16)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S16", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S16_OE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S16OE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U16)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U16", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U16_OE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U16OE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S24_32)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S24_32", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S24_32_OE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S24_32OE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U24_32)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U24_32", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U24_32_OE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U24_32OE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S32)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S32", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S32_OE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S32OE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U32)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U32", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U32_OE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U32OE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S24)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S24", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S24_OE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S24OE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U24)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U24", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U24_OE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U24OE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S20)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S20", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S20_OE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S20OE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U20)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U20", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U20_OE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U20OE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S18)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S18", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_S18_OE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:S18OE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U18)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U18", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_U18_OE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:U18OE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_F32)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:F32", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_F32_OE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:F32OE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_F64)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:F64", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_FORMAT_F64_OE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioFormat:F64OE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub fn spa_type_audio_format_from_short_name(arg_name: [*c]const u8) callconv(.c) u32 { + var name = arg_name; + _ = &name; + return spa_type_from_short_name(name, @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_format[@as(usize, @intCast(0))]))), @as(u32, @bitCast(SPA_AUDIO_FORMAT_UNKNOWN))); +} +pub fn spa_type_audio_format_to_short_name(arg_type: u32) callconv(.c) [*c]const u8 { + var @"type" = arg_type; + _ = &@"type"; + return spa_type_to_short_name(@"type", @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_format[@as(usize, @intCast(0))]))), "UNKNOWN"); +} +pub const spa_type_audio_flags: [3]struct_spa_type_info = [3]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Flags:AudioFlags:none", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 1) << @intCast(0))), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Flags:AudioFlags:unpositioned", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_audio_channel: [103]struct_spa_type_info = [103]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_UNKNOWN)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:UNK", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_NA)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:NA", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_MONO)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:MONO", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_FL)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:FL", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_FR)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:FR", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_FC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:FC", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_LFE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:LFE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_SL)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:SL", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_SR)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:SR", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_FLC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:FLC", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_FRC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:FRC", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_RC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:RC", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_RL)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:RL", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_RR)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:RR", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_TC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:TC", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_TFL)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:TFL", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_TFC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:TFC", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_TFR)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:TFR", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_TRL)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:TRL", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_TRC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:TRC", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_TRR)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:TRR", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_RLC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:RLC", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_RRC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:RRC", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_FLW)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:FLW", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_FRW)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:FRW", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_LFE2)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:LFE2", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_FLH)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:FLH", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_FCH)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:FCH", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_FRH)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:FRH", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_TFLC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:TFLC", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_TFRC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:TFRC", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_TSL)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:TSL", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_TSR)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:TSR", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_LLFE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:LLFE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_RLFE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:RLFE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_BC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:BC", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_BLC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:BLC", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_BRC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:BRC", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX0)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX0", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX1)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX1", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX2)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX2", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX3)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX3", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX4)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX4", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX5)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX5", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX6)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX6", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX7)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX7", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX8)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX8", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX9)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX9", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX10)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX10", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX11)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX11", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX12)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX12", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX13)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX13", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX14)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX14", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX15)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX15", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX16)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX16", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX17)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX17", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX18)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX18", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX19)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX19", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX20)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX20", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX21)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX21", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX22)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX22", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX23)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX23", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX24)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX24", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX25)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX25", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX26)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX26", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX27)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX27", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX28)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX28", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX29)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX29", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX30)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX30", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX31)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX31", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX32)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX32", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX33)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX33", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX34)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX34", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX35)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX35", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX36)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX36", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX37)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX37", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX38)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX38", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX39)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX39", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX40)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX40", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX41)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX41", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX42)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX42", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX43)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX43", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX44)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX44", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX45)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX45", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX46)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX46", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX47)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX47", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX48)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX48", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX49)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX49", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX50)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX50", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX51)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX51", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX52)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX52", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX53)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX53", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX54)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX54", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX55)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX55", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX56)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX56", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX57)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX57", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX58)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX58", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX59)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX59", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX60)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX60", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX61)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX61", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX62)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX62", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_CHANNEL_AUX63)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioChannel:AUX63", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub fn spa_type_audio_channel_from_short_name(arg_name: [*c]const u8) callconv(.c) u32 { + var name = arg_name; + _ = &name; + return spa_type_from_short_name(name, @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_channel[@as(usize, @intCast(0))]))), @as(u32, @bitCast(SPA_AUDIO_CHANNEL_UNKNOWN))); +} +pub fn spa_type_audio_channel_to_short_name(arg_type: u32) callconv(.c) [*c]const u8 { + var @"type" = arg_type; + _ = &@"type"; + return spa_type_to_short_name(@"type", @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_channel[@as(usize, @intCast(0))]))), "UNK"); +} +pub const spa_type_audio_volume_ramp_scale: [4]struct_spa_type_info = [4]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_VOLUME_RAMP_INVALID)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioVolumeRampScale:INVALID", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_VOLUME_RAMP_LINEAR)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioVolumeRampScale:LINEAR", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_VOLUME_RAMP_CUBIC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioVolumeRampScale:CUBIC", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const SPA_AUDIO_IEC958_CODEC_UNKNOWN: c_int = 0; +pub const SPA_AUDIO_IEC958_CODEC_PCM: c_int = 1; +pub const SPA_AUDIO_IEC958_CODEC_DTS: c_int = 2; +pub const SPA_AUDIO_IEC958_CODEC_AC3: c_int = 3; +pub const SPA_AUDIO_IEC958_CODEC_MPEG: c_int = 4; +pub const SPA_AUDIO_IEC958_CODEC_MPEG2_AAC: c_int = 5; +pub const SPA_AUDIO_IEC958_CODEC_EAC3: c_int = 6; +pub const SPA_AUDIO_IEC958_CODEC_TRUEHD: c_int = 7; +pub const SPA_AUDIO_IEC958_CODEC_DTSHD: c_int = 8; +pub const enum_spa_audio_iec958_codec = c_uint; +pub const struct_spa_audio_info_iec958 = extern struct { + codec: enum_spa_audio_iec958_codec = @import("std").mem.zeroes(enum_spa_audio_iec958_codec), + flags: u32 = @import("std").mem.zeroes(u32), + rate: u32 = @import("std").mem.zeroes(u32), +}; +pub const spa_type_audio_iec958_codec: [10]struct_spa_type_info = [10]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_IEC958_CODEC_UNKNOWN)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioIEC958Codec:UNKNOWN", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_IEC958_CODEC_PCM)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioIEC958Codec:PCM", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_IEC958_CODEC_DTS)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioIEC958Codec:DTS", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_IEC958_CODEC_AC3)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioIEC958Codec:AC3", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_IEC958_CODEC_MPEG)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioIEC958Codec:MPEG", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_IEC958_CODEC_MPEG2_AAC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioIEC958Codec:MPEG2-AAC", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_IEC958_CODEC_EAC3)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioIEC958Codec:EAC3", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_IEC958_CODEC_TRUEHD)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioIEC958Codec:TrueHD", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_IEC958_CODEC_DTSHD)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioIEC958Codec:DTS-HD", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub fn spa_type_audio_iec958_codec_from_short_name(arg_name: [*c]const u8) callconv(.c) u32 { + var name = arg_name; + _ = &name; + return spa_type_from_short_name(name, @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_iec958_codec[@as(usize, @intCast(0))]))), @as(u32, @bitCast(SPA_AUDIO_IEC958_CODEC_UNKNOWN))); +} +pub fn spa_type_audio_iec958_codec_to_short_name(arg_type: u32) callconv(.c) [*c]const u8 { + var @"type" = arg_type; + _ = &@"type"; + return spa_type_to_short_name(@"type", @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_iec958_codec[@as(usize, @intCast(0))]))), "UNKNOWN"); +} +pub const SPA_AUDIO_MP3_CHANNEL_MODE_UNKNOWN: c_int = 0; +pub const SPA_AUDIO_MP3_CHANNEL_MODE_MONO: c_int = 1; +pub const SPA_AUDIO_MP3_CHANNEL_MODE_STEREO: c_int = 2; +pub const SPA_AUDIO_MP3_CHANNEL_MODE_JOINTSTEREO: c_int = 3; +pub const SPA_AUDIO_MP3_CHANNEL_MODE_DUAL: c_int = 4; +pub const enum_spa_audio_mp3_channel_mode = c_uint; +pub const struct_spa_audio_info_mp3 = extern struct { + rate: u32 = @import("std").mem.zeroes(u32), + channels: u32 = @import("std").mem.zeroes(u32), + channel_mode: enum_spa_audio_mp3_channel_mode = @import("std").mem.zeroes(enum_spa_audio_mp3_channel_mode), +}; +pub const spa_type_audio_mp3_channel_mode: [6]struct_spa_type_info = [6]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_MP3_CHANNEL_MODE_UNKNOWN)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioMP3ChannelMode:UNKNOWN", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_MP3_CHANNEL_MODE_MONO)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioMP3ChannelMode:Mono", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_MP3_CHANNEL_MODE_STEREO)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioMP3ChannelMode:Stereo", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_MP3_CHANNEL_MODE_JOINTSTEREO)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioMP3ChannelMode:Joint-stereo", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_MP3_CHANNEL_MODE_DUAL)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioMP3ChannelMode:Dual", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const SPA_AUDIO_AAC_STREAM_FORMAT_UNKNOWN: c_int = 0; +pub const SPA_AUDIO_AAC_STREAM_FORMAT_RAW: c_int = 1; +pub const SPA_AUDIO_AAC_STREAM_FORMAT_MP2ADTS: c_int = 2; +pub const SPA_AUDIO_AAC_STREAM_FORMAT_MP4ADTS: c_int = 3; +pub const SPA_AUDIO_AAC_STREAM_FORMAT_MP4LOAS: c_int = 4; +pub const SPA_AUDIO_AAC_STREAM_FORMAT_MP4LATM: c_int = 5; +pub const SPA_AUDIO_AAC_STREAM_FORMAT_ADIF: c_int = 6; +pub const SPA_AUDIO_AAC_STREAM_FORMAT_MP4FF: c_int = 7; +pub const SPA_AUDIO_AAC_STREAM_FORMAT_CUSTOM: c_int = 65536; +pub const enum_spa_audio_aac_stream_format = c_uint; +pub const struct_spa_audio_info_aac = extern struct { + rate: u32 = @import("std").mem.zeroes(u32), + channels: u32 = @import("std").mem.zeroes(u32), + bitrate: u32 = @import("std").mem.zeroes(u32), + stream_format: enum_spa_audio_aac_stream_format = @import("std").mem.zeroes(enum_spa_audio_aac_stream_format), +}; +pub const spa_type_audio_aac_stream_format: [9]struct_spa_type_info = [9]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_AAC_STREAM_FORMAT_UNKNOWN)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioAACStreamFormat:UNKNOWN", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_AAC_STREAM_FORMAT_RAW)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioAACStreamFormat:RAW", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_AAC_STREAM_FORMAT_MP2ADTS)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioAACStreamFormat:MP2ADTS", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_AAC_STREAM_FORMAT_MP4ADTS)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioAACStreamFormat:MP4ADTS", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_AAC_STREAM_FORMAT_MP4LOAS)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioAACStreamFormat:MP4LOAS", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_AAC_STREAM_FORMAT_MP4LATM)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioAACStreamFormat:MP4LATM", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_AAC_STREAM_FORMAT_ADIF)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioAACStreamFormat:ADIF", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_AAC_STREAM_FORMAT_MP4FF)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioAACStreamFormat:MP4FF", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const SPA_AUDIO_WMA_PROFILE_UNKNOWN: c_int = 0; +pub const SPA_AUDIO_WMA_PROFILE_WMA7: c_int = 1; +pub const SPA_AUDIO_WMA_PROFILE_WMA8: c_int = 2; +pub const SPA_AUDIO_WMA_PROFILE_WMA9: c_int = 3; +pub const SPA_AUDIO_WMA_PROFILE_WMA10: c_int = 4; +pub const SPA_AUDIO_WMA_PROFILE_WMA9_PRO: c_int = 5; +pub const SPA_AUDIO_WMA_PROFILE_WMA9_LOSSLESS: c_int = 6; +pub const SPA_AUDIO_WMA_PROFILE_WMA10_LOSSLESS: c_int = 7; +pub const SPA_AUDIO_WMA_PROFILE_CUSTOM: c_int = 65536; +pub const enum_spa_audio_wma_profile = c_uint; +pub const struct_spa_audio_info_wma = extern struct { + rate: u32 = @import("std").mem.zeroes(u32), + channels: u32 = @import("std").mem.zeroes(u32), + bitrate: u32 = @import("std").mem.zeroes(u32), + block_align: u32 = @import("std").mem.zeroes(u32), + profile: enum_spa_audio_wma_profile = @import("std").mem.zeroes(enum_spa_audio_wma_profile), +}; +pub const spa_type_audio_wma_profile: [9]struct_spa_type_info = [9]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_WMA_PROFILE_UNKNOWN)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioWMAProfile:UNKNOWN", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_WMA_PROFILE_WMA7)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioWMAProfile:WMA7", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_WMA_PROFILE_WMA8)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioWMAProfile:WMA8", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_WMA_PROFILE_WMA9)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioWMAProfile:WMA9", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_WMA_PROFILE_WMA10)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioWMAProfile:WMA10", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_WMA_PROFILE_WMA9_PRO)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioWMAProfile:WMA9-Pro", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_WMA_PROFILE_WMA9_LOSSLESS)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioWMAProfile:WMA9-Lossless", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_WMA_PROFILE_WMA10_LOSSLESS)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioWMAProfile:WMA10-Lossless", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const SPA_AUDIO_AMR_BAND_MODE_UNKNOWN: c_int = 0; +pub const SPA_AUDIO_AMR_BAND_MODE_NB: c_int = 1; +pub const SPA_AUDIO_AMR_BAND_MODE_WB: c_int = 2; +pub const enum_spa_audio_amr_band_mode = c_uint; +pub const struct_spa_audio_info_amr = extern struct { + rate: u32 = @import("std").mem.zeroes(u32), + channels: u32 = @import("std").mem.zeroes(u32), + band_mode: enum_spa_audio_amr_band_mode = @import("std").mem.zeroes(enum_spa_audio_amr_band_mode), +}; +pub const spa_type_audio_amr_band_mode: [4]struct_spa_type_info = [4]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_AMR_BAND_MODE_UNKNOWN)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioAMRBandMode:UNKNOWN", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_AMR_BAND_MODE_NB)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioAMRBandMode:NB", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_AMR_BAND_MODE_WB)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioAMRBandMode:WB", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const SPA_AUDIO_DTS_EXT_UNKNOWN: c_int = 0; +pub const SPA_AUDIO_DTS_EXT_NONE: c_int = 1; +pub const SPA_AUDIO_DTS_EXT_HD_HRA: c_int = 2; +pub const SPA_AUDIO_DTS_EXT_HD_MA: c_int = 3; +pub const enum_spa_audio_dts_ext_type = c_uint; +pub const struct_spa_audio_info_dts = extern struct { + rate: u32 = @import("std").mem.zeroes(u32), + channels: u32 = @import("std").mem.zeroes(u32), + ext_type: enum_spa_audio_dts_ext_type = @import("std").mem.zeroes(enum_spa_audio_dts_ext_type), +}; +pub const spa_type_audio_dts_ext_type: [5]struct_spa_type_info = [5]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_DTS_EXT_UNKNOWN)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioDTSExtType:UNKNOWN", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_DTS_EXT_NONE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioDTSExtType:NONE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_DTS_EXT_HD_HRA)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioDTSExtType:HRA", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_AUDIO_DTS_EXT_HD_MA)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:AudioDTSExtType:MA", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_prop_float_array: [2]struct_spa_type_info = [2]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Float)), + .name = "Spa:floatArray", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_prop_int_array: [2]struct_spa_type_info = [2]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:intArray", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_prop_channel_map: [2]struct_spa_type_info = [2]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:channelMap", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_channel[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_prop_iec958_codec: [2]struct_spa_type_info = [2]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:iec958Codec", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_iec958_codec[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_param_bitorder: [4]struct_spa_type_info = [4]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_BITORDER_unknown)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:ParamBitorder:unknown", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_BITORDER_msb)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:ParamBitorder:msb", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_BITORDER_lsb)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:ParamBitorder:lsb", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_param_availability: [4]struct_spa_type_info = [4]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_AVAILABILITY_unknown)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:ParamAvailability:unknown", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_AVAILABILITY_no)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:ParamAvailability:no", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_AVAILABILITY_yes)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:ParamAvailability:yes", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_param_meta: [4]struct_spa_type_info = [4]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_META_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Meta:", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_META_type)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Meta:type", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_meta_type[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_META_size)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Meta:size", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_param_io: [4]struct_spa_type_info = [4]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_IO_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:IO:", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_IO_id)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:IO:id", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_io[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_IO_size)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:IO:size", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_param_buffers: [9]struct_spa_type_info = [9]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_BUFFERS_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Buffers:", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_BUFFERS_buffers)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Buffers:buffers", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_BUFFERS_blocks)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Buffers:blocks", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_BUFFERS_size)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Buffers:BlockInfo:size", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_BUFFERS_stride)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Buffers:BlockInfo:stride", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_BUFFERS_align)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Buffers:BlockInfo:align", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_BUFFERS_dataType)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Buffers:BlockInfo:dataType", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_BUFFERS_metaType)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Buffers:BlockInfo:metaType", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const SPA_BLUETOOTH_AUDIO_CODEC_START: c_int = 0; +pub const SPA_BLUETOOTH_AUDIO_CODEC_SBC: c_int = 1; +pub const SPA_BLUETOOTH_AUDIO_CODEC_SBC_XQ: c_int = 2; +pub const SPA_BLUETOOTH_AUDIO_CODEC_MPEG: c_int = 3; +pub const SPA_BLUETOOTH_AUDIO_CODEC_AAC: c_int = 4; +pub const SPA_BLUETOOTH_AUDIO_CODEC_AAC_ELD: c_int = 5; +pub const SPA_BLUETOOTH_AUDIO_CODEC_APTX: c_int = 6; +pub const SPA_BLUETOOTH_AUDIO_CODEC_APTX_HD: c_int = 7; +pub const SPA_BLUETOOTH_AUDIO_CODEC_LDAC: c_int = 8; +pub const SPA_BLUETOOTH_AUDIO_CODEC_APTX_LL: c_int = 9; +pub const SPA_BLUETOOTH_AUDIO_CODEC_APTX_LL_DUPLEX: c_int = 10; +pub const SPA_BLUETOOTH_AUDIO_CODEC_FASTSTREAM: c_int = 11; +pub const SPA_BLUETOOTH_AUDIO_CODEC_FASTSTREAM_DUPLEX: c_int = 12; +pub const SPA_BLUETOOTH_AUDIO_CODEC_LC3PLUS_HR: c_int = 13; +pub const SPA_BLUETOOTH_AUDIO_CODEC_OPUS_05: c_int = 14; +pub const SPA_BLUETOOTH_AUDIO_CODEC_OPUS_05_51: c_int = 15; +pub const SPA_BLUETOOTH_AUDIO_CODEC_OPUS_05_71: c_int = 16; +pub const SPA_BLUETOOTH_AUDIO_CODEC_OPUS_05_DUPLEX: c_int = 17; +pub const SPA_BLUETOOTH_AUDIO_CODEC_OPUS_05_PRO: c_int = 18; +pub const SPA_BLUETOOTH_AUDIO_CODEC_OPUS_G: c_int = 19; +pub const SPA_BLUETOOTH_AUDIO_CODEC_CVSD: c_int = 256; +pub const SPA_BLUETOOTH_AUDIO_CODEC_MSBC: c_int = 257; +pub const SPA_BLUETOOTH_AUDIO_CODEC_LC3_SWB: c_int = 258; +pub const SPA_BLUETOOTH_AUDIO_CODEC_LC3_A127: c_int = 259; +pub const SPA_BLUETOOTH_AUDIO_CODEC_LC3: c_int = 512; +pub const SPA_BLUETOOTH_AUDIO_CODEC_G722: c_int = 768; +pub const enum_spa_bluetooth_audio_codec = c_uint; +pub const spa_type_bluetooth_audio_codec: [26]struct_spa_type_info = [26]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_SBC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:sbc", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_SBC_XQ)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:sbc_xq", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_MPEG)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:mpeg", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_AAC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:aac", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_AAC_ELD)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:aac_eld", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_APTX)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:aptx", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_APTX_HD)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:aptx_hd", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_LDAC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:ldac", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_APTX_LL)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:aptx_ll", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_APTX_LL_DUPLEX)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:aptx_ll_duplex", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_FASTSTREAM)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:faststream", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_FASTSTREAM_DUPLEX)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:faststream_duplex", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_LC3PLUS_HR)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:lc3plus_hr", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_OPUS_05)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:opus_05", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_OPUS_05_51)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:opus_05_51", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_OPUS_05_71)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:opus_05_71", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_OPUS_05_DUPLEX)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:opus_05_duplex", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_OPUS_05_PRO)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:opus_05_pro", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_OPUS_G)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:opus_g", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_CVSD)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:cvsd", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_MSBC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:msbc", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_LC3_SWB)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:lc3_swb", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_LC3_A127)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:lc3_a127", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_LC3)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:lc3", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_BLUETOOTH_AUDIO_CODEC_G722)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:BluetoothAudioCodec:g722", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_props: [49]struct_spa_type_info = [49]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Props:", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_unknown)), + .parent = @as(u32, @bitCast(SPA_TYPE_None)), + .name = "Spa:Pod:Object:Param:Props:unknown", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_device)), + .parent = @as(u32, @bitCast(SPA_TYPE_String)), + .name = "Spa:Pod:Object:Param:Props:device", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_deviceName)), + .parent = @as(u32, @bitCast(SPA_TYPE_String)), + .name = "Spa:Pod:Object:Param:Props:deviceName", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_deviceFd)), + .parent = @as(u32, @bitCast(SPA_TYPE_Fd)), + .name = "Spa:Pod:Object:Param:Props:deviceFd", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_card)), + .parent = @as(u32, @bitCast(SPA_TYPE_String)), + .name = "Spa:Pod:Object:Param:Props:card", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_cardName)), + .parent = @as(u32, @bitCast(SPA_TYPE_String)), + .name = "Spa:Pod:Object:Param:Props:cardName", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_minLatency)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Props:minLatency", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_maxLatency)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Props:maxLatency", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_periods)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Props:periods", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_periodSize)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Props:periodSize", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_periodEvent)), + .parent = @as(u32, @bitCast(SPA_TYPE_Bool)), + .name = "Spa:Pod:Object:Param:Props:periodEvent", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_live)), + .parent = @as(u32, @bitCast(SPA_TYPE_Bool)), + .name = "Spa:Pod:Object:Param:Props:live", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_rate)), + .parent = @as(u32, @bitCast(SPA_TYPE_Double)), + .name = "Spa:Pod:Object:Param:Props:rate", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_quality)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Props:quality", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_bluetoothAudioCodec)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Props:bluetoothAudioCodec", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_bluetooth_audio_codec[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_bluetoothOffloadActive)), + .parent = @as(u32, @bitCast(SPA_TYPE_Bool)), + .name = "Spa:Pod:Object:Param:Props:bluetoothOffloadActive", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_waveType)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Props:waveType", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_frequency)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Props:frequency", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_volume)), + .parent = @as(u32, @bitCast(SPA_TYPE_Float)), + .name = "Spa:Pod:Object:Param:Props:volume", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_mute)), + .parent = @as(u32, @bitCast(SPA_TYPE_Bool)), + .name = "Spa:Pod:Object:Param:Props:mute", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_patternType)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Props:patternType", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_ditherType)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Props:ditherType", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_truncate)), + .parent = @as(u32, @bitCast(SPA_TYPE_Bool)), + .name = "Spa:Pod:Object:Param:Props:truncate", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_channelVolumes)), + .parent = @as(u32, @bitCast(SPA_TYPE_Array)), + .name = "Spa:Pod:Object:Param:Props:channelVolumes", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_prop_float_array[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_volumeBase)), + .parent = @as(u32, @bitCast(SPA_TYPE_Float)), + .name = "Spa:Pod:Object:Param:Props:volumeBase", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_volumeStep)), + .parent = @as(u32, @bitCast(SPA_TYPE_Float)), + .name = "Spa:Pod:Object:Param:Props:volumeStep", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_channelMap)), + .parent = @as(u32, @bitCast(SPA_TYPE_Array)), + .name = "Spa:Pod:Object:Param:Props:channelMap", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_prop_channel_map[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_monitorMute)), + .parent = @as(u32, @bitCast(SPA_TYPE_Bool)), + .name = "Spa:Pod:Object:Param:Props:monitorMute", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_monitorVolumes)), + .parent = @as(u32, @bitCast(SPA_TYPE_Array)), + .name = "Spa:Pod:Object:Param:Props:monitorVolumes", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_prop_float_array[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_latencyOffsetNsec)), + .parent = @as(u32, @bitCast(SPA_TYPE_Long)), + .name = "Spa:Pod:Object:Param:Props:latencyOffsetNsec", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_softMute)), + .parent = @as(u32, @bitCast(SPA_TYPE_Bool)), + .name = "Spa:Pod:Object:Param:Props:softMute", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_softVolumes)), + .parent = @as(u32, @bitCast(SPA_TYPE_Array)), + .name = "Spa:Pod:Object:Param:Props:softVolumes", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_prop_float_array[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_iec958Codecs)), + .parent = @as(u32, @bitCast(SPA_TYPE_Array)), + .name = "Spa:Pod:Object:Param:Props:iec958Codecs", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_prop_iec958_codec[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_volumeRampSamples)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Props:volumeRampSamples", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_volumeRampStepSamples)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Props:volumeRampStepSamples", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_volumeRampTime)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Props:volumeRampTime", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_volumeRampStepTime)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Props:volumeRampStepTime", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_volumeRampScale)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Props:volumeRampScale", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_volume_ramp_scale[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_brightness)), + .parent = @as(u32, @bitCast(SPA_TYPE_Float)), + .name = "Spa:Pod:Object:Param:Props:brightness", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_contrast)), + .parent = @as(u32, @bitCast(SPA_TYPE_Float)), + .name = "Spa:Pod:Object:Param:Props:contrast", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_saturation)), + .parent = @as(u32, @bitCast(SPA_TYPE_Float)), + .name = "Spa:Pod:Object:Param:Props:saturation", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_hue)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Props:hue", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_gamma)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Props:gamma", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_exposure)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Props:exposure", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_gain)), + .parent = @as(u32, @bitCast(SPA_TYPE_Float)), + .name = "Spa:Pod:Object:Param:Props:gain", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_sharpness)), + .parent = @as(u32, @bitCast(SPA_TYPE_Float)), + .name = "Spa:Pod:Object:Param:Props:sharpness", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_params)), + .parent = @as(u32, @bitCast(SPA_TYPE_Struct)), + .name = "Spa:Pod:Object:Param:Props:params", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_prop_info: [9]struct_spa_type_info = [9]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_INFO_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:PropInfo:", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_INFO_id)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:PropInfo:id", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_props[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_INFO_name)), + .parent = @as(u32, @bitCast(SPA_TYPE_String)), + .name = "Spa:Pod:Object:Param:PropInfo:name", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_INFO_type)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pod)), + .name = "Spa:Pod:Object:Param:PropInfo:type", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_INFO_labels)), + .parent = @as(u32, @bitCast(SPA_TYPE_Struct)), + .name = "Spa:Pod:Object:Param:PropInfo:labels", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_INFO_container)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:PropInfo:container", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_INFO_params)), + .parent = @as(u32, @bitCast(SPA_TYPE_Bool)), + .name = "Spa:Pod:Object:Param:PropInfo:params", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROP_INFO_description)), + .parent = @as(u32, @bitCast(SPA_TYPE_String)), + .name = "Spa:Pod:Object:Param:PropInfo:description", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_video_color_range: [4]struct_spa_type_info = [4]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_RANGE_UNKNOWN)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorRange:unknown", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_RANGE_0_255)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorRange:0-255", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_RANGE_16_235)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorRange:16-235", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_video_color_matrix: [8]struct_spa_type_info = [8]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_MATRIX_UNKNOWN)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorMatrix:unknown", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_MATRIX_RGB)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorMatrix:rgb", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_MATRIX_FCC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorMatrix:fcc", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_MATRIX_BT709)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorMatrix:bt709", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_MATRIX_BT601)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorMatrix:bt601", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_MATRIX_SMPTE240M)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorMatrix:smpte240m", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_MATRIX_BT2020)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorMatrix:bt2020", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_video_transfer_function: [18]struct_spa_type_info = [18]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_TRANSFER_UNKNOWN)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoTransferFunction:unknown", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_TRANSFER_GAMMA10)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoTransferFunction:gamma10", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_TRANSFER_GAMMA18)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoTransferFunction:gamma18", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_TRANSFER_GAMMA20)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoTransferFunction:gamma20", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_TRANSFER_GAMMA22)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoTransferFunction:gamma22", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_TRANSFER_BT709)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoTransferFunction:bt709", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_TRANSFER_SMPTE240M)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoTransferFunction:smpte240m", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_TRANSFER_SRGB)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoTransferFunction:srgb", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_TRANSFER_GAMMA28)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoTransferFunction:gamma28", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_TRANSFER_LOG100)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoTransferFunction:log100", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_TRANSFER_LOG316)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoTransferFunction:log316", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_TRANSFER_BT2020_12)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoTransferFunction:bt2020-12", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_TRANSFER_ADOBERGB)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoTransferFunction:adobergb", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_TRANSFER_BT2020_10)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoTransferFunction:bt2020-10", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_TRANSFER_SMPTE2084)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoTransferFunction:smpte2084", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_TRANSFER_ARIB_STD_B67)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoTransferFunction:arib-std-b67", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_TRANSFER_BT601)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoTransferFunction:bt601", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_video_color_primaries: [14]struct_spa_type_info = [14]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_PRIMARIES_UNKNOWN)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorPrimaries:unknown", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_PRIMARIES_BT709)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorPrimaries:bt709", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_PRIMARIES_BT470M)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorPrimaries:bt470m", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_PRIMARIES_BT470BG)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorPrimaries:bt470bg", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_PRIMARIES_SMPTE170M)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorPrimaries:smpte170m", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_PRIMARIES_SMPTE240M)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorPrimaries:smpte240m", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_PRIMARIES_FILM)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorPrimaries:film", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_PRIMARIES_BT2020)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorPrimaries:bt2020", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_PRIMARIES_ADOBERGB)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorPrimaries:adobergb", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_PRIMARIES_SMPTEST428)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorPrimaries:smptest428", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_PRIMARIES_SMPTERP431)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorPrimaries:smpterp431", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_PRIMARIES_SMPTEEG432)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorPrimaries:smpteeg432", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_COLOR_PRIMARIES_EBU3213)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoColorPrimaries:ebu3213", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_video_format: [89]struct_spa_type_info = [89]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_UNKNOWN)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:UNKNOWN", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_ENCODED)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:ENCODED", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_I420)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:I420", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_YV12)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:YV12", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_YUY2)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:YUY2", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_UYVY)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:UYVY", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_AYUV)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:AYUV", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_RGBx)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:RGBx", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_BGRx)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:BGRx", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_xRGB)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:xRGB", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_xBGR)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:xBGR", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_RGBA)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:RGBA", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_BGRA)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:BGRA", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_ARGB)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:ARGB", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_ABGR)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:ABGR", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_RGB)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:RGB", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_BGR)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:BGR", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_Y41B)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:Y41B", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_Y42B)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:Y42B", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_YVYU)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:YVYU", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_Y444)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:Y444", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_v210)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:v210", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_v216)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:v216", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_NV12)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:NV12", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_NV21)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:NV21", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_GRAY8)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:GRAY8", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_GRAY16_BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:GRAY16_BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_GRAY16_LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:GRAY16_LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_v308)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:v308", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_RGB16)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:RGB16", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_BGR16)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:BGR16", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_RGB15)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:RGB15", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_BGR15)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:BGR15", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_UYVP)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:UYVP", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_A420)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:A420", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_RGB8P)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:RGB8P", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_YUV9)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:YUV9", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_YVU9)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:YVU9", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_IYU1)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:IYU1", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_ARGB64)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:ARGB64", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_AYUV64)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:AYUV64", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_r210)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:r210", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_I420_10BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:I420_10BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_I420_10LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:I420_10LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_I422_10BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:I422_10BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_I422_10LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:I422_10LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_Y444_10BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:Y444_10BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_Y444_10LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:Y444_10LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_GBR)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:GBR", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_GBR_10BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:GBR_10BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_GBR_10LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:GBR_10LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_NV16)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:NV16", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_NV24)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:NV24", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_NV12_64Z32)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:NV12_64Z32", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_A420_10BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:A420_10BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_A420_10LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:A420_10LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_A422_10BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:A422_10BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_A422_10LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:A422_10LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_A444_10BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:A444_10BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_A444_10LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:A444_10LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_NV61)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:NV61", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_P010_10BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:P010_10BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_P010_10LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:P010_10LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_IYU2)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:IYU2", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_VYUY)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:VYUY", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_GBRA)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:GBRA", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_GBRA_10BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:GBRA_10BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_GBRA_10LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:GBRA_10LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_GBR_12BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:GBR_12BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_GBR_12LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:GBR_12LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_GBRA_12BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:GBRA_12BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_GBRA_12LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:GBRA_12LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_I420_12BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:I420_12BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_I420_12LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:I420_12LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_I422_12BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:I422_12BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_I422_12LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:I422_12LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_Y444_12BE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:Y444_12BE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_Y444_12LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:Y444_12LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_RGBA_F16)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:RGBA_F16", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_RGBA_F32)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:RGBA_F32", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_xRGB_210LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:xRGB_210LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_xBGR_210LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:xBGR_210LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_RGBx_102LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:RGBx_102LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_BGRx_102LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:BGRx_102LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_ARGB_210LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:ARGB_210LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_ABGR_210LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:ABGR_210LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_RGBA_102LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:RGBA_102LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FORMAT_BGRA_102LE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoFormat:BGRA_102LE", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub fn spa_type_video_format_from_short_name(arg_name: [*c]const u8) callconv(.c) u32 { + var name = arg_name; + _ = &name; + return spa_type_from_short_name(name, @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_video_format[@as(usize, @intCast(0))]))), @as(u32, @bitCast(SPA_VIDEO_FORMAT_UNKNOWN))); +} +pub fn spa_type_video_format_to_short_name(arg_type: u32) callconv(.c) [*c]const u8 { + var @"type" = arg_type; + _ = &@"type"; + return spa_type_to_short_name(@"type", @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_video_format[@as(usize, @intCast(0))]))), "UNKNOWN"); +} +pub const spa_type_video_flags: [5]struct_spa_type_info = [5]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FLAG_NONE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Flags:VideoFlags:none", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FLAG_VARIABLE_FPS)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Flags:VideoFlags:variable-fps", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FLAG_PREMULTIPLIED_ALPHA)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Flags:VideoFlags:premultiplied-alpha", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_FLAG_MODIFIER)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Flags:VideoFlags:modifier", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_video_interlace_mode: [5]struct_spa_type_info = [5]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_INTERLACE_MODE_PROGRESSIVE)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoInterlaceMode:progressive", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_INTERLACE_MODE_INTERLEAVED)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoInterlaceMode:interleaved", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_INTERLACE_MODE_MIXED)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoInterlaceMode:mixed", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_VIDEO_INTERLACE_MODE_FIELDS)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:VideoInterlaceMode:fields", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const SPA_CONTROL_Invalid: c_int = 0; +pub const SPA_CONTROL_Properties: c_int = 1; +pub const SPA_CONTROL_Midi: c_int = 2; +pub const SPA_CONTROL_OSC: c_int = 3; +pub const SPA_CONTROL_UMP: c_int = 4; +pub const _SPA_CONTROL_LAST: c_int = 5; +pub const enum_spa_control_type = c_uint; +pub const spa_type_control: [6]struct_spa_type_info = [6]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_CONTROL_Invalid)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Control:Invalid", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_CONTROL_Properties)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Control:Properties", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_CONTROL_Midi)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Control:Midi", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_CONTROL_OSC)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Control:OSC", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_CONTROL_UMP)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:Control:UMP", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_media_type: [8]struct_spa_type_info = [8]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_TYPE_unknown)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaType:unknown", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_TYPE_audio)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaType:audio", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_TYPE_video)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaType:video", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_TYPE_image)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaType:image", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_TYPE_binary)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaType:binary", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_TYPE_stream)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaType:stream", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_TYPE_application)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaType:application", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_media_subtype: [43]struct_spa_type_info = [43]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_unknown)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:unknown", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_raw)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:raw", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_dsp)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:dsp", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_iec958)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:iec958", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_dsd)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:dsd", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_mp3)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:mp3", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_aac)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:aac", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_vorbis)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:vorbis", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_wma)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:wma", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_ra)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:ra", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_sbc)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:sbc", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_adpcm)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:adpcm", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_g723)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:g723", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_g726)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:g726", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_g729)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:g729", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_amr)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:amr", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_gsm)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:gsm", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_alac)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:alac", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_flac)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:flac", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_ape)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:ape", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_opus)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:opus", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_ac3)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:ac3", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_eac3)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:eac3", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_truehd)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:truehd", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_dts)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:dts", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_mpegh)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:mpegh", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_h264)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:h264", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_mjpg)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:mjpg", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_dv)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:dv", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_mpegts)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:mpegts", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_h263)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:h263", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_mpeg1)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:mpeg1", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_mpeg2)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:mpeg2", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_mpeg4)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:mpeg4", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_xvid)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:xvid", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_vc1)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:vc1", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_vp8)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:vp8", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_vp9)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:vp9", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_bayer)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:bayer", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_jpeg)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:jpeg", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_midi)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:midi", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_MEDIA_SUBTYPE_control)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:MediaSubtype:control", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_format: [39]struct_spa_type_info = [39]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_mediaType)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:mediaType", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_media_type[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_mediaSubtype)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:mediaSubtype", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_media_subtype[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_AUDIO_format)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Audio:format", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_format[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_AUDIO_flags)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Audio:flags", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_flags[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_AUDIO_rate)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Format:Audio:rate", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_AUDIO_channels)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Format:Audio:channels", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_AUDIO_position)), + .parent = @as(u32, @bitCast(SPA_TYPE_Array)), + .name = "Spa:Pod:Object:Param:Format:Audio:position", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_prop_channel_map[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_AUDIO_iec958Codec)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Audio:iec958Codec", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_iec958_codec[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_AUDIO_bitorder)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Audio:bitorder", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param_bitorder[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_AUDIO_interleave)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Format:Audio:interleave", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_AUDIO_bitrate)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Format:Audio:bitrate", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_AUDIO_blockAlign)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Format:Audio:blockAlign", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_AUDIO_AAC_streamFormat)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Audio:AAC:streamFormat", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_aac_stream_format[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_AUDIO_WMA_profile)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Audio:WMA:profile", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_wma_profile[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_AUDIO_AMR_bandMode)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Audio:AMR:bandMode", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_amr_band_mode[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_AUDIO_MP3_channelMode)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Audio:MP3:channelMode", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_mp3_channel_mode[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_AUDIO_DTS_extType)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Audio:DTS:extType", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_dts_ext_type[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_format)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Video:format", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_video_format[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_modifier)), + .parent = @as(u32, @bitCast(SPA_TYPE_Long)), + .name = "Spa:Pod:Object:Param:Format:Video:modifier", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_size)), + .parent = @as(u32, @bitCast(SPA_TYPE_Rectangle)), + .name = "Spa:Pod:Object:Param:Format:Video:size", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_framerate)), + .parent = @as(u32, @bitCast(SPA_TYPE_Fraction)), + .name = "Spa:Pod:Object:Param:Format:Video:framerate", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_maxFramerate)), + .parent = @as(u32, @bitCast(SPA_TYPE_Fraction)), + .name = "Spa:Pod:Object:Param:Format:Video:maxFramerate", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_views)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Format:Video:views", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_interlaceMode)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Video:interlaceMode", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_video_interlace_mode[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_pixelAspectRatio)), + .parent = @as(u32, @bitCast(SPA_TYPE_Fraction)), + .name = "Spa:Pod:Object:Param:Format:Video:pixelAspectRatio", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_multiviewMode)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Video:multiviewMode", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_multiviewFlags)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Video:multiviewFlags", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_chromaSite)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Video:chromaSite", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_colorRange)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Video:colorRange", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_video_color_range[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_colorMatrix)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Video:colorMatrix", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_video_color_matrix[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_transferFunction)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Video:transferFunction", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_video_transfer_function[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_colorPrimaries)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Video:colorPrimaries", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_video_color_primaries[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_profile)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Format:Video:profile", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_level)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Format:Video:level", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_H264_streamFormat)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Video:H264:streamFormat", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_VIDEO_H264_alignment)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Video:H264:alignment", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_FORMAT_CONTROL_types)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Format:Control:types", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_control[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const SPA_PARAM_LATENCY_START: c_int = 0; +pub const SPA_PARAM_LATENCY_direction: c_int = 1; +pub const SPA_PARAM_LATENCY_minQuantum: c_int = 2; +pub const SPA_PARAM_LATENCY_maxQuantum: c_int = 3; +pub const SPA_PARAM_LATENCY_minRate: c_int = 4; +pub const SPA_PARAM_LATENCY_maxRate: c_int = 5; +pub const SPA_PARAM_LATENCY_minNs: c_int = 6; +pub const SPA_PARAM_LATENCY_maxNs: c_int = 7; +pub const enum_spa_param_latency = c_uint; +pub const struct_spa_latency_info = extern struct { + direction: enum_spa_direction = @import("std").mem.zeroes(enum_spa_direction), + min_quantum: f32 = @import("std").mem.zeroes(f32), + max_quantum: f32 = @import("std").mem.zeroes(f32), + min_rate: i32 = @import("std").mem.zeroes(i32), + max_rate: i32 = @import("std").mem.zeroes(i32), + min_ns: i64 = @import("std").mem.zeroes(i64), + max_ns: i64 = @import("std").mem.zeroes(i64), +}; +pub const SPA_PARAM_PROCESS_LATENCY_START: c_int = 0; +pub const SPA_PARAM_PROCESS_LATENCY_quantum: c_int = 1; +pub const SPA_PARAM_PROCESS_LATENCY_rate: c_int = 2; +pub const SPA_PARAM_PROCESS_LATENCY_ns: c_int = 3; +pub const enum_spa_param_process_latency = c_uint; +pub const struct_spa_process_latency_info = extern struct { + quantum: f32 = @import("std").mem.zeroes(f32), + rate: i32 = @import("std").mem.zeroes(i32), + ns: i64 = @import("std").mem.zeroes(i64), +}; +pub const spa_type_param_latency: [9]struct_spa_type_info = [9]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_LATENCY_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Latency:", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_LATENCY_direction)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Latency:direction", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_direction[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_LATENCY_minQuantum)), + .parent = @as(u32, @bitCast(SPA_TYPE_Float)), + .name = "Spa:Pod:Object:Param:Latency:minQuantum", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_LATENCY_maxQuantum)), + .parent = @as(u32, @bitCast(SPA_TYPE_Float)), + .name = "Spa:Pod:Object:Param:Latency:maxQuantum", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_LATENCY_minRate)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Latency:minRate", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_LATENCY_maxRate)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Latency:maxRate", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_LATENCY_minNs)), + .parent = @as(u32, @bitCast(SPA_TYPE_Long)), + .name = "Spa:Pod:Object:Param:Latency:minNs", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_LATENCY_maxNs)), + .parent = @as(u32, @bitCast(SPA_TYPE_Long)), + .name = "Spa:Pod:Object:Param:Latency:maxNs", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_param_process_latency: [5]struct_spa_type_info = [5]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PROCESS_LATENCY_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Latency:", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PROCESS_LATENCY_quantum)), + .parent = @as(u32, @bitCast(SPA_TYPE_Float)), + .name = "Spa:Pod:Object:Param:ProcessLatency:quantum", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PROCESS_LATENCY_rate)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:ProcessLatency:rate", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PROCESS_LATENCY_ns)), + .parent = @as(u32, @bitCast(SPA_TYPE_Long)), + .name = "Spa:Pod:Object:Param:ProcessLatency:ns", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_param_port_config_mode: [5]struct_spa_type_info = [5]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PORT_CONFIG_MODE_none)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:ParamPortConfigMode:none", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PORT_CONFIG_MODE_passthrough)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:ParamPortConfigMode:passthrough", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PORT_CONFIG_MODE_convert)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:ParamPortConfigMode:convert", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PORT_CONFIG_MODE_dsp)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Enum:ParamPortConfigMode:dsp", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_param_port_config: [7]struct_spa_type_info = [7]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PORT_CONFIG_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:PortConfig:", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PORT_CONFIG_direction)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:PortConfig:direction", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_direction[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PORT_CONFIG_mode)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:PortConfig:mode", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param_port_config_mode[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PORT_CONFIG_monitor)), + .parent = @as(u32, @bitCast(SPA_TYPE_Bool)), + .name = "Spa:Pod:Object:Param:PortConfig:monitor", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PORT_CONFIG_control)), + .parent = @as(u32, @bitCast(SPA_TYPE_Bool)), + .name = "Spa:Pod:Object:Param:PortConfig:control", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PORT_CONFIG_format)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_Format)), + .name = "Spa:Pod:Object:Param:PortConfig:format", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const SPA_PROFILER_START: c_int = 0; +pub const SPA_PROFILER_START_Driver: c_int = 65536; +pub const SPA_PROFILER_info: c_int = 65537; +pub const SPA_PROFILER_clock: c_int = 65538; +pub const SPA_PROFILER_driverBlock: c_int = 65539; +pub const SPA_PROFILER_START_Follower: c_int = 131072; +pub const SPA_PROFILER_followerBlock: c_int = 131073; +pub const SPA_PROFILER_followerClock: c_int = 131074; +pub const SPA_PROFILER_START_CUSTOM: c_int = 16777216; +pub const enum_spa_profiler = c_uint; +pub const spa_type_profiler: [7]struct_spa_type_info = [7]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROFILER_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Profiler:", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROFILER_info)), + .parent = @as(u32, @bitCast(SPA_TYPE_Struct)), + .name = "Spa:Pod:Object:Profiler:info", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROFILER_clock)), + .parent = @as(u32, @bitCast(SPA_TYPE_Struct)), + .name = "Spa:Pod:Object:Profiler:clock", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROFILER_driverBlock)), + .parent = @as(u32, @bitCast(SPA_TYPE_Struct)), + .name = "Spa:Pod:Object:Profiler:driverBlock", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROFILER_followerBlock)), + .parent = @as(u32, @bitCast(SPA_TYPE_Struct)), + .name = "Spa:Pod:Object:Profiler:followerBlock", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PROFILER_followerClock)), + .parent = @as(u32, @bitCast(SPA_TYPE_Struct)), + .name = "Spa:Pod:Object:Profiler:followerClock", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_param_profile: [10]struct_spa_type_info = [10]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PROFILE_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Profile:", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PROFILE_index)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Profile:index", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PROFILE_name)), + .parent = @as(u32, @bitCast(SPA_TYPE_String)), + .name = "Spa:Pod:Object:Param:Profile:name", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PROFILE_description)), + .parent = @as(u32, @bitCast(SPA_TYPE_String)), + .name = "Spa:Pod:Object:Param:Profile:description", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PROFILE_priority)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Profile:priority", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PROFILE_available)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Profile:available", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param_availability[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PROFILE_info)), + .parent = @as(u32, @bitCast(SPA_TYPE_Struct)), + .name = "Spa:Pod:Object:Param:Profile:info", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PROFILE_classes)), + .parent = @as(u32, @bitCast(SPA_TYPE_Struct)), + .name = "Spa:Pod:Object:Param:Profile:classes", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_PROFILE_save)), + .parent = @as(u32, @bitCast(SPA_TYPE_Bool)), + .name = "Spa:Pod:Object:Param:Profile:save", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_type_param_route: [15]struct_spa_type_info = [15]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_ROUTE_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Route:", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_ROUTE_index)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Route:index", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_ROUTE_direction)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Route:direction", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_direction[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_ROUTE_device)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Route:device", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_ROUTE_name)), + .parent = @as(u32, @bitCast(SPA_TYPE_String)), + .name = "Spa:Pod:Object:Param:Route:name", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_ROUTE_description)), + .parent = @as(u32, @bitCast(SPA_TYPE_String)), + .name = "Spa:Pod:Object:Param:Route:description", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_ROUTE_priority)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Route:priority", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_ROUTE_available)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Route:available", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param_availability[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_ROUTE_info)), + .parent = @as(u32, @bitCast(SPA_TYPE_Struct)), + .name = "Spa:Pod:Object:Param:Route:info", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_ROUTE_profiles)), + .parent = @as(u32, @bitCast(SPA_TYPE_Array)), + .name = "Spa:Pod:Object:Param:Route:profiles", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_prop_int_array[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_ROUTE_props)), + .parent = @as(u32, @bitCast(SPA_TYPE_OBJECT_Props)), + .name = "Spa:Pod:Object:Param:Route:props", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_ROUTE_devices)), + .parent = @as(u32, @bitCast(SPA_TYPE_Array)), + .name = "Spa:Pod:Object:Param:Route:devices", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_prop_int_array[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_ROUTE_profile)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Pod:Object:Param:Route:profile", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_ROUTE_save)), + .parent = @as(u32, @bitCast(SPA_TYPE_Bool)), + .name = "Spa:Pod:Object:Param:Route:save", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const SPA_PARAM_TAG_START: c_int = 0; +pub const SPA_PARAM_TAG_direction: c_int = 1; +pub const SPA_PARAM_TAG_info: c_int = 2; +pub const enum_spa_param_tag = c_uint; +pub const struct_spa_tag_info = extern struct { + direction: enum_spa_direction = @import("std").mem.zeroes(enum_spa_direction), + info: [*c]const struct_spa_pod = @import("std").mem.zeroes([*c]const struct_spa_pod), +}; +pub const spa_type_param_tag: [4]struct_spa_type_info = [4]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_TAG_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Tag:", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_TAG_direction)), + .parent = @as(u32, @bitCast(SPA_TYPE_Id)), + .name = "Spa:Pod:Object:Param:Tag:direction", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_direction[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_PARAM_TAG_info)), + .parent = @as(u32, @bitCast(SPA_TYPE_Struct)), + .name = "Spa:Pod:Object:Param:Tag:info", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub const spa_types: [46]struct_spa_type_info = [46]struct_spa_type_info{ + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_START)), + .name = "Spa:", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_None)), + .parent = @as(u32, @bitCast(SPA_TYPE_None)), + .name = "Spa:None", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Bool)), + .parent = @as(u32, @bitCast(SPA_TYPE_Bool)), + .name = "Spa:Bool", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Id)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Id", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Int)), + .parent = @as(u32, @bitCast(SPA_TYPE_Int)), + .name = "Spa:Int", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Long)), + .parent = @as(u32, @bitCast(SPA_TYPE_Long)), + .name = "Spa:Long", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Float)), + .parent = @as(u32, @bitCast(SPA_TYPE_Float)), + .name = "Spa:Float", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Double)), + .parent = @as(u32, @bitCast(SPA_TYPE_Double)), + .name = "Spa:Double", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_String)), + .parent = @as(u32, @bitCast(SPA_TYPE_String)), + .name = "Spa:String", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Bytes)), + .parent = @as(u32, @bitCast(SPA_TYPE_Bytes)), + .name = "Spa:Bytes", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Rectangle)), + .parent = @as(u32, @bitCast(SPA_TYPE_Rectangle)), + .name = "Spa:Rectangle", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Fraction)), + .parent = @as(u32, @bitCast(SPA_TYPE_Fraction)), + .name = "Spa:Fraction", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Bitmap)), + .parent = @as(u32, @bitCast(SPA_TYPE_Bitmap)), + .name = "Spa:Bitmap", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Array)), + .parent = @as(u32, @bitCast(SPA_TYPE_Array)), + .name = "Spa:Array", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Pod)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pod)), + .name = "Spa:Pod", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Struct)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pod)), + .name = "Spa:Pod:Struct", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Object)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pod)), + .name = "Spa:Pod:Object", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Sequence)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pod)), + .name = "Spa:Pod:Sequence", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Pointer)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pointer)), + .name = "Spa:Pointer", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Fd)), + .parent = @as(u32, @bitCast(SPA_TYPE_Fd)), + .name = "Spa:Fd", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_Choice)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pod)), + .name = "Spa:Pod:Choice", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_POINTER_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pointer)), + .name = "Spa:Pointer", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_POINTER_Buffer)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pointer)), + .name = "Spa:Pointer:Buffer", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_POINTER_Meta)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pointer)), + .name = "Spa:Pointer:Meta", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_POINTER_Dict)), + .parent = @as(u32, @bitCast(SPA_TYPE_Pointer)), + .name = "Spa:Pointer:Dict", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_EVENT_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Event", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_EVENT_Device)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Event:Device", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_device_event[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_EVENT_Node)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Event:Node", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_node_event[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_COMMAND_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Command", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_COMMAND_Device)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Command:Device", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_COMMAND_Node)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Command:Node", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_node_command[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_OBJECT_START)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object", + .values = null, + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_OBJECT_PropInfo)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Param:PropInfo", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_prop_info[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_OBJECT_Props)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Param:Props", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_props[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_OBJECT_Format)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Param:Format", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_format[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamBuffers)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Param:Buffers", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param_buffers[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamMeta)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Param:Meta", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param_meta[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamIO)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Param:IO", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param_io[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamProfile)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Param:Profile", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param_profile[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamPortConfig)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Param:PortConfig", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param_port_config[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamRoute)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Param:Route", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param_route[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_OBJECT_Profiler)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Profiler", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_profiler[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamLatency)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Param:Latency", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param_latency[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamProcessLatency)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Param:ProcessLatency", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param_process_latency[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(SPA_TYPE_OBJECT_ParamTag)), + .parent = @as(u32, @bitCast(SPA_TYPE_Object)), + .name = "Spa:Pod:Object:Param:Tag", + .values = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_param_tag[@as(usize, @intCast(0))]))), + }, + struct_spa_type_info{ + .type = @as(u32, @bitCast(@as(c_int, 0))), + .parent = @as(u32, @bitCast(@as(c_int, 0))), + .name = null, + .values = null, + }, +}; +pub fn spa_debug_type_find(arg_info: [*c]const struct_spa_type_info, arg_type: u32) callconv(.c) [*c]const struct_spa_type_info { + var info = arg_info; + _ = &info; + var @"type" = arg_type; + _ = &@"type"; + var res: [*c]const struct_spa_type_info = undefined; + _ = &res; + if (info == @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + info = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_types[@as(usize, @intCast(0))]))); + } + while ((info != null) and (info.*.name != null)) { + if (info.*.type == @as(u32, @bitCast(@as(c_uint, 4294967295)))) { + if ((info.*.values != null) and ((blk: { + const tmp = spa_debug_type_find(info.*.values, @"type"); + res = tmp; + break :blk tmp; + }) != null)) return res; + } else if (info.*.type == @"type") return info; + info += 1; + } + return null; +} +pub fn spa_debug_type_short_name(arg_name: [*c]const u8) callconv(.c) [*c]const u8 { + var name = arg_name; + _ = &name; + return spa_type_short_name(name); +} +pub fn spa_debug_type_find_name(arg_info: [*c]const struct_spa_type_info, arg_type: u32) callconv(.c) [*c]const u8 { + var info = arg_info; + _ = &info; + var @"type" = arg_type; + _ = &@"type"; + if ((blk: { + const tmp = spa_debug_type_find(info, @"type"); + info = tmp; + break :blk tmp; + }) == @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return null; + return info.*.name; +} +pub fn spa_debug_type_find_short_name(arg_info: [*c]const struct_spa_type_info, arg_type: u32) callconv(.c) [*c]const u8 { + var info = arg_info; + _ = &info; + var @"type" = arg_type; + _ = &@"type"; + var str: [*c]const u8 = undefined; + _ = &str; + if ((blk: { + const tmp = spa_debug_type_find_name(info, @"type"); + str = tmp; + break :blk tmp; + }) == @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return null; + return spa_debug_type_short_name(str); +} +pub fn spa_debug_type_find_type(arg_info: [*c]const struct_spa_type_info, arg_name: [*c]const u8) callconv(.c) u32 { + var info = arg_info; + _ = &info; + var name = arg_name; + _ = &name; + if (info == @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + info = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_types[@as(usize, @intCast(0))]))); + } + while ((info != null) and (info.*.name != null)) { + var res: u32 = undefined; + _ = &res; + if (strcmp(info.*.name, name) == @as(c_int, 0)) return info.*.type; + if ((info.*.values != null) and ((blk: { + const tmp = spa_debug_type_find_type(info.*.values, name); + res = tmp; + break :blk tmp; + }) != @as(u32, @bitCast(@as(c_uint, 4294967295))))) return res; + info += 1; + } + return @as(u32, @bitCast(@as(c_uint, 4294967295))); +} +pub fn spa_debug_type_find_short(arg_info: [*c]const struct_spa_type_info, arg_name: [*c]const u8) callconv(.c) [*c]const struct_spa_type_info { + var info = arg_info; + _ = &info; + var name = arg_name; + _ = &name; + while ((info != null) and (info.*.name != null)) { + if (strcmp(spa_debug_type_short_name(info.*.name), name) == @as(c_int, 0)) return info; + if (strcmp(info.*.name, name) == @as(c_int, 0)) return info; + if ((info.*.type != @as(u32, @bitCast(@as(c_int, 0)))) and (info.*.type == @as(u32, @bitCast(atoi(name))))) return info; + info += 1; + } + return null; +} +pub fn spa_debug_type_find_type_short(arg_info: [*c]const struct_spa_type_info, arg_name: [*c]const u8) callconv(.c) u32 { + var info = arg_info; + _ = &info; + var name = arg_name; + _ = &name; + if ((blk: { + const tmp = spa_debug_type_find_short(info, name); + info = tmp; + break :blk tmp; + }) == @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) return @as(u32, @bitCast(@as(c_uint, 4294967295))); + return info.*.type; +} +pub fn spa_debug_strbuf_format_value(arg_buffer: [*c]struct_spa_strbuf, arg_info: [*c]const struct_spa_type_info, arg_type: u32, arg_body: ?*anyopaque, arg_size: u32) callconv(.c) c_int { + var buffer = arg_buffer; + _ = &buffer; + var info = arg_info; + _ = &info; + var @"type" = arg_type; + _ = &@"type"; + var body = arg_body; + _ = &body; + var size = arg_size; + _ = &size; + while (true) { + switch (@"type") { + @as(u32, @bitCast(@as(c_int, 2))) => { + _ = spa_strbuf_append(buffer, "%s", if (@as([*c]i32, @ptrCast(@alignCast(body))).* != 0) "true" else "false"); + break; + }, + @as(u32, @bitCast(@as(c_int, 3))) => { + { + var value: u32 = @as([*c]u32, @ptrCast(@alignCast(body))).*; + _ = &value; + var str: [*c]const u8 = spa_debug_type_find_short_name(info, value); + _ = &str; + var tmp: [64]u8 = undefined; + _ = &tmp; + if (str == @as([*c]const u8, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + _ = snprintf(@as([*c]u8, @ptrCast(@alignCast(&tmp[@as(usize, @intCast(0))]))), @sizeOf([64]u8), "%u", value); + str = @as([*c]u8, @ptrCast(@alignCast(&tmp[@as(usize, @intCast(0))]))); + } + _ = spa_strbuf_append(buffer, "%s", str); + break; + } + }, + @as(u32, @bitCast(@as(c_int, 4))) => { + _ = spa_strbuf_append(buffer, "%d", @as([*c]i32, @ptrCast(@alignCast(body))).*); + break; + }, + @as(u32, @bitCast(@as(c_int, 5))) => { + _ = spa_strbuf_append(buffer, "%li", @as([*c]i64, @ptrCast(@alignCast(body))).*); + break; + }, + @as(u32, @bitCast(@as(c_int, 6))) => { + _ = spa_strbuf_append(buffer, "%f", @as(f64, @floatCast(@as([*c]f32, @ptrCast(@alignCast(body))).*))); + break; + }, + @as(u32, @bitCast(@as(c_int, 7))) => { + _ = spa_strbuf_append(buffer, "%f", @as([*c]f64, @ptrCast(@alignCast(body))).*); + break; + }, + @as(u32, @bitCast(@as(c_int, 8))) => { + _ = spa_strbuf_append(buffer, "%-*s", size, @as([*c]u8, @ptrCast(@alignCast(body)))); + break; + }, + @as(u32, @bitCast(@as(c_int, 10))) => { + { + var r: [*c]struct_spa_rectangle = @as([*c]struct_spa_rectangle, @ptrCast(@alignCast(body))); + _ = &r; + _ = spa_strbuf_append(buffer, "%ux%u", r.*.width, r.*.height); + break; + } + }, + @as(u32, @bitCast(@as(c_int, 11))) => { + { + var f: [*c]struct_spa_fraction = @as([*c]struct_spa_fraction, @ptrCast(@alignCast(body))); + _ = &f; + _ = spa_strbuf_append(buffer, "%u/%u", f.*.num, f.*.denom); + break; + } + }, + @as(u32, @bitCast(@as(c_int, 12))) => { + _ = spa_strbuf_append(buffer, "Bitmap"); + break; + }, + @as(u32, @bitCast(@as(c_int, 9))) => { + _ = spa_strbuf_append(buffer, "Bytes"); + break; + }, + @as(u32, @bitCast(@as(c_int, 13))) => { + { + var p: ?*anyopaque = undefined; + _ = &p; + var b: [*c]struct_spa_pod_array_body = @as([*c]struct_spa_pod_array_body, @ptrCast(@alignCast(body))); + _ = &b; + var i: c_int = 0; + _ = &i; + info = if ((info != null) and (info.*.values != null)) info.*.values else info; + _ = spa_strbuf_append(buffer, "< "); + if (b.*.child.size >= spa_pod_type_size(b.*.child.type)) { + { + p = @as(@TypeOf(p), @ptrCast(@as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(b))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod_array_body))))))))); + while ((b.*.child.size > @as(u32, @bitCast(@as(c_int, 0)))) and (@as(c_int, @intFromBool(spa_ptrinside(@as(?*const anyopaque, @ptrCast(b)), @as(usize, @bitCast(@as(c_ulong, size))), p, @as(usize, @bitCast(@as(c_ulong, b.*.child.size))), null))) != 0)) : (p = @as(@TypeOf(p), @ptrCast(@as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(p))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, b.*.child.size)))))))))) { + if ((blk: { + const ref = &i; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + }) > @as(c_int, 0)) { + _ = spa_strbuf_append(buffer, ", "); + } + _ = spa_debug_strbuf_format_value(buffer, info, b.*.child.type, p, b.*.child.size); + } + } + } + _ = spa_strbuf_append(buffer, " >"); + break; + } + }, + else => { + _ = spa_strbuf_append(buffer, "INVALID type %d", @"type"); + break; + }, + } + break; + } + return 0; +} +pub fn spa_debug_format_value(arg_info: [*c]const struct_spa_type_info, arg_type: u32, arg_body: ?*anyopaque, arg_size: u32) callconv(.c) c_int { + var info = arg_info; + _ = &info; + var @"type" = arg_type; + _ = &@"type"; + var body = arg_body; + _ = &body; + var size = arg_size; + _ = &size; + var buffer: [1024]u8 = undefined; + _ = &buffer; + var buf: struct_spa_strbuf = undefined; + _ = &buf; + spa_strbuf_init(&buf, @as([*c]u8, @ptrCast(@alignCast(&buffer[@as(usize, @intCast(0))]))), @sizeOf([1024]u8)); + _ = spa_debug_strbuf_format_value(&buf, info, @"type", body, size); + _ = printf("%s", @as([*c]u8, @ptrCast(@alignCast(&buffer[@as(usize, @intCast(0))])))); + return 0; +} +pub fn spa_debugc_format(arg_ctx: [*c]struct_spa_debug_context, arg_indent: c_int, arg_info: [*c]const struct_spa_type_info, arg_format: [*c]const struct_spa_pod) callconv(.c) c_int { + var ctx = arg_ctx; + _ = &ctx; + var indent = arg_indent; + _ = &indent; + var info = arg_info; + _ = &info; + var format = arg_format; + _ = &format; + var media_type: [*c]const u8 = undefined; + _ = &media_type; + var media_subtype: [*c]const u8 = undefined; + _ = &media_subtype; + var prop: [*c]struct_spa_pod_prop = undefined; + _ = ∝ + var mtype: u32 = undefined; + _ = &mtype; + var mstype: u32 = undefined; + _ = &mstype; + if (info == @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) { + info = @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_format[@as(usize, @intCast(0))]))); + } + if ((format == @as([*c]const struct_spa_pod, @ptrCast(@alignCast(@as(?*anyopaque, @ptrFromInt(@as(c_int, 0))))))) or (format.*.type != @as(u32, @bitCast(SPA_TYPE_Object)))) return -@as(c_int, 22); + if (spa_format_parse(format, &mtype, &mstype) < @as(c_int, 0)) return -@as(c_int, 22); + media_type = spa_debug_type_find_name(@as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_media_type[@as(usize, @intCast(0))]))), mtype); + media_subtype = spa_debug_type_find_name(@as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_media_subtype[@as(usize, @intCast(0))]))), mstype); + if (ctx != null) _ = ctx.*.log.?(ctx, "%*s %s/%s", indent, "", if (media_type != null) spa_debug_type_short_name(media_type) else "unknown", if (media_subtype != null) spa_debug_type_short_name(media_subtype) else "unknown") else _ = printf("%*s %s/%s\n", indent, "", if (media_type != null) spa_debug_type_short_name(media_type) else "unknown", if (media_subtype != null) spa_debug_type_short_name(media_subtype) else "unknown"); + { + prop = spa_pod_prop_first(&@as([*c]struct_spa_pod_object, @ptrCast(@constCast(@volatileCast(format)))).*.body); + while (spa_pod_prop_is_inside(&@as([*c]struct_spa_pod_object, @ptrCast(@constCast(@volatileCast(format)))).*.body, @as([*c]struct_spa_pod, @ptrCast(@alignCast(@as([*c]struct_spa_pod_object, @ptrCast(@constCast(@volatileCast(format))))))).*.size, prop)) : (prop = spa_pod_prop_next(prop)) { + var key: [*c]const u8 = undefined; + _ = &key; + var ti: [*c]const struct_spa_type_info = undefined; + _ = &ti; + var i: u32 = undefined; + _ = &i; + var @"type": u32 = undefined; + _ = &@"type"; + var size: u32 = undefined; + _ = &size; + var n_vals: u32 = undefined; + _ = &n_vals; + var choice: u32 = undefined; + _ = &choice; + var val: [*c]const struct_spa_pod = undefined; + _ = &val; + var vals: ?*anyopaque = undefined; + _ = &vals; + var buffer: [1024]u8 = undefined; + _ = &buffer; + var buf: struct_spa_strbuf = undefined; + _ = &buf; + if ((prop.*.key == @as(u32, @bitCast(SPA_FORMAT_mediaType))) or (prop.*.key == @as(u32, @bitCast(SPA_FORMAT_mediaSubtype)))) continue; + val = spa_pod_get_values(&prop.*.value, &n_vals, &choice); + @"type" = val.*.type; + size = val.*.size; + if ((((@"type" < @as(u32, @bitCast(SPA_TYPE_None))) or (@"type" >= @as(u32, @bitCast(_SPA_TYPE_LAST)))) or (n_vals < @as(u32, @bitCast(@as(c_int, 1))))) or (size < spa_pod_type_size(@"type"))) continue; + vals = @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(val))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))); + ti = spa_debug_type_find(info, prop.*.key); + key = if (ti != null) ti.*.name else null; + spa_strbuf_init(&buf, @as([*c]u8, @ptrCast(@alignCast(&buffer[@as(usize, @intCast(0))]))), @sizeOf([1024]u8)); + _ = spa_strbuf_append(&buf, "%*s %16s : (%s) ", indent, "", if (key != null) spa_debug_type_short_name(key) else "unknown", spa_debug_type_short_name(spa_types[@"type"].name)); + if (choice == @as(u32, @bitCast(SPA_CHOICE_None))) { + _ = spa_debug_strbuf_format_value(&buf, if (ti != null) ti.*.values else null, @"type", vals, size); + } else { + var ssep: [*c]const u8 = undefined; + _ = &ssep; + var esep: [*c]const u8 = undefined; + _ = &esep; + var sep: [*c]const u8 = undefined; + _ = &sep; + while (true) { + switch (choice) { + @as(u32, @bitCast(@as(c_int, 1))), @as(u32, @bitCast(@as(c_int, 2))) => { + ssep = "[ "; + sep = ", "; + esep = " ]"; + break; + }, + else => { + ssep = "{ "; + sep = ", "; + esep = " }"; + break; + }, + } + break; + } + _ = spa_strbuf_append(&buf, "%s", ssep); + { + i = 1; + while (i < n_vals) : (i +%= 1) { + vals = @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(vals))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, size))))))); + if (i > @as(u32, @bitCast(@as(c_int, 1)))) { + _ = spa_strbuf_append(&buf, "%s", sep); + } + _ = spa_debug_strbuf_format_value(&buf, if (ti != null) ti.*.values else null, @"type", vals, size); + } + } + _ = spa_strbuf_append(&buf, "%s", esep); + } + if (ctx != null) _ = ctx.*.log.?(ctx, "%s", @as([*c]u8, @ptrCast(@alignCast(&buffer[@as(usize, @intCast(0))])))) else _ = printf("%s\n", @as([*c]u8, @ptrCast(@alignCast(&buffer[@as(usize, @intCast(0))])))); + } + } + return 0; +} +pub fn spa_debug_format(arg_indent: c_int, arg_info: [*c]const struct_spa_type_info, arg_format: [*c]const struct_spa_pod) callconv(.c) c_int { + var indent = arg_indent; + _ = &indent; + var info = arg_info; + _ = &info; + var format = arg_format; + _ = &format; + return spa_debugc_format(null, indent, info, format); +} +pub const __llvm__ = @as(c_int, 1); +pub const __clang__ = @as(c_int, 1); +pub const __clang_major__ = @as(c_int, 20); +pub const __clang_minor__ = @as(c_int, 1); +pub const __clang_patchlevel__ = @as(c_int, 2); +pub const __clang_version__ = "20.1.2 (https://github.com/ziglang/zig-bootstrap c6bc9398c72c7a63fe9420a9055dcfd1845bc266)"; +pub const __GNUC__ = @as(c_int, 4); +pub const __GNUC_MINOR__ = @as(c_int, 2); +pub const __GNUC_PATCHLEVEL__ = @as(c_int, 1); +pub const __GXX_ABI_VERSION = @as(c_int, 1002); +pub const __ATOMIC_RELAXED = @as(c_int, 0); +pub const __ATOMIC_CONSUME = @as(c_int, 1); +pub const __ATOMIC_ACQUIRE = @as(c_int, 2); +pub const __ATOMIC_RELEASE = @as(c_int, 3); +pub const __ATOMIC_ACQ_REL = @as(c_int, 4); +pub const __ATOMIC_SEQ_CST = @as(c_int, 5); +pub const __MEMORY_SCOPE_SYSTEM = @as(c_int, 0); +pub const __MEMORY_SCOPE_DEVICE = @as(c_int, 1); +pub const __MEMORY_SCOPE_WRKGRP = @as(c_int, 2); +pub const __MEMORY_SCOPE_WVFRNT = @as(c_int, 3); +pub const __MEMORY_SCOPE_SINGLE = @as(c_int, 4); +pub const __OPENCL_MEMORY_SCOPE_WORK_ITEM = @as(c_int, 0); +pub const __OPENCL_MEMORY_SCOPE_WORK_GROUP = @as(c_int, 1); +pub const __OPENCL_MEMORY_SCOPE_DEVICE = @as(c_int, 2); +pub const __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES = @as(c_int, 3); +pub const __OPENCL_MEMORY_SCOPE_SUB_GROUP = @as(c_int, 4); +pub const __FPCLASS_SNAN = @as(c_int, 0x0001); +pub const __FPCLASS_QNAN = @as(c_int, 0x0002); +pub const __FPCLASS_NEGINF = @as(c_int, 0x0004); +pub const __FPCLASS_NEGNORMAL = @as(c_int, 0x0008); +pub const __FPCLASS_NEGSUBNORMAL = @as(c_int, 0x0010); +pub const __FPCLASS_NEGZERO = @as(c_int, 0x0020); +pub const __FPCLASS_POSZERO = @as(c_int, 0x0040); +pub const __FPCLASS_POSSUBNORMAL = @as(c_int, 0x0080); +pub const __FPCLASS_POSNORMAL = @as(c_int, 0x0100); +pub const __FPCLASS_POSINF = @as(c_int, 0x0200); +pub const __PRAGMA_REDEFINE_EXTNAME = @as(c_int, 1); +pub const __VERSION__ = "Clang 20.1.2 (https://github.com/ziglang/zig-bootstrap c6bc9398c72c7a63fe9420a9055dcfd1845bc266)"; +pub const __OBJC_BOOL_IS_BOOL = @as(c_int, 0); +pub const __CONSTANT_CFSTRINGS__ = @as(c_int, 1); +pub const __clang_literal_encoding__ = "UTF-8"; +pub const __clang_wide_literal_encoding__ = "UTF-32"; +pub const __ORDER_LITTLE_ENDIAN__ = @as(c_int, 1234); +pub const __ORDER_BIG_ENDIAN__ = @as(c_int, 4321); +pub const __ORDER_PDP_ENDIAN__ = @as(c_int, 3412); +pub const __BYTE_ORDER__ = __ORDER_LITTLE_ENDIAN__; +pub const __LITTLE_ENDIAN__ = @as(c_int, 1); +pub const _LP64 = @as(c_int, 1); +pub const __LP64__ = @as(c_int, 1); +pub const __CHAR_BIT__ = @as(c_int, 8); +pub const __BOOL_WIDTH__ = @as(c_int, 1); +pub const __SHRT_WIDTH__ = @as(c_int, 16); +pub const __INT_WIDTH__ = @as(c_int, 32); +pub const __LONG_WIDTH__ = @as(c_int, 64); +pub const __LLONG_WIDTH__ = @as(c_int, 64); +pub const __BITINT_MAXWIDTH__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 8388608, .decimal); +pub const __SCHAR_MAX__ = @as(c_int, 127); +pub const __SHRT_MAX__ = @as(c_int, 32767); +pub const __INT_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __LONG_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __LONG_LONG_MAX__ = @as(c_longlong, 9223372036854775807); +pub const __WCHAR_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __WCHAR_WIDTH__ = @as(c_int, 32); +pub const __WINT_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const __WINT_WIDTH__ = @as(c_int, 32); +pub const __INTMAX_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __INTMAX_WIDTH__ = @as(c_int, 64); +pub const __SIZE_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __SIZE_WIDTH__ = @as(c_int, 64); +pub const __UINTMAX_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __UINTMAX_WIDTH__ = @as(c_int, 64); +pub const __PTRDIFF_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __PTRDIFF_WIDTH__ = @as(c_int, 64); +pub const __INTPTR_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __INTPTR_WIDTH__ = @as(c_int, 64); +pub const __UINTPTR_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __UINTPTR_WIDTH__ = @as(c_int, 64); +pub const __SIZEOF_DOUBLE__ = @as(c_int, 8); +pub const __SIZEOF_FLOAT__ = @as(c_int, 4); +pub const __SIZEOF_INT__ = @as(c_int, 4); +pub const __SIZEOF_LONG__ = @as(c_int, 8); +pub const __SIZEOF_LONG_DOUBLE__ = @as(c_int, 16); +pub const __SIZEOF_LONG_LONG__ = @as(c_int, 8); +pub const __SIZEOF_POINTER__ = @as(c_int, 8); +pub const __SIZEOF_SHORT__ = @as(c_int, 2); +pub const __SIZEOF_PTRDIFF_T__ = @as(c_int, 8); +pub const __SIZEOF_SIZE_T__ = @as(c_int, 8); +pub const __SIZEOF_WCHAR_T__ = @as(c_int, 4); +pub const __SIZEOF_WINT_T__ = @as(c_int, 4); +pub const __SIZEOF_INT128__ = @as(c_int, 16); +pub const __INTMAX_TYPE__ = c_long; +pub const __INTMAX_FMTd__ = "ld"; +pub const __INTMAX_FMTi__ = "li"; +pub const __INTMAX_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `L`"); +// (no file):95:9 +pub const __INTMAX_C = @import("std").zig.c_translation.Macros.L_SUFFIX; +pub const __UINTMAX_TYPE__ = c_ulong; +pub const __UINTMAX_FMTo__ = "lo"; +pub const __UINTMAX_FMTu__ = "lu"; +pub const __UINTMAX_FMTx__ = "lx"; +pub const __UINTMAX_FMTX__ = "lX"; +pub const __UINTMAX_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `UL`"); +// (no file):102:9 +pub const __UINTMAX_C = @import("std").zig.c_translation.Macros.UL_SUFFIX; +pub const __PTRDIFF_TYPE__ = c_long; +pub const __PTRDIFF_FMTd__ = "ld"; +pub const __PTRDIFF_FMTi__ = "li"; +pub const __INTPTR_TYPE__ = c_long; +pub const __INTPTR_FMTd__ = "ld"; +pub const __INTPTR_FMTi__ = "li"; +pub const __SIZE_TYPE__ = c_ulong; +pub const __SIZE_FMTo__ = "lo"; +pub const __SIZE_FMTu__ = "lu"; +pub const __SIZE_FMTx__ = "lx"; +pub const __SIZE_FMTX__ = "lX"; +pub const __WCHAR_TYPE__ = c_int; +pub const __WINT_TYPE__ = c_uint; +pub const __SIG_ATOMIC_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __SIG_ATOMIC_WIDTH__ = @as(c_int, 32); +pub const __CHAR16_TYPE__ = c_ushort; +pub const __CHAR32_TYPE__ = c_uint; +pub const __UINTPTR_TYPE__ = c_ulong; +pub const __UINTPTR_FMTo__ = "lo"; +pub const __UINTPTR_FMTu__ = "lu"; +pub const __UINTPTR_FMTx__ = "lx"; +pub const __UINTPTR_FMTX__ = "lX"; +pub const __FLT16_DENORM_MIN__ = @as(f16, 5.9604644775390625e-8); +pub const __FLT16_NORM_MAX__ = @as(f16, 6.5504e+4); +pub const __FLT16_HAS_DENORM__ = @as(c_int, 1); +pub const __FLT16_DIG__ = @as(c_int, 3); +pub const __FLT16_DECIMAL_DIG__ = @as(c_int, 5); +pub const __FLT16_EPSILON__ = @as(f16, 9.765625e-4); +pub const __FLT16_HAS_INFINITY__ = @as(c_int, 1); +pub const __FLT16_HAS_QUIET_NAN__ = @as(c_int, 1); +pub const __FLT16_MANT_DIG__ = @as(c_int, 11); +pub const __FLT16_MAX_10_EXP__ = @as(c_int, 4); +pub const __FLT16_MAX_EXP__ = @as(c_int, 16); +pub const __FLT16_MAX__ = @as(f16, 6.5504e+4); +pub const __FLT16_MIN_10_EXP__ = -@as(c_int, 4); +pub const __FLT16_MIN_EXP__ = -@as(c_int, 13); +pub const __FLT16_MIN__ = @as(f16, 6.103515625e-5); +pub const __FLT_DENORM_MIN__ = @as(f32, 1.40129846e-45); +pub const __FLT_NORM_MAX__ = @as(f32, 3.40282347e+38); +pub const __FLT_HAS_DENORM__ = @as(c_int, 1); +pub const __FLT_DIG__ = @as(c_int, 6); +pub const __FLT_DECIMAL_DIG__ = @as(c_int, 9); +pub const __FLT_EPSILON__ = @as(f32, 1.19209290e-7); +pub const __FLT_HAS_INFINITY__ = @as(c_int, 1); +pub const __FLT_HAS_QUIET_NAN__ = @as(c_int, 1); +pub const __FLT_MANT_DIG__ = @as(c_int, 24); +pub const __FLT_MAX_10_EXP__ = @as(c_int, 38); +pub const __FLT_MAX_EXP__ = @as(c_int, 128); +pub const __FLT_MAX__ = @as(f32, 3.40282347e+38); +pub const __FLT_MIN_10_EXP__ = -@as(c_int, 37); +pub const __FLT_MIN_EXP__ = -@as(c_int, 125); +pub const __FLT_MIN__ = @as(f32, 1.17549435e-38); +pub const __DBL_DENORM_MIN__ = @as(f64, 4.9406564584124654e-324); +pub const __DBL_NORM_MAX__ = @as(f64, 1.7976931348623157e+308); +pub const __DBL_HAS_DENORM__ = @as(c_int, 1); +pub const __DBL_DIG__ = @as(c_int, 15); +pub const __DBL_DECIMAL_DIG__ = @as(c_int, 17); +pub const __DBL_EPSILON__ = @as(f64, 2.2204460492503131e-16); +pub const __DBL_HAS_INFINITY__ = @as(c_int, 1); +pub const __DBL_HAS_QUIET_NAN__ = @as(c_int, 1); +pub const __DBL_MANT_DIG__ = @as(c_int, 53); +pub const __DBL_MAX_10_EXP__ = @as(c_int, 308); +pub const __DBL_MAX_EXP__ = @as(c_int, 1024); +pub const __DBL_MAX__ = @as(f64, 1.7976931348623157e+308); +pub const __DBL_MIN_10_EXP__ = -@as(c_int, 307); +pub const __DBL_MIN_EXP__ = -@as(c_int, 1021); +pub const __DBL_MIN__ = @as(f64, 2.2250738585072014e-308); +pub const __LDBL_DENORM_MIN__ = @as(c_longdouble, 3.64519953188247460253e-4951); +pub const __LDBL_NORM_MAX__ = @as(c_longdouble, 1.18973149535723176502e+4932); +pub const __LDBL_HAS_DENORM__ = @as(c_int, 1); +pub const __LDBL_DIG__ = @as(c_int, 18); +pub const __LDBL_DECIMAL_DIG__ = @as(c_int, 21); +pub const __LDBL_EPSILON__ = @as(c_longdouble, 1.08420217248550443401e-19); +pub const __LDBL_HAS_INFINITY__ = @as(c_int, 1); +pub const __LDBL_HAS_QUIET_NAN__ = @as(c_int, 1); +pub const __LDBL_MANT_DIG__ = @as(c_int, 64); +pub const __LDBL_MAX_10_EXP__ = @as(c_int, 4932); +pub const __LDBL_MAX_EXP__ = @as(c_int, 16384); +pub const __LDBL_MAX__ = @as(c_longdouble, 1.18973149535723176502e+4932); +pub const __LDBL_MIN_10_EXP__ = -@as(c_int, 4931); +pub const __LDBL_MIN_EXP__ = -@as(c_int, 16381); +pub const __LDBL_MIN__ = @as(c_longdouble, 3.36210314311209350626e-4932); +pub const __POINTER_WIDTH__ = @as(c_int, 64); +pub const __BIGGEST_ALIGNMENT__ = @as(c_int, 16); +pub const __WINT_UNSIGNED__ = @as(c_int, 1); +pub const __INT8_TYPE__ = i8; +pub const __INT8_FMTd__ = "hhd"; +pub const __INT8_FMTi__ = "hhi"; +pub const __INT8_C_SUFFIX__ = ""; +pub inline fn __INT8_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub const __INT16_TYPE__ = c_short; +pub const __INT16_FMTd__ = "hd"; +pub const __INT16_FMTi__ = "hi"; +pub const __INT16_C_SUFFIX__ = ""; +pub inline fn __INT16_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub const __INT32_TYPE__ = c_int; +pub const __INT32_FMTd__ = "d"; +pub const __INT32_FMTi__ = "i"; +pub const __INT32_C_SUFFIX__ = ""; +pub inline fn __INT32_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub const __INT64_TYPE__ = c_long; +pub const __INT64_FMTd__ = "ld"; +pub const __INT64_FMTi__ = "li"; +pub const __INT64_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `L`"); +// (no file):207:9 +pub const __INT64_C = @import("std").zig.c_translation.Macros.L_SUFFIX; +pub const __UINT8_TYPE__ = u8; +pub const __UINT8_FMTo__ = "hho"; +pub const __UINT8_FMTu__ = "hhu"; +pub const __UINT8_FMTx__ = "hhx"; +pub const __UINT8_FMTX__ = "hhX"; +pub const __UINT8_C_SUFFIX__ = ""; +pub inline fn __UINT8_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub const __UINT8_MAX__ = @as(c_int, 255); +pub const __INT8_MAX__ = @as(c_int, 127); +pub const __UINT16_TYPE__ = c_ushort; +pub const __UINT16_FMTo__ = "ho"; +pub const __UINT16_FMTu__ = "hu"; +pub const __UINT16_FMTx__ = "hx"; +pub const __UINT16_FMTX__ = "hX"; +pub const __UINT16_C_SUFFIX__ = ""; +pub inline fn __UINT16_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub const __UINT16_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const __INT16_MAX__ = @as(c_int, 32767); +pub const __UINT32_TYPE__ = c_uint; +pub const __UINT32_FMTo__ = "o"; +pub const __UINT32_FMTu__ = "u"; +pub const __UINT32_FMTx__ = "x"; +pub const __UINT32_FMTX__ = "X"; +pub const __UINT32_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `U`"); +// (no file):232:9 +pub const __UINT32_C = @import("std").zig.c_translation.Macros.U_SUFFIX; +pub const __UINT32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const __INT32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __UINT64_TYPE__ = c_ulong; +pub const __UINT64_FMTo__ = "lo"; +pub const __UINT64_FMTu__ = "lu"; +pub const __UINT64_FMTx__ = "lx"; +pub const __UINT64_FMTX__ = "lX"; +pub const __UINT64_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `UL`"); +// (no file):241:9 +pub const __UINT64_C = @import("std").zig.c_translation.Macros.UL_SUFFIX; +pub const __UINT64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __INT64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __INT_LEAST8_TYPE__ = i8; +pub const __INT_LEAST8_MAX__ = @as(c_int, 127); +pub const __INT_LEAST8_WIDTH__ = @as(c_int, 8); +pub const __INT_LEAST8_FMTd__ = "hhd"; +pub const __INT_LEAST8_FMTi__ = "hhi"; +pub const __UINT_LEAST8_TYPE__ = u8; +pub const __UINT_LEAST8_MAX__ = @as(c_int, 255); +pub const __UINT_LEAST8_FMTo__ = "hho"; +pub const __UINT_LEAST8_FMTu__ = "hhu"; +pub const __UINT_LEAST8_FMTx__ = "hhx"; +pub const __UINT_LEAST8_FMTX__ = "hhX"; +pub const __INT_LEAST16_TYPE__ = c_short; +pub const __INT_LEAST16_MAX__ = @as(c_int, 32767); +pub const __INT_LEAST16_WIDTH__ = @as(c_int, 16); +pub const __INT_LEAST16_FMTd__ = "hd"; +pub const __INT_LEAST16_FMTi__ = "hi"; +pub const __UINT_LEAST16_TYPE__ = c_ushort; +pub const __UINT_LEAST16_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const __UINT_LEAST16_FMTo__ = "ho"; +pub const __UINT_LEAST16_FMTu__ = "hu"; +pub const __UINT_LEAST16_FMTx__ = "hx"; +pub const __UINT_LEAST16_FMTX__ = "hX"; +pub const __INT_LEAST32_TYPE__ = c_int; +pub const __INT_LEAST32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __INT_LEAST32_WIDTH__ = @as(c_int, 32); +pub const __INT_LEAST32_FMTd__ = "d"; +pub const __INT_LEAST32_FMTi__ = "i"; +pub const __UINT_LEAST32_TYPE__ = c_uint; +pub const __UINT_LEAST32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const __UINT_LEAST32_FMTo__ = "o"; +pub const __UINT_LEAST32_FMTu__ = "u"; +pub const __UINT_LEAST32_FMTx__ = "x"; +pub const __UINT_LEAST32_FMTX__ = "X"; +pub const __INT_LEAST64_TYPE__ = c_long; +pub const __INT_LEAST64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __INT_LEAST64_WIDTH__ = @as(c_int, 64); +pub const __INT_LEAST64_FMTd__ = "ld"; +pub const __INT_LEAST64_FMTi__ = "li"; +pub const __UINT_LEAST64_TYPE__ = c_ulong; +pub const __UINT_LEAST64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __UINT_LEAST64_FMTo__ = "lo"; +pub const __UINT_LEAST64_FMTu__ = "lu"; +pub const __UINT_LEAST64_FMTx__ = "lx"; +pub const __UINT_LEAST64_FMTX__ = "lX"; +pub const __INT_FAST8_TYPE__ = i8; +pub const __INT_FAST8_MAX__ = @as(c_int, 127); +pub const __INT_FAST8_WIDTH__ = @as(c_int, 8); +pub const __INT_FAST8_FMTd__ = "hhd"; +pub const __INT_FAST8_FMTi__ = "hhi"; +pub const __UINT_FAST8_TYPE__ = u8; +pub const __UINT_FAST8_MAX__ = @as(c_int, 255); +pub const __UINT_FAST8_FMTo__ = "hho"; +pub const __UINT_FAST8_FMTu__ = "hhu"; +pub const __UINT_FAST8_FMTx__ = "hhx"; +pub const __UINT_FAST8_FMTX__ = "hhX"; +pub const __INT_FAST16_TYPE__ = c_short; +pub const __INT_FAST16_MAX__ = @as(c_int, 32767); +pub const __INT_FAST16_WIDTH__ = @as(c_int, 16); +pub const __INT_FAST16_FMTd__ = "hd"; +pub const __INT_FAST16_FMTi__ = "hi"; +pub const __UINT_FAST16_TYPE__ = c_ushort; +pub const __UINT_FAST16_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const __UINT_FAST16_FMTo__ = "ho"; +pub const __UINT_FAST16_FMTu__ = "hu"; +pub const __UINT_FAST16_FMTx__ = "hx"; +pub const __UINT_FAST16_FMTX__ = "hX"; +pub const __INT_FAST32_TYPE__ = c_int; +pub const __INT_FAST32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __INT_FAST32_WIDTH__ = @as(c_int, 32); +pub const __INT_FAST32_FMTd__ = "d"; +pub const __INT_FAST32_FMTi__ = "i"; +pub const __UINT_FAST32_TYPE__ = c_uint; +pub const __UINT_FAST32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const __UINT_FAST32_FMTo__ = "o"; +pub const __UINT_FAST32_FMTu__ = "u"; +pub const __UINT_FAST32_FMTx__ = "x"; +pub const __UINT_FAST32_FMTX__ = "X"; +pub const __INT_FAST64_TYPE__ = c_long; +pub const __INT_FAST64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __INT_FAST64_WIDTH__ = @as(c_int, 64); +pub const __INT_FAST64_FMTd__ = "ld"; +pub const __INT_FAST64_FMTi__ = "li"; +pub const __UINT_FAST64_TYPE__ = c_ulong; +pub const __UINT_FAST64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __UINT_FAST64_FMTo__ = "lo"; +pub const __UINT_FAST64_FMTu__ = "lu"; +pub const __UINT_FAST64_FMTx__ = "lx"; +pub const __UINT_FAST64_FMTX__ = "lX"; +pub const __USER_LABEL_PREFIX__ = ""; +pub const __FINITE_MATH_ONLY__ = @as(c_int, 0); +pub const __GNUC_STDC_INLINE__ = @as(c_int, 1); +pub const __GCC_ATOMIC_TEST_AND_SET_TRUEVAL = @as(c_int, 1); +pub const __GCC_DESTRUCTIVE_SIZE = @as(c_int, 64); +pub const __GCC_CONSTRUCTIVE_SIZE = @as(c_int, 64); +pub const __CLANG_ATOMIC_BOOL_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_CHAR_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_CHAR16_T_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_CHAR32_T_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_WCHAR_T_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_SHORT_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_INT_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_LONG_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_LLONG_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_POINTER_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_BOOL_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_CHAR_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_CHAR16_T_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_CHAR32_T_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_WCHAR_T_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_SHORT_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_INT_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_LONG_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_LLONG_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_POINTER_LOCK_FREE = @as(c_int, 2); +pub const __NO_INLINE__ = @as(c_int, 1); +pub const __PIC__ = @as(c_int, 2); +pub const __pic__ = @as(c_int, 2); +pub const __FLT_RADIX__ = @as(c_int, 2); +pub const __DECIMAL_DIG__ = __LDBL_DECIMAL_DIG__; +pub const __ELF__ = @as(c_int, 1); +pub const __GCC_ASM_FLAG_OUTPUTS__ = @as(c_int, 1); +pub const __code_model_small__ = @as(c_int, 1); +pub const __amd64__ = @as(c_int, 1); +pub const __amd64 = @as(c_int, 1); +pub const __x86_64 = @as(c_int, 1); +pub const __x86_64__ = @as(c_int, 1); +pub const __SEG_GS = @as(c_int, 1); +pub const __SEG_FS = @as(c_int, 1); +pub const __seg_gs = @compileError("unable to translate macro: undefined identifier `address_space`"); +// (no file):375:9 +pub const __seg_fs = @compileError("unable to translate macro: undefined identifier `address_space`"); +// (no file):376:9 +pub const __znver4 = @as(c_int, 1); +pub const __znver4__ = @as(c_int, 1); +pub const __tune_znver4__ = @as(c_int, 1); +pub const __REGISTER_PREFIX__ = ""; +pub const __NO_MATH_INLINES = @as(c_int, 1); +pub const __AES__ = @as(c_int, 1); +pub const __VAES__ = @as(c_int, 1); +pub const __PCLMUL__ = @as(c_int, 1); +pub const __VPCLMULQDQ__ = @as(c_int, 1); +pub const __LAHF_SAHF__ = @as(c_int, 1); +pub const __LZCNT__ = @as(c_int, 1); +pub const __RDRND__ = @as(c_int, 1); +pub const __FSGSBASE__ = @as(c_int, 1); +pub const __BMI__ = @as(c_int, 1); +pub const __BMI2__ = @as(c_int, 1); +pub const __POPCNT__ = @as(c_int, 1); +pub const __PRFCHW__ = @as(c_int, 1); +pub const __RDSEED__ = @as(c_int, 1); +pub const __ADX__ = @as(c_int, 1); +pub const __MWAITX__ = @as(c_int, 1); +pub const __MOVBE__ = @as(c_int, 1); +pub const __SSE4A__ = @as(c_int, 1); +pub const __FMA__ = @as(c_int, 1); +pub const __F16C__ = @as(c_int, 1); +pub const __GFNI__ = @as(c_int, 1); +pub const __EVEX512__ = @as(c_int, 1); +pub const __AVX512CD__ = @as(c_int, 1); +pub const __AVX512VPOPCNTDQ__ = @as(c_int, 1); +pub const __AVX512VNNI__ = @as(c_int, 1); +pub const __AVX512BF16__ = @as(c_int, 1); +pub const __AVX512DQ__ = @as(c_int, 1); +pub const __AVX512BITALG__ = @as(c_int, 1); +pub const __AVX512BW__ = @as(c_int, 1); +pub const __AVX512VL__ = @as(c_int, 1); +pub const __EVEX256__ = @as(c_int, 1); +pub const __AVX512VBMI__ = @as(c_int, 1); +pub const __AVX512VBMI2__ = @as(c_int, 1); +pub const __AVX512IFMA__ = @as(c_int, 1); +pub const __SHA__ = @as(c_int, 1); +pub const __FXSR__ = @as(c_int, 1); +pub const __XSAVE__ = @as(c_int, 1); +pub const __XSAVEOPT__ = @as(c_int, 1); +pub const __XSAVEC__ = @as(c_int, 1); +pub const __XSAVES__ = @as(c_int, 1); +pub const __PKU__ = @as(c_int, 1); +pub const __CLFLUSHOPT__ = @as(c_int, 1); +pub const __CLWB__ = @as(c_int, 1); +pub const __WBNOINVD__ = @as(c_int, 1); +pub const __SHSTK__ = @as(c_int, 1); +pub const __CLZERO__ = @as(c_int, 1); +pub const __RDPID__ = @as(c_int, 1); +pub const __RDPRU__ = @as(c_int, 1); +pub const __INVPCID__ = @as(c_int, 1); +pub const __CRC32__ = @as(c_int, 1); +pub const __AVX512F__ = @as(c_int, 1); +pub const __AVX2__ = @as(c_int, 1); +pub const __AVX__ = @as(c_int, 1); +pub const __SSE4_2__ = @as(c_int, 1); +pub const __SSE4_1__ = @as(c_int, 1); +pub const __SSSE3__ = @as(c_int, 1); +pub const __SSE3__ = @as(c_int, 1); +pub const __SSE2__ = @as(c_int, 1); +pub const __SSE2_MATH__ = @as(c_int, 1); +pub const __SSE__ = @as(c_int, 1); +pub const __SSE_MATH__ = @as(c_int, 1); +pub const __MMX__ = @as(c_int, 1); +pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 = @as(c_int, 1); +pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 = @as(c_int, 1); +pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 = @as(c_int, 1); +pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 = @as(c_int, 1); +pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16 = @as(c_int, 1); +pub const __SIZEOF_FLOAT128__ = @as(c_int, 16); +pub const unix = @as(c_int, 1); +pub const __unix = @as(c_int, 1); +pub const __unix__ = @as(c_int, 1); +pub const linux = @as(c_int, 1); +pub const __linux = @as(c_int, 1); +pub const __linux__ = @as(c_int, 1); +pub const __gnu_linux__ = @as(c_int, 1); +pub const __FLOAT128__ = @as(c_int, 1); +pub const __STDC__ = @as(c_int, 1); +pub const __STDC_HOSTED__ = @as(c_int, 1); +pub const __STDC_VERSION__ = @as(c_long, 201710); +pub const __STDC_UTF_16__ = @as(c_int, 1); +pub const __STDC_UTF_32__ = @as(c_int, 1); +pub const __STDC_EMBED_NOT_FOUND__ = @as(c_int, 0); +pub const __STDC_EMBED_FOUND__ = @as(c_int, 1); +pub const __STDC_EMBED_EMPTY__ = @as(c_int, 2); +pub const __GLIBC_MINOR__ = @as(c_int, 39); +pub const __GCC_HAVE_DWARF2_CFI_ASM = @as(c_int, 1); +pub const SPA_UTILS_DEFS_H = ""; +pub const __CLANG_INTTYPES_H = ""; +pub const _INTTYPES_H = @as(c_int, 1); +pub const _FEATURES_H = @as(c_int, 1); +pub const __KERNEL_STRICT_NAMES = ""; +pub inline fn __GNUC_PREREQ(maj: anytype, min: anytype) @TypeOf(((__GNUC__ << @as(c_int, 16)) + __GNUC_MINOR__) >= ((maj << @as(c_int, 16)) + min)) { + _ = &maj; + _ = &min; + return ((__GNUC__ << @as(c_int, 16)) + __GNUC_MINOR__) >= ((maj << @as(c_int, 16)) + min); +} +pub inline fn __glibc_clang_prereq(maj: anytype, min: anytype) @TypeOf(((__clang_major__ << @as(c_int, 16)) + __clang_minor__) >= ((maj << @as(c_int, 16)) + min)) { + _ = &maj; + _ = &min; + return ((__clang_major__ << @as(c_int, 16)) + __clang_minor__) >= ((maj << @as(c_int, 16)) + min); +} +pub const __GLIBC_USE = @compileError("unable to translate macro: undefined identifier `__GLIBC_USE_`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/features.h:189:9 +pub const _DEFAULT_SOURCE = @as(c_int, 1); +pub const __GLIBC_USE_ISOC23 = @as(c_int, 0); +pub const __USE_ISOC11 = @as(c_int, 1); +pub const __USE_ISOC99 = @as(c_int, 1); +pub const __USE_ISOC95 = @as(c_int, 1); +pub const __USE_POSIX_IMPLICITLY = @as(c_int, 1); +pub const _POSIX_SOURCE = @as(c_int, 1); +pub const _POSIX_C_SOURCE = @as(c_long, 200809); +pub const __USE_POSIX = @as(c_int, 1); +pub const __USE_POSIX2 = @as(c_int, 1); +pub const __USE_POSIX199309 = @as(c_int, 1); +pub const __USE_POSIX199506 = @as(c_int, 1); +pub const __USE_XOPEN2K = @as(c_int, 1); +pub const __USE_XOPEN2K8 = @as(c_int, 1); +pub const _ATFILE_SOURCE = @as(c_int, 1); +pub const __WORDSIZE = @as(c_int, 64); +pub const __WORDSIZE_TIME64_COMPAT32 = @as(c_int, 1); +pub const __SYSCALL_WORDSIZE = @as(c_int, 64); +pub const __TIMESIZE = __WORDSIZE; +pub const __USE_TIME_BITS64 = @as(c_int, 1); +pub const __USE_MISC = @as(c_int, 1); +pub const __USE_ATFILE = @as(c_int, 1); +pub const __USE_FORTIFY_LEVEL = @as(c_int, 0); +pub const __GLIBC_USE_DEPRECATED_GETS = @as(c_int, 0); +pub const __GLIBC_USE_DEPRECATED_SCANF = @as(c_int, 0); +pub const __GLIBC_USE_C23_STRTOL = @as(c_int, 0); +pub const _STDC_PREDEF_H = @as(c_int, 1); +pub const __STDC_IEC_559__ = @as(c_int, 1); +pub const __STDC_IEC_60559_BFP__ = @as(c_long, 201404); +pub const __STDC_IEC_559_COMPLEX__ = @as(c_int, 1); +pub const __STDC_IEC_60559_COMPLEX__ = @as(c_long, 201404); +pub const __STDC_ISO_10646__ = @as(c_long, 201706); +pub const __GNU_LIBRARY__ = @as(c_int, 6); +pub const __GLIBC__ = @as(c_int, 2); +pub inline fn __GLIBC_PREREQ(maj: anytype, min: anytype) @TypeOf(((__GLIBC__ << @as(c_int, 16)) + __GLIBC_MINOR__) >= ((maj << @as(c_int, 16)) + min)) { + _ = &maj; + _ = &min; + return ((__GLIBC__ << @as(c_int, 16)) + __GLIBC_MINOR__) >= ((maj << @as(c_int, 16)) + min); +} +pub const _SYS_CDEFS_H = @as(c_int, 1); +pub const __glibc_has_attribute = @compileError("unable to translate macro: undefined identifier `__has_attribute`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:45:10 +pub inline fn __glibc_has_builtin(name: anytype) @TypeOf(__has_builtin(name)) { + _ = &name; + return __has_builtin(name); +} +pub const __glibc_has_extension = @compileError("unable to translate macro: undefined identifier `__has_extension`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:55:10 +pub const __LEAF = ""; +pub const __LEAF_ATTR = ""; +pub const __THROW = @compileError("unable to translate macro: undefined identifier `__nothrow__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:79:11 +pub const __THROWNL = @compileError("unable to translate macro: undefined identifier `__nothrow__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:80:11 +pub const __NTH = @compileError("unable to translate macro: undefined identifier `__nothrow__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:81:11 +pub const __NTHNL = @compileError("unable to translate macro: undefined identifier `__nothrow__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:82:11 +pub const __COLD = @compileError("unable to translate macro: undefined identifier `__cold__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:102:11 +pub inline fn __P(args: anytype) @TypeOf(args) { + _ = &args; + return args; +} +pub inline fn __PMT(args: anytype) @TypeOf(args) { + _ = &args; + return args; +} +pub const __CONCAT = @compileError("unable to translate C expr: unexpected token '##'"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:131:9 +pub const __STRING = @compileError("unable to translate C expr: unexpected token '#'"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:132:9 +pub const __ptr_t = ?*anyopaque; +pub const __BEGIN_DECLS = ""; +pub const __END_DECLS = ""; +pub const __attribute_overloadable__ = @compileError("unable to translate macro: undefined identifier `__overloadable__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:151:10 +pub inline fn __bos(ptr: anytype) @TypeOf(__builtin_object_size(ptr, __USE_FORTIFY_LEVEL > @as(c_int, 1))) { + _ = &ptr; + return __builtin_object_size(ptr, __USE_FORTIFY_LEVEL > @as(c_int, 1)); +} +pub inline fn __bos0(ptr: anytype) @TypeOf(__builtin_object_size(ptr, @as(c_int, 0))) { + _ = &ptr; + return __builtin_object_size(ptr, @as(c_int, 0)); +} +pub inline fn __glibc_objsize0(__o: anytype) @TypeOf(__bos0(__o)) { + _ = &__o; + return __bos0(__o); +} +pub inline fn __glibc_objsize(__o: anytype) @TypeOf(__bos(__o)) { + _ = &__o; + return __bos(__o); +} +pub const __warnattr = @compileError("unable to translate C expr: unexpected token ''"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:370:10 +pub const __errordecl = @compileError("unable to translate C expr: unexpected token 'extern'"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:371:10 +pub const __flexarr = @compileError("unable to translate C expr: unexpected token '['"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:379:10 +pub const __glibc_c99_flexarr_available = @as(c_int, 1); +pub const __REDIRECT = @compileError("unable to translate C expr: unexpected token '__asm__'"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:410:10 +pub const __REDIRECT_NTH = @compileError("unable to translate C expr: unexpected token '__asm__'"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:417:11 +pub const __REDIRECT_NTHNL = @compileError("unable to translate C expr: unexpected token '__asm__'"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:419:11 +pub const __ASMNAME = @compileError("unable to translate C expr: unexpected token ','"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:422:10 +pub inline fn __ASMNAME2(prefix: anytype, cname: anytype) @TypeOf(__STRING(prefix) ++ cname) { + _ = &prefix; + _ = &cname; + return __STRING(prefix) ++ cname; +} +pub const __REDIRECT_FORTIFY = __REDIRECT; +pub const __REDIRECT_FORTIFY_NTH = __REDIRECT_NTH; +pub const __attribute_malloc__ = @compileError("unable to translate macro: undefined identifier `__malloc__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:452:10 +pub const __attribute_alloc_size__ = @compileError("unable to translate C expr: unexpected token ''"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:463:10 +pub const __attribute_alloc_align__ = @compileError("unable to translate macro: undefined identifier `__alloc_align__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:469:10 +pub const __attribute_pure__ = @compileError("unable to translate macro: undefined identifier `__pure__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:479:10 +pub const __attribute_const__ = @compileError("unable to translate C expr: unexpected token '__attribute__'"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:486:10 +pub const __attribute_maybe_unused__ = @compileError("unable to translate macro: undefined identifier `__unused__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:492:10 +pub const __attribute_used__ = @compileError("unable to translate macro: undefined identifier `__used__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:501:10 +pub const __attribute_noinline__ = @compileError("unable to translate macro: undefined identifier `__noinline__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:502:10 +pub const __attribute_deprecated__ = @compileError("unable to translate macro: undefined identifier `__deprecated__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:510:10 +pub const __attribute_deprecated_msg__ = @compileError("unable to translate macro: undefined identifier `__deprecated__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:520:10 +pub const __attribute_format_arg__ = @compileError("unable to translate macro: undefined identifier `__format_arg__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:533:10 +pub const __attribute_format_strfmon__ = @compileError("unable to translate macro: undefined identifier `__format__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:543:10 +pub const __attribute_nonnull__ = @compileError("unable to translate macro: undefined identifier `__nonnull__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:555:11 +pub inline fn __nonnull(params: anytype) @TypeOf(__attribute_nonnull__(params)) { + _ = ¶ms; + return __attribute_nonnull__(params); +} +pub const __returns_nonnull = @compileError("unable to translate macro: undefined identifier `__returns_nonnull__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:568:10 +pub const __attribute_warn_unused_result__ = @compileError("unable to translate macro: undefined identifier `__warn_unused_result__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:577:10 +pub const __wur = ""; +pub const __always_inline = @compileError("unable to translate macro: undefined identifier `__always_inline__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:595:10 +pub const __attribute_artificial__ = @compileError("unable to translate macro: undefined identifier `__artificial__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:604:10 +pub const __extern_inline = @compileError("unable to translate macro: undefined identifier `__gnu_inline__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:622:11 +pub const __extern_always_inline = @compileError("unable to translate macro: undefined identifier `__gnu_inline__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:623:11 +pub const __fortify_function = __extern_always_inline ++ __attribute_artificial__; +pub const __restrict_arr = @compileError("unable to translate C expr: unexpected token '__restrict'"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:666:10 +pub inline fn __glibc_unlikely(cond: anytype) @TypeOf(__builtin_expect(cond, @as(c_int, 0))) { + _ = &cond; + return __builtin_expect(cond, @as(c_int, 0)); +} +pub inline fn __glibc_likely(cond: anytype) @TypeOf(__builtin_expect(cond, @as(c_int, 1))) { + _ = &cond; + return __builtin_expect(cond, @as(c_int, 1)); +} +pub const __attribute_nonstring__ = ""; +pub const __attribute_copy__ = @compileError("unable to translate C expr: unexpected token ''"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:715:10 +pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI = @as(c_int, 0); +pub inline fn __LDBL_REDIR1(name: anytype, proto: anytype, alias: anytype) @TypeOf(name ++ proto) { + _ = &name; + _ = &proto; + _ = &alias; + return name ++ proto; +} +pub inline fn __LDBL_REDIR(name: anytype, proto: anytype) @TypeOf(name ++ proto) { + _ = &name; + _ = &proto; + return name ++ proto; +} +pub inline fn __LDBL_REDIR1_NTH(name: anytype, proto: anytype, alias: anytype) @TypeOf(name ++ proto ++ __THROW) { + _ = &name; + _ = &proto; + _ = &alias; + return name ++ proto ++ __THROW; +} +pub inline fn __LDBL_REDIR_NTH(name: anytype, proto: anytype) @TypeOf(name ++ proto ++ __THROW) { + _ = &name; + _ = &proto; + return name ++ proto ++ __THROW; +} +pub const __LDBL_REDIR2_DECL = @compileError("unable to translate C expr: unexpected token ''"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:792:10 +pub const __LDBL_REDIR_DECL = @compileError("unable to translate C expr: unexpected token ''"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:793:10 +pub inline fn __REDIRECT_LDBL(name: anytype, proto: anytype, alias: anytype) @TypeOf(__REDIRECT(name, proto, alias)) { + _ = &name; + _ = &proto; + _ = &alias; + return __REDIRECT(name, proto, alias); +} +pub inline fn __REDIRECT_NTH_LDBL(name: anytype, proto: anytype, alias: anytype) @TypeOf(__REDIRECT_NTH(name, proto, alias)) { + _ = &name; + _ = &proto; + _ = &alias; + return __REDIRECT_NTH(name, proto, alias); +} +pub const __glibc_macro_warning1 = @compileError("unable to translate macro: undefined identifier `_Pragma`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:807:10 +pub const __glibc_macro_warning = @compileError("unable to translate macro: undefined identifier `GCC`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:808:10 +pub const __HAVE_GENERIC_SELECTION = @as(c_int, 1); +pub const __fortified_attr_access = @compileError("unable to translate C expr: unexpected token ''"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:853:11 +pub const __attr_access = @compileError("unable to translate C expr: unexpected token ''"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:854:11 +pub const __attr_access_none = @compileError("unable to translate C expr: unexpected token ''"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:855:11 +pub const __attr_dealloc = @compileError("unable to translate C expr: unexpected token ''"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:865:10 +pub const __attr_dealloc_free = ""; +pub const __attribute_returns_twice__ = @compileError("unable to translate macro: undefined identifier `__returns_twice__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:872:10 +pub const __attribute_struct_may_alias__ = @compileError("unable to translate macro: undefined identifier `__may_alias__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/cdefs.h:881:10 +pub const __stub___compat_bdflush = ""; +pub const __stub_chflags = ""; +pub const __stub_fchflags = ""; +pub const __stub_gtty = ""; +pub const __stub_revoke = ""; +pub const __stub_setlogin = ""; +pub const __stub_sigreturn = ""; +pub const __stub_stty = ""; +pub const __CLANG_STDINT_H = ""; +pub const _STDINT_H = @as(c_int, 1); +pub const __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION = ""; +pub const __GLIBC_USE_LIB_EXT2 = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_BFP_EXT = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_BFP_EXT_C23 = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_EXT = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_FUNCS_EXT = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C23 = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_TYPES_EXT = @as(c_int, 0); +pub const _BITS_TYPES_H = @as(c_int, 1); +pub const __S16_TYPE = c_short; +pub const __U16_TYPE = c_ushort; +pub const __S32_TYPE = c_int; +pub const __U32_TYPE = c_uint; +pub const __SLONGWORD_TYPE = c_long; +pub const __ULONGWORD_TYPE = c_ulong; +pub const __SQUAD_TYPE = c_long; +pub const __UQUAD_TYPE = c_ulong; +pub const __SWORD_TYPE = c_long; +pub const __UWORD_TYPE = c_ulong; +pub const __SLONG32_TYPE = c_int; +pub const __ULONG32_TYPE = c_uint; +pub const __S64_TYPE = c_long; +pub const __U64_TYPE = c_ulong; +pub const __STD_TYPE = @compileError("unable to translate C expr: unexpected token 'typedef'"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types.h:137:10 +pub const _BITS_TYPESIZES_H = @as(c_int, 1); +pub const __SYSCALL_SLONG_TYPE = __SLONGWORD_TYPE; +pub const __SYSCALL_ULONG_TYPE = __ULONGWORD_TYPE; +pub const __DEV_T_TYPE = __UQUAD_TYPE; +pub const __UID_T_TYPE = __U32_TYPE; +pub const __GID_T_TYPE = __U32_TYPE; +pub const __INO_T_TYPE = __SYSCALL_ULONG_TYPE; +pub const __INO64_T_TYPE = __UQUAD_TYPE; +pub const __MODE_T_TYPE = __U32_TYPE; +pub const __NLINK_T_TYPE = __SYSCALL_ULONG_TYPE; +pub const __FSWORD_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __OFF_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __OFF64_T_TYPE = __SQUAD_TYPE; +pub const __PID_T_TYPE = __S32_TYPE; +pub const __RLIM_T_TYPE = __SYSCALL_ULONG_TYPE; +pub const __RLIM64_T_TYPE = __UQUAD_TYPE; +pub const __BLKCNT_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __BLKCNT64_T_TYPE = __SQUAD_TYPE; +pub const __FSBLKCNT_T_TYPE = __SYSCALL_ULONG_TYPE; +pub const __FSBLKCNT64_T_TYPE = __UQUAD_TYPE; +pub const __FSFILCNT_T_TYPE = __SYSCALL_ULONG_TYPE; +pub const __FSFILCNT64_T_TYPE = __UQUAD_TYPE; +pub const __ID_T_TYPE = __U32_TYPE; +pub const __CLOCK_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __TIME_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __USECONDS_T_TYPE = __U32_TYPE; +pub const __SUSECONDS_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __SUSECONDS64_T_TYPE = __SQUAD_TYPE; +pub const __DADDR_T_TYPE = __S32_TYPE; +pub const __KEY_T_TYPE = __S32_TYPE; +pub const __CLOCKID_T_TYPE = __S32_TYPE; +pub const __TIMER_T_TYPE = ?*anyopaque; +pub const __BLKSIZE_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __FSID_T_TYPE = @compileError("unable to translate macro: undefined identifier `__val`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/typesizes.h:73:9 +pub const __SSIZE_T_TYPE = __SWORD_TYPE; +pub const __CPU_MASK_TYPE = __SYSCALL_ULONG_TYPE; +pub const __OFF_T_MATCHES_OFF64_T = @as(c_int, 1); +pub const __INO_T_MATCHES_INO64_T = @as(c_int, 1); +pub const __RLIM_T_MATCHES_RLIM64_T = @as(c_int, 1); +pub const __STATFS_MATCHES_STATFS64 = @as(c_int, 1); +pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64 = @as(c_int, 1); +pub const __FD_SETSIZE = @as(c_int, 1024); +pub const _BITS_TIME64_H = @as(c_int, 1); +pub const __TIME64_T_TYPE = __TIME_T_TYPE; +pub const _BITS_WCHAR_H = @as(c_int, 1); +pub const __WCHAR_MAX = __WCHAR_MAX__; +pub const __WCHAR_MIN = -__WCHAR_MAX - @as(c_int, 1); +pub const _BITS_STDINT_INTN_H = @as(c_int, 1); +pub const _BITS_STDINT_UINTN_H = @as(c_int, 1); +pub const _BITS_STDINT_LEAST_H = @as(c_int, 1); +pub const __intptr_t_defined = ""; +pub const INT8_MIN = -@as(c_int, 128); +pub const INT16_MIN = -@as(c_int, 32767) - @as(c_int, 1); +pub const INT32_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal) - @as(c_int, 1); +pub const INT64_MIN = -__INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)) - @as(c_int, 1); +pub const INT8_MAX = @as(c_int, 127); +pub const INT16_MAX = @as(c_int, 32767); +pub const INT32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const INT64_MAX = __INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)); +pub const UINT8_MAX = @as(c_int, 255); +pub const UINT16_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const UINT32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const UINT64_MAX = __UINT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 18446744073709551615, .decimal)); +pub const INT_LEAST8_MIN = -@as(c_int, 128); +pub const INT_LEAST16_MIN = -@as(c_int, 32767) - @as(c_int, 1); +pub const INT_LEAST32_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal) - @as(c_int, 1); +pub const INT_LEAST64_MIN = -__INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)) - @as(c_int, 1); +pub const INT_LEAST8_MAX = @as(c_int, 127); +pub const INT_LEAST16_MAX = @as(c_int, 32767); +pub const INT_LEAST32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const INT_LEAST64_MAX = __INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)); +pub const UINT_LEAST8_MAX = @as(c_int, 255); +pub const UINT_LEAST16_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const UINT_LEAST32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const UINT_LEAST64_MAX = __UINT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 18446744073709551615, .decimal)); +pub const INT_FAST8_MIN = -@as(c_int, 128); +pub const INT_FAST16_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal) - @as(c_int, 1); +pub const INT_FAST32_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal) - @as(c_int, 1); +pub const INT_FAST64_MIN = -__INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)) - @as(c_int, 1); +pub const INT_FAST8_MAX = @as(c_int, 127); +pub const INT_FAST16_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const INT_FAST32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const INT_FAST64_MAX = __INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)); +pub const UINT_FAST8_MAX = @as(c_int, 255); +pub const UINT_FAST16_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const UINT_FAST32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const UINT_FAST64_MAX = __UINT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 18446744073709551615, .decimal)); +pub const INTPTR_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal) - @as(c_int, 1); +pub const INTPTR_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const UINTPTR_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const INTMAX_MIN = -__INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)) - @as(c_int, 1); +pub const INTMAX_MAX = __INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)); +pub const UINTMAX_MAX = __UINT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 18446744073709551615, .decimal)); +pub const PTRDIFF_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal) - @as(c_int, 1); +pub const PTRDIFF_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const SIG_ATOMIC_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal) - @as(c_int, 1); +pub const SIG_ATOMIC_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const SIZE_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const WCHAR_MIN = __WCHAR_MIN; +pub const WCHAR_MAX = __WCHAR_MAX; +pub const WINT_MIN = @as(c_uint, 0); +pub const WINT_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub inline fn INT8_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub inline fn INT16_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub inline fn INT32_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub const INT64_C = @import("std").zig.c_translation.Macros.L_SUFFIX; +pub inline fn UINT8_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub inline fn UINT16_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub const UINT32_C = @import("std").zig.c_translation.Macros.U_SUFFIX; +pub const UINT64_C = @import("std").zig.c_translation.Macros.UL_SUFFIX; +pub const INTMAX_C = @import("std").zig.c_translation.Macros.L_SUFFIX; +pub const UINTMAX_C = @import("std").zig.c_translation.Macros.UL_SUFFIX; +pub const ____gwchar_t_defined = @as(c_int, 1); +pub const __PRI64_PREFIX = "l"; +pub const __PRIPTR_PREFIX = "l"; +pub const PRId8 = "d"; +pub const PRId16 = "d"; +pub const PRId32 = "d"; +pub const PRId64 = __PRI64_PREFIX ++ "d"; +pub const PRIdLEAST8 = "d"; +pub const PRIdLEAST16 = "d"; +pub const PRIdLEAST32 = "d"; +pub const PRIdLEAST64 = __PRI64_PREFIX ++ "d"; +pub const PRIdFAST8 = "d"; +pub const PRIdFAST16 = __PRIPTR_PREFIX ++ "d"; +pub const PRIdFAST32 = __PRIPTR_PREFIX ++ "d"; +pub const PRIdFAST64 = __PRI64_PREFIX ++ "d"; +pub const PRIi8 = "i"; +pub const PRIi16 = "i"; +pub const PRIi32 = "i"; +pub const PRIi64 = __PRI64_PREFIX ++ "i"; +pub const PRIiLEAST8 = "i"; +pub const PRIiLEAST16 = "i"; +pub const PRIiLEAST32 = "i"; +pub const PRIiLEAST64 = __PRI64_PREFIX ++ "i"; +pub const PRIiFAST8 = "i"; +pub const PRIiFAST16 = __PRIPTR_PREFIX ++ "i"; +pub const PRIiFAST32 = __PRIPTR_PREFIX ++ "i"; +pub const PRIiFAST64 = __PRI64_PREFIX ++ "i"; +pub const PRIo8 = "o"; +pub const PRIo16 = "o"; +pub const PRIo32 = "o"; +pub const PRIo64 = __PRI64_PREFIX ++ "o"; +pub const PRIoLEAST8 = "o"; +pub const PRIoLEAST16 = "o"; +pub const PRIoLEAST32 = "o"; +pub const PRIoLEAST64 = __PRI64_PREFIX ++ "o"; +pub const PRIoFAST8 = "o"; +pub const PRIoFAST16 = __PRIPTR_PREFIX ++ "o"; +pub const PRIoFAST32 = __PRIPTR_PREFIX ++ "o"; +pub const PRIoFAST64 = __PRI64_PREFIX ++ "o"; +pub const PRIu8 = "u"; +pub const PRIu16 = "u"; +pub const PRIu32 = "u"; +pub const PRIu64 = __PRI64_PREFIX ++ "u"; +pub const PRIuLEAST8 = "u"; +pub const PRIuLEAST16 = "u"; +pub const PRIuLEAST32 = "u"; +pub const PRIuLEAST64 = __PRI64_PREFIX ++ "u"; +pub const PRIuFAST8 = "u"; +pub const PRIuFAST16 = __PRIPTR_PREFIX ++ "u"; +pub const PRIuFAST32 = __PRIPTR_PREFIX ++ "u"; +pub const PRIuFAST64 = __PRI64_PREFIX ++ "u"; +pub const PRIx8 = "x"; +pub const PRIx16 = "x"; +pub const PRIx32 = "x"; +pub const PRIx64 = __PRI64_PREFIX ++ "x"; +pub const PRIxLEAST8 = "x"; +pub const PRIxLEAST16 = "x"; +pub const PRIxLEAST32 = "x"; +pub const PRIxLEAST64 = __PRI64_PREFIX ++ "x"; +pub const PRIxFAST8 = "x"; +pub const PRIxFAST16 = __PRIPTR_PREFIX ++ "x"; +pub const PRIxFAST32 = __PRIPTR_PREFIX ++ "x"; +pub const PRIxFAST64 = __PRI64_PREFIX ++ "x"; +pub const PRIX8 = "X"; +pub const PRIX16 = "X"; +pub const PRIX32 = "X"; +pub const PRIX64 = __PRI64_PREFIX ++ "X"; +pub const PRIXLEAST8 = "X"; +pub const PRIXLEAST16 = "X"; +pub const PRIXLEAST32 = "X"; +pub const PRIXLEAST64 = __PRI64_PREFIX ++ "X"; +pub const PRIXFAST8 = "X"; +pub const PRIXFAST16 = __PRIPTR_PREFIX ++ "X"; +pub const PRIXFAST32 = __PRIPTR_PREFIX ++ "X"; +pub const PRIXFAST64 = __PRI64_PREFIX ++ "X"; +pub const PRIdMAX = __PRI64_PREFIX ++ "d"; +pub const PRIiMAX = __PRI64_PREFIX ++ "i"; +pub const PRIoMAX = __PRI64_PREFIX ++ "o"; +pub const PRIuMAX = __PRI64_PREFIX ++ "u"; +pub const PRIxMAX = __PRI64_PREFIX ++ "x"; +pub const PRIXMAX = __PRI64_PREFIX ++ "X"; +pub const PRIdPTR = __PRIPTR_PREFIX ++ "d"; +pub const PRIiPTR = __PRIPTR_PREFIX ++ "i"; +pub const PRIoPTR = __PRIPTR_PREFIX ++ "o"; +pub const PRIuPTR = __PRIPTR_PREFIX ++ "u"; +pub const PRIxPTR = __PRIPTR_PREFIX ++ "x"; +pub const PRIXPTR = __PRIPTR_PREFIX ++ "X"; +pub const SCNd8 = "hhd"; +pub const SCNd16 = "hd"; +pub const SCNd32 = "d"; +pub const SCNd64 = __PRI64_PREFIX ++ "d"; +pub const SCNdLEAST8 = "hhd"; +pub const SCNdLEAST16 = "hd"; +pub const SCNdLEAST32 = "d"; +pub const SCNdLEAST64 = __PRI64_PREFIX ++ "d"; +pub const SCNdFAST8 = "hhd"; +pub const SCNdFAST16 = __PRIPTR_PREFIX ++ "d"; +pub const SCNdFAST32 = __PRIPTR_PREFIX ++ "d"; +pub const SCNdFAST64 = __PRI64_PREFIX ++ "d"; +pub const SCNi8 = "hhi"; +pub const SCNi16 = "hi"; +pub const SCNi32 = "i"; +pub const SCNi64 = __PRI64_PREFIX ++ "i"; +pub const SCNiLEAST8 = "hhi"; +pub const SCNiLEAST16 = "hi"; +pub const SCNiLEAST32 = "i"; +pub const SCNiLEAST64 = __PRI64_PREFIX ++ "i"; +pub const SCNiFAST8 = "hhi"; +pub const SCNiFAST16 = __PRIPTR_PREFIX ++ "i"; +pub const SCNiFAST32 = __PRIPTR_PREFIX ++ "i"; +pub const SCNiFAST64 = __PRI64_PREFIX ++ "i"; +pub const SCNu8 = "hhu"; +pub const SCNu16 = "hu"; +pub const SCNu32 = "u"; +pub const SCNu64 = __PRI64_PREFIX ++ "u"; +pub const SCNuLEAST8 = "hhu"; +pub const SCNuLEAST16 = "hu"; +pub const SCNuLEAST32 = "u"; +pub const SCNuLEAST64 = __PRI64_PREFIX ++ "u"; +pub const SCNuFAST8 = "hhu"; +pub const SCNuFAST16 = __PRIPTR_PREFIX ++ "u"; +pub const SCNuFAST32 = __PRIPTR_PREFIX ++ "u"; +pub const SCNuFAST64 = __PRI64_PREFIX ++ "u"; +pub const SCNo8 = "hho"; +pub const SCNo16 = "ho"; +pub const SCNo32 = "o"; +pub const SCNo64 = __PRI64_PREFIX ++ "o"; +pub const SCNoLEAST8 = "hho"; +pub const SCNoLEAST16 = "ho"; +pub const SCNoLEAST32 = "o"; +pub const SCNoLEAST64 = __PRI64_PREFIX ++ "o"; +pub const SCNoFAST8 = "hho"; +pub const SCNoFAST16 = __PRIPTR_PREFIX ++ "o"; +pub const SCNoFAST32 = __PRIPTR_PREFIX ++ "o"; +pub const SCNoFAST64 = __PRI64_PREFIX ++ "o"; +pub const SCNx8 = "hhx"; +pub const SCNx16 = "hx"; +pub const SCNx32 = "x"; +pub const SCNx64 = __PRI64_PREFIX ++ "x"; +pub const SCNxLEAST8 = "hhx"; +pub const SCNxLEAST16 = "hx"; +pub const SCNxLEAST32 = "x"; +pub const SCNxLEAST64 = __PRI64_PREFIX ++ "x"; +pub const SCNxFAST8 = "hhx"; +pub const SCNxFAST16 = __PRIPTR_PREFIX ++ "x"; +pub const SCNxFAST32 = __PRIPTR_PREFIX ++ "x"; +pub const SCNxFAST64 = __PRI64_PREFIX ++ "x"; +pub const SCNdMAX = __PRI64_PREFIX ++ "d"; +pub const SCNiMAX = __PRI64_PREFIX ++ "i"; +pub const SCNoMAX = __PRI64_PREFIX ++ "o"; +pub const SCNuMAX = __PRI64_PREFIX ++ "u"; +pub const SCNxMAX = __PRI64_PREFIX ++ "x"; +pub const SCNdPTR = __PRIPTR_PREFIX ++ "d"; +pub const SCNiPTR = __PRIPTR_PREFIX ++ "i"; +pub const SCNoPTR = __PRIPTR_PREFIX ++ "o"; +pub const SCNuPTR = __PRIPTR_PREFIX ++ "u"; +pub const SCNxPTR = __PRIPTR_PREFIX ++ "x"; +pub const _SIGNAL_H = ""; +pub const _BITS_SIGNUM_GENERIC_H = @as(c_int, 1); +pub const SIG_ERR = @import("std").zig.c_translation.cast(__sighandler_t, -@as(c_int, 1)); +pub const SIG_DFL = @import("std").zig.c_translation.cast(__sighandler_t, @as(c_int, 0)); +pub const SIG_IGN = @import("std").zig.c_translation.cast(__sighandler_t, @as(c_int, 1)); +pub const SIGINT = @as(c_int, 2); +pub const SIGILL = @as(c_int, 4); +pub const SIGABRT = @as(c_int, 6); +pub const SIGFPE = @as(c_int, 8); +pub const SIGSEGV = @as(c_int, 11); +pub const SIGTERM = @as(c_int, 15); +pub const SIGHUP = @as(c_int, 1); +pub const SIGQUIT = @as(c_int, 3); +pub const SIGTRAP = @as(c_int, 5); +pub const SIGKILL = @as(c_int, 9); +pub const SIGPIPE = @as(c_int, 13); +pub const SIGALRM = @as(c_int, 14); +pub const SIGIO = SIGPOLL; +pub const SIGIOT = SIGABRT; +pub const SIGCLD = SIGCHLD; +pub const _BITS_SIGNUM_ARCH_H = @as(c_int, 1); +pub const SIGSTKFLT = @as(c_int, 16); +pub const SIGPWR = @as(c_int, 30); +pub const SIGBUS = @as(c_int, 7); +pub const SIGSYS = @as(c_int, 31); +pub const SIGURG = @as(c_int, 23); +pub const SIGSTOP = @as(c_int, 19); +pub const SIGTSTP = @as(c_int, 20); +pub const SIGCONT = @as(c_int, 18); +pub const SIGCHLD = @as(c_int, 17); +pub const SIGTTIN = @as(c_int, 21); +pub const SIGTTOU = @as(c_int, 22); +pub const SIGPOLL = @as(c_int, 29); +pub const SIGXFSZ = @as(c_int, 25); +pub const SIGXCPU = @as(c_int, 24); +pub const SIGVTALRM = @as(c_int, 26); +pub const SIGPROF = @as(c_int, 27); +pub const SIGUSR1 = @as(c_int, 10); +pub const SIGUSR2 = @as(c_int, 12); +pub const SIGWINCH = @as(c_int, 28); +pub const __SIGRTMIN = @as(c_int, 32); +pub const __SIGRTMAX = @as(c_int, 64); +pub const _NSIG = __SIGRTMAX + @as(c_int, 1); +pub const __sig_atomic_t_defined = @as(c_int, 1); +pub const __sigset_t_defined = @as(c_int, 1); +pub const ____sigset_t_defined = ""; +pub const _SIGSET_NWORDS = @import("std").zig.c_translation.MacroArithmetic.div(@as(c_int, 1024), @as(c_int, 8) * @import("std").zig.c_translation.sizeof(c_ulong)); +pub const __pid_t_defined = ""; +pub const __uid_t_defined = ""; +pub const _STRUCT_TIMESPEC = @as(c_int, 1); +pub const _BITS_ENDIAN_H = @as(c_int, 1); +pub const __LITTLE_ENDIAN = @as(c_int, 1234); +pub const __BIG_ENDIAN = @as(c_int, 4321); +pub const __PDP_ENDIAN = @as(c_int, 3412); +pub const _BITS_ENDIANNESS_H = @as(c_int, 1); +pub const __BYTE_ORDER = __LITTLE_ENDIAN; +pub const __FLOAT_WORD_ORDER = __BYTE_ORDER; +pub inline fn __LONG_LONG_PAIR(HI: anytype, LO: anytype) @TypeOf(HI) { + _ = &HI; + _ = &LO; + return blk: { + _ = &LO; + break :blk HI; + }; +} +pub const __time_t_defined = @as(c_int, 1); +pub const __siginfo_t_defined = @as(c_int, 1); +pub const ____sigval_t_defined = ""; +pub const __SI_MAX_SIZE = @as(c_int, 128); +pub const __SI_PAD_SIZE = @import("std").zig.c_translation.MacroArithmetic.div(__SI_MAX_SIZE, @import("std").zig.c_translation.sizeof(c_int)) - @as(c_int, 4); +pub const _BITS_SIGINFO_ARCH_H = @as(c_int, 1); +pub const __SI_ALIGNMENT = ""; +pub const __SI_BAND_TYPE = c_long; +pub const __SI_CLOCK_T = __clock_t; +pub const __SI_ERRNO_THEN_CODE = @as(c_int, 1); +pub const __SI_HAVE_SIGSYS = @as(c_int, 1); +pub const __SI_SIGFAULT_ADDL = ""; +pub const si_pid = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:128:9 +pub const si_uid = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:129:9 +pub const si_timerid = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:130:9 +pub const si_overrun = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:131:9 +pub const si_status = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:132:9 +pub const si_utime = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:133:9 +pub const si_stime = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:134:9 +pub const si_value = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:135:9 +pub const si_int = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:136:9 +pub const si_ptr = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:137:9 +pub const si_addr = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:138:9 +pub const si_addr_lsb = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:139:9 +pub const si_lower = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:140:9 +pub const si_upper = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:141:9 +pub const si_pkey = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:142:9 +pub const si_band = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:143:9 +pub const si_fd = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:144:9 +pub const si_call_addr = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:146:10 +pub const si_syscall = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:147:10 +pub const si_arch = @compileError("unable to translate macro: undefined identifier `_sifields`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/siginfo_t.h:148:10 +pub const _BITS_SIGINFO_CONSTS_H = @as(c_int, 1); +pub const __SI_ASYNCIO_AFTER_SIGIO = @as(c_int, 1); +pub const __sigval_t_defined = ""; +pub const __sigevent_t_defined = @as(c_int, 1); +pub const __SIGEV_MAX_SIZE = @as(c_int, 64); +pub const __SIGEV_PAD_SIZE = @import("std").zig.c_translation.MacroArithmetic.div(__SIGEV_MAX_SIZE, @import("std").zig.c_translation.sizeof(c_int)) - @as(c_int, 4); +pub const __have_pthread_attr_t = @as(c_int, 1); +pub const sigev_notify_function = @compileError("unable to translate macro: undefined identifier `_sigev_un`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/sigevent_t.h:45:9 +pub const sigev_notify_attributes = @compileError("unable to translate macro: undefined identifier `_sigev_un`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/sigevent_t.h:46:9 +pub const _BITS_SIGEVENT_CONSTS_H = @as(c_int, 1); +pub inline fn sigmask(sig: anytype) @TypeOf(__glibc_macro_warning("sigmask is deprecated")(@import("std").zig.c_translation.cast(c_int, @as(c_uint, 1) << (sig - @as(c_int, 1))))) { + _ = &sig; + return __glibc_macro_warning("sigmask is deprecated")(@import("std").zig.c_translation.cast(c_int, @as(c_uint, 1) << (sig - @as(c_int, 1)))); +} +pub const NSIG = _NSIG; +pub const _BITS_SIGACTION_H = @as(c_int, 1); +pub const sa_handler = @compileError("unable to translate macro: undefined identifier `__sigaction_handler`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/sigaction.h:39:10 +pub const sa_sigaction = @compileError("unable to translate macro: undefined identifier `__sigaction_handler`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/sigaction.h:40:10 +pub const SA_NOCLDSTOP = @as(c_int, 1); +pub const SA_NOCLDWAIT = @as(c_int, 2); +pub const SA_SIGINFO = @as(c_int, 4); +pub const SA_ONSTACK = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x08000000, .hex); +pub const SA_RESTART = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x10000000, .hex); +pub const SA_NODEFER = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x40000000, .hex); +pub const SA_RESETHAND = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x80000000, .hex); +pub const SA_INTERRUPT = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x20000000, .hex); +pub const SA_NOMASK = SA_NODEFER; +pub const SA_ONESHOT = SA_RESETHAND; +pub const SA_STACK = SA_ONSTACK; +pub const SIG_BLOCK = @as(c_int, 0); +pub const SIG_UNBLOCK = @as(c_int, 1); +pub const SIG_SETMASK = @as(c_int, 2); +pub const _BITS_SIGCONTEXT_H = @as(c_int, 1); +pub const FP_XSTATE_MAGIC1 = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x46505853, .hex); +pub const FP_XSTATE_MAGIC2 = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x46505845, .hex); +pub const FP_XSTATE_MAGIC2_SIZE = @import("std").zig.c_translation.sizeof(FP_XSTATE_MAGIC2); +pub const __need_size_t = ""; +pub const _SIZE_T = ""; +pub const __stack_t_defined = @as(c_int, 1); +pub const _SYS_UCONTEXT_H = @as(c_int, 1); +pub inline fn __ctx(fld: anytype) @TypeOf(fld) { + _ = &fld; + return fld; +} +pub const __NGREG = @as(c_int, 23); +pub const NGREG = __NGREG; +pub const _BITS_SIGSTACK_H = @as(c_int, 1); +pub const MINSIGSTKSZ = @as(c_int, 2048); +pub const SIGSTKSZ = @as(c_int, 8192); +pub const _BITS_SS_FLAGS_H = @as(c_int, 1); +pub const __sigstack_defined = @as(c_int, 1); +pub const _BITS_PTHREADTYPES_COMMON_H = @as(c_int, 1); +pub const _THREAD_SHARED_TYPES_H = @as(c_int, 1); +pub const _BITS_PTHREADTYPES_ARCH_H = @as(c_int, 1); +pub const __SIZEOF_PTHREAD_MUTEX_T = @as(c_int, 40); +pub const __SIZEOF_PTHREAD_ATTR_T = @as(c_int, 56); +pub const __SIZEOF_PTHREAD_RWLOCK_T = @as(c_int, 56); +pub const __SIZEOF_PTHREAD_BARRIER_T = @as(c_int, 32); +pub const __SIZEOF_PTHREAD_MUTEXATTR_T = @as(c_int, 4); +pub const __SIZEOF_PTHREAD_COND_T = @as(c_int, 48); +pub const __SIZEOF_PTHREAD_CONDATTR_T = @as(c_int, 4); +pub const __SIZEOF_PTHREAD_RWLOCKATTR_T = @as(c_int, 8); +pub const __SIZEOF_PTHREAD_BARRIERATTR_T = @as(c_int, 4); +pub const __LOCK_ALIGNMENT = ""; +pub const __ONCE_ALIGNMENT = ""; +pub const _BITS_ATOMIC_WIDE_COUNTER_H = ""; +pub const _THREAD_MUTEX_INTERNAL_H = @as(c_int, 1); +pub const __PTHREAD_MUTEX_HAVE_PREV = @as(c_int, 1); +pub const __PTHREAD_MUTEX_INITIALIZER = @compileError("unable to translate C expr: unexpected token '{'"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/struct_mutex.h:56:10 +pub const _RWLOCK_INTERNAL_H = ""; +pub const __PTHREAD_RWLOCK_ELISION_EXTRA = @compileError("unable to translate C expr: unexpected token '{'"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/struct_rwlock.h:40:11 +pub inline fn __PTHREAD_RWLOCK_INITIALIZER(__flags: anytype) @TypeOf(__flags) { + _ = &__flags; + return blk: { + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = &__PTHREAD_RWLOCK_ELISION_EXTRA; + _ = @as(c_int, 0); + break :blk __flags; + }; +} +pub const __ONCE_FLAG_INIT = @compileError("unable to translate C expr: unexpected token '{'"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/thread-shared-types.h:113:9 +pub const _BITS_SIGTHREAD_H = @as(c_int, 1); +pub const SIGRTMIN = __libc_current_sigrtmin(); +pub const SIGRTMAX = __libc_current_sigrtmax(); +pub const __need_wchar_t = ""; +pub const __need_NULL = ""; +pub const _WCHAR_T = ""; +pub const NULL = @import("std").zig.c_translation.cast(?*anyopaque, @as(c_int, 0)); +pub const _STDLIB_H = @as(c_int, 1); +pub const WNOHANG = @as(c_int, 1); +pub const WUNTRACED = @as(c_int, 2); +pub const WSTOPPED = @as(c_int, 2); +pub const WEXITED = @as(c_int, 4); +pub const WCONTINUED = @as(c_int, 8); +pub const WNOWAIT = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x01000000, .hex); +pub const __WNOTHREAD = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x20000000, .hex); +pub const __WALL = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x40000000, .hex); +pub const __WCLONE = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x80000000, .hex); +pub inline fn __WEXITSTATUS(status: anytype) @TypeOf((status & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xff00, .hex)) >> @as(c_int, 8)) { + _ = &status; + return (status & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xff00, .hex)) >> @as(c_int, 8); +} +pub inline fn __WTERMSIG(status: anytype) @TypeOf(status & @as(c_int, 0x7f)) { + _ = &status; + return status & @as(c_int, 0x7f); +} +pub inline fn __WSTOPSIG(status: anytype) @TypeOf(__WEXITSTATUS(status)) { + _ = &status; + return __WEXITSTATUS(status); +} +pub inline fn __WIFEXITED(status: anytype) @TypeOf(__WTERMSIG(status) == @as(c_int, 0)) { + _ = &status; + return __WTERMSIG(status) == @as(c_int, 0); +} +pub inline fn __WIFSIGNALED(status: anytype) @TypeOf((@import("std").zig.c_translation.cast(i8, (status & @as(c_int, 0x7f)) + @as(c_int, 1)) >> @as(c_int, 1)) > @as(c_int, 0)) { + _ = &status; + return (@import("std").zig.c_translation.cast(i8, (status & @as(c_int, 0x7f)) + @as(c_int, 1)) >> @as(c_int, 1)) > @as(c_int, 0); +} +pub inline fn __WIFSTOPPED(status: anytype) @TypeOf((status & @as(c_int, 0xff)) == @as(c_int, 0x7f)) { + _ = &status; + return (status & @as(c_int, 0xff)) == @as(c_int, 0x7f); +} +pub inline fn __WIFCONTINUED(status: anytype) @TypeOf(status == __W_CONTINUED) { + _ = &status; + return status == __W_CONTINUED; +} +pub inline fn __WCOREDUMP(status: anytype) @TypeOf(status & __WCOREFLAG) { + _ = &status; + return status & __WCOREFLAG; +} +pub inline fn __W_EXITCODE(ret: anytype, sig: anytype) @TypeOf((ret << @as(c_int, 8)) | sig) { + _ = &ret; + _ = &sig; + return (ret << @as(c_int, 8)) | sig; +} +pub inline fn __W_STOPCODE(sig: anytype) @TypeOf((sig << @as(c_int, 8)) | @as(c_int, 0x7f)) { + _ = &sig; + return (sig << @as(c_int, 8)) | @as(c_int, 0x7f); +} +pub const __W_CONTINUED = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffff, .hex); +pub const __WCOREFLAG = @as(c_int, 0x80); +pub inline fn WEXITSTATUS(status: anytype) @TypeOf(__WEXITSTATUS(status)) { + _ = &status; + return __WEXITSTATUS(status); +} +pub inline fn WTERMSIG(status: anytype) @TypeOf(__WTERMSIG(status)) { + _ = &status; + return __WTERMSIG(status); +} +pub inline fn WSTOPSIG(status: anytype) @TypeOf(__WSTOPSIG(status)) { + _ = &status; + return __WSTOPSIG(status); +} +pub inline fn WIFEXITED(status: anytype) @TypeOf(__WIFEXITED(status)) { + _ = &status; + return __WIFEXITED(status); +} +pub inline fn WIFSIGNALED(status: anytype) @TypeOf(__WIFSIGNALED(status)) { + _ = &status; + return __WIFSIGNALED(status); +} +pub inline fn WIFSTOPPED(status: anytype) @TypeOf(__WIFSTOPPED(status)) { + _ = &status; + return __WIFSTOPPED(status); +} +pub inline fn WIFCONTINUED(status: anytype) @TypeOf(__WIFCONTINUED(status)) { + _ = &status; + return __WIFCONTINUED(status); +} +pub const _BITS_FLOATN_H = ""; +pub const __HAVE_FLOAT128 = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT128 = @as(c_int, 0); +pub const __HAVE_FLOAT64X = @as(c_int, 1); +pub const __HAVE_FLOAT64X_LONG_DOUBLE = @as(c_int, 1); +pub const _BITS_FLOATN_COMMON_H = ""; +pub const __HAVE_FLOAT16 = @as(c_int, 0); +pub const __HAVE_FLOAT32 = @as(c_int, 1); +pub const __HAVE_FLOAT64 = @as(c_int, 1); +pub const __HAVE_FLOAT32X = @as(c_int, 1); +pub const __HAVE_FLOAT128X = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT16 = __HAVE_FLOAT16; +pub const __HAVE_DISTINCT_FLOAT32 = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT64 = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT32X = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT64X = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT128X = __HAVE_FLOAT128X; +pub const __HAVE_FLOAT128_UNLIKE_LDBL = (__HAVE_DISTINCT_FLOAT128 != 0) and (__LDBL_MANT_DIG__ != @as(c_int, 113)); +pub const __HAVE_FLOATN_NOT_TYPEDEF = @as(c_int, 0); +pub const __f32 = @import("std").zig.c_translation.Macros.F_SUFFIX; +pub inline fn __f64(x: anytype) @TypeOf(x) { + _ = &x; + return x; +} +pub inline fn __f32x(x: anytype) @TypeOf(x) { + _ = &x; + return x; +} +pub const __f64x = @import("std").zig.c_translation.Macros.L_SUFFIX; +pub const __CFLOAT32 = @compileError("unable to translate: TODO _Complex"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/floatn-common.h:149:12 +pub const __CFLOAT64 = @compileError("unable to translate: TODO _Complex"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/floatn-common.h:160:13 +pub const __CFLOAT32X = @compileError("unable to translate: TODO _Complex"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/floatn-common.h:169:12 +pub const __CFLOAT64X = @compileError("unable to translate: TODO _Complex"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/floatn-common.h:178:13 +pub inline fn __builtin_huge_valf32() @TypeOf(__builtin_huge_valf()) { + return __builtin_huge_valf(); +} +pub inline fn __builtin_inff32() @TypeOf(__builtin_inff()) { + return __builtin_inff(); +} +pub inline fn __builtin_nanf32(x: anytype) @TypeOf(__builtin_nanf(x)) { + _ = &x; + return __builtin_nanf(x); +} +pub const __builtin_nansf32 = @compileError("unable to translate macro: undefined identifier `__builtin_nansf`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/floatn-common.h:221:12 +pub const __builtin_huge_valf64 = @compileError("unable to translate macro: undefined identifier `__builtin_huge_val`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/floatn-common.h:255:13 +pub const __builtin_inff64 = @compileError("unable to translate macro: undefined identifier `__builtin_inf`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/floatn-common.h:256:13 +pub const __builtin_nanf64 = @compileError("unable to translate macro: undefined identifier `__builtin_nan`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/floatn-common.h:257:13 +pub const __builtin_nansf64 = @compileError("unable to translate macro: undefined identifier `__builtin_nans`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/floatn-common.h:258:13 +pub const __builtin_huge_valf32x = @compileError("unable to translate macro: undefined identifier `__builtin_huge_val`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/floatn-common.h:272:12 +pub const __builtin_inff32x = @compileError("unable to translate macro: undefined identifier `__builtin_inf`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/floatn-common.h:273:12 +pub const __builtin_nanf32x = @compileError("unable to translate macro: undefined identifier `__builtin_nan`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/floatn-common.h:274:12 +pub const __builtin_nansf32x = @compileError("unable to translate macro: undefined identifier `__builtin_nans`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/floatn-common.h:275:12 +pub const __builtin_huge_valf64x = @compileError("unable to translate macro: undefined identifier `__builtin_huge_vall`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/floatn-common.h:289:13 +pub const __builtin_inff64x = @compileError("unable to translate macro: undefined identifier `__builtin_infl`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/floatn-common.h:290:13 +pub const __builtin_nanf64x = @compileError("unable to translate macro: undefined identifier `__builtin_nanl`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/floatn-common.h:291:13 +pub const __builtin_nansf64x = @compileError("unable to translate macro: undefined identifier `__builtin_nansl`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/floatn-common.h:292:13 +pub const __ldiv_t_defined = @as(c_int, 1); +pub const __lldiv_t_defined = @as(c_int, 1); +pub const RAND_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const EXIT_FAILURE = @as(c_int, 1); +pub const EXIT_SUCCESS = @as(c_int, 0); +pub const MB_CUR_MAX = __ctype_get_mb_cur_max(); +pub const _SYS_TYPES_H = @as(c_int, 1); +pub const __u_char_defined = ""; +pub const __ino_t_defined = ""; +pub const __dev_t_defined = ""; +pub const __gid_t_defined = ""; +pub const __mode_t_defined = ""; +pub const __nlink_t_defined = ""; +pub const __off_t_defined = ""; +pub const __id_t_defined = ""; +pub const __ssize_t_defined = ""; +pub const __daddr_t_defined = ""; +pub const __key_t_defined = ""; +pub const __clock_t_defined = @as(c_int, 1); +pub const __clockid_t_defined = @as(c_int, 1); +pub const __timer_t_defined = @as(c_int, 1); +pub const __BIT_TYPES_DEFINED__ = @as(c_int, 1); +pub const _ENDIAN_H = @as(c_int, 1); +pub const LITTLE_ENDIAN = __LITTLE_ENDIAN; +pub const BIG_ENDIAN = __BIG_ENDIAN; +pub const PDP_ENDIAN = __PDP_ENDIAN; +pub const BYTE_ORDER = __BYTE_ORDER; +pub const _BITS_BYTESWAP_H = @as(c_int, 1); +pub inline fn __bswap_constant_16(x: anytype) __uint16_t { + _ = &x; + return @import("std").zig.c_translation.cast(__uint16_t, ((x >> @as(c_int, 8)) & @as(c_int, 0xff)) | ((x & @as(c_int, 0xff)) << @as(c_int, 8))); +} +pub inline fn __bswap_constant_32(x: anytype) @TypeOf(((((x & @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0xff000000, .hex)) >> @as(c_int, 24)) | ((x & @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x00ff0000, .hex)) >> @as(c_int, 8))) | ((x & @as(c_uint, 0x0000ff00)) << @as(c_int, 8))) | ((x & @as(c_uint, 0x000000ff)) << @as(c_int, 24))) { + _ = &x; + return ((((x & @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0xff000000, .hex)) >> @as(c_int, 24)) | ((x & @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x00ff0000, .hex)) >> @as(c_int, 8))) | ((x & @as(c_uint, 0x0000ff00)) << @as(c_int, 8))) | ((x & @as(c_uint, 0x000000ff)) << @as(c_int, 24)); +} +pub inline fn __bswap_constant_64(x: anytype) @TypeOf(((((((((x & @as(c_ulonglong, 0xff00000000000000)) >> @as(c_int, 56)) | ((x & @as(c_ulonglong, 0x00ff000000000000)) >> @as(c_int, 40))) | ((x & @as(c_ulonglong, 0x0000ff0000000000)) >> @as(c_int, 24))) | ((x & @as(c_ulonglong, 0x000000ff00000000)) >> @as(c_int, 8))) | ((x & @as(c_ulonglong, 0x00000000ff000000)) << @as(c_int, 8))) | ((x & @as(c_ulonglong, 0x0000000000ff0000)) << @as(c_int, 24))) | ((x & @as(c_ulonglong, 0x000000000000ff00)) << @as(c_int, 40))) | ((x & @as(c_ulonglong, 0x00000000000000ff)) << @as(c_int, 56))) { + _ = &x; + return ((((((((x & @as(c_ulonglong, 0xff00000000000000)) >> @as(c_int, 56)) | ((x & @as(c_ulonglong, 0x00ff000000000000)) >> @as(c_int, 40))) | ((x & @as(c_ulonglong, 0x0000ff0000000000)) >> @as(c_int, 24))) | ((x & @as(c_ulonglong, 0x000000ff00000000)) >> @as(c_int, 8))) | ((x & @as(c_ulonglong, 0x00000000ff000000)) << @as(c_int, 8))) | ((x & @as(c_ulonglong, 0x0000000000ff0000)) << @as(c_int, 24))) | ((x & @as(c_ulonglong, 0x000000000000ff00)) << @as(c_int, 40))) | ((x & @as(c_ulonglong, 0x00000000000000ff)) << @as(c_int, 56)); +} +pub const _BITS_UINTN_IDENTITY_H = @as(c_int, 1); +pub inline fn htobe16(x: anytype) @TypeOf(__bswap_16(x)) { + _ = &x; + return __bswap_16(x); +} +pub inline fn htole16(x: anytype) @TypeOf(__uint16_identity(x)) { + _ = &x; + return __uint16_identity(x); +} +pub inline fn be16toh(x: anytype) @TypeOf(__bswap_16(x)) { + _ = &x; + return __bswap_16(x); +} +pub inline fn le16toh(x: anytype) @TypeOf(__uint16_identity(x)) { + _ = &x; + return __uint16_identity(x); +} +pub inline fn htobe32(x: anytype) @TypeOf(__bswap_32(x)) { + _ = &x; + return __bswap_32(x); +} +pub inline fn htole32(x: anytype) @TypeOf(__uint32_identity(x)) { + _ = &x; + return __uint32_identity(x); +} +pub inline fn be32toh(x: anytype) @TypeOf(__bswap_32(x)) { + _ = &x; + return __bswap_32(x); +} +pub inline fn le32toh(x: anytype) @TypeOf(__uint32_identity(x)) { + _ = &x; + return __uint32_identity(x); +} +pub inline fn htobe64(x: anytype) @TypeOf(__bswap_64(x)) { + _ = &x; + return __bswap_64(x); +} +pub inline fn htole64(x: anytype) @TypeOf(__uint64_identity(x)) { + _ = &x; + return __uint64_identity(x); +} +pub inline fn be64toh(x: anytype) @TypeOf(__bswap_64(x)) { + _ = &x; + return __bswap_64(x); +} +pub inline fn le64toh(x: anytype) @TypeOf(__uint64_identity(x)) { + _ = &x; + return __uint64_identity(x); +} +pub const _SYS_SELECT_H = @as(c_int, 1); +pub const __FD_ZERO = @compileError("unable to translate macro: undefined identifier `__i`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/select.h:25:9 +pub const __FD_SET = @compileError("unable to translate C expr: expected ')' instead got '|='"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/select.h:32:9 +pub const __FD_CLR = @compileError("unable to translate C expr: expected ')' instead got '&='"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/select.h:34:9 +pub inline fn __FD_ISSET(d: anytype, s: anytype) @TypeOf((__FDS_BITS(s)[@as(usize, @intCast(__FD_ELT(d)))] & __FD_MASK(d)) != @as(c_int, 0)) { + _ = &d; + _ = &s; + return (__FDS_BITS(s)[@as(usize, @intCast(__FD_ELT(d)))] & __FD_MASK(d)) != @as(c_int, 0); +} +pub const __timeval_defined = @as(c_int, 1); +pub const __suseconds_t_defined = ""; +pub const __NFDBITS = @as(c_int, 8) * @import("std").zig.c_translation.cast(c_int, @import("std").zig.c_translation.sizeof(__fd_mask)); +pub inline fn __FD_ELT(d: anytype) @TypeOf(@import("std").zig.c_translation.MacroArithmetic.div(d, __NFDBITS)) { + _ = &d; + return @import("std").zig.c_translation.MacroArithmetic.div(d, __NFDBITS); +} +pub inline fn __FD_MASK(d: anytype) __fd_mask { + _ = &d; + return @import("std").zig.c_translation.cast(__fd_mask, @as(c_ulong, 1) << @import("std").zig.c_translation.MacroArithmetic.rem(d, __NFDBITS)); +} +pub inline fn __FDS_BITS(set: anytype) @TypeOf(set.*.__fds_bits) { + _ = &set; + return set.*.__fds_bits; +} +pub const FD_SETSIZE = __FD_SETSIZE; +pub const NFDBITS = __NFDBITS; +pub inline fn FD_SET(fd: anytype, fdsetp: anytype) @TypeOf(__FD_SET(fd, fdsetp)) { + _ = &fd; + _ = &fdsetp; + return __FD_SET(fd, fdsetp); +} +pub inline fn FD_CLR(fd: anytype, fdsetp: anytype) @TypeOf(__FD_CLR(fd, fdsetp)) { + _ = &fd; + _ = &fdsetp; + return __FD_CLR(fd, fdsetp); +} +pub inline fn FD_ISSET(fd: anytype, fdsetp: anytype) @TypeOf(__FD_ISSET(fd, fdsetp)) { + _ = &fd; + _ = &fdsetp; + return __FD_ISSET(fd, fdsetp); +} +pub inline fn FD_ZERO(fdsetp: anytype) @TypeOf(__FD_ZERO(fdsetp)) { + _ = &fdsetp; + return __FD_ZERO(fdsetp); +} +pub const __blksize_t_defined = ""; +pub const __blkcnt_t_defined = ""; +pub const __fsblkcnt_t_defined = ""; +pub const __fsfilcnt_t_defined = ""; +pub const _ALLOCA_H = @as(c_int, 1); +pub const __COMPAR_FN_T = ""; +pub const _STRING_H = @as(c_int, 1); +pub const _BITS_TYPES_LOCALE_T_H = @as(c_int, 1); +pub const _BITS_TYPES___LOCALE_T_H = @as(c_int, 1); +pub const _STRINGS_H = @as(c_int, 1); +pub const __need_ptrdiff_t = ""; +pub const __need_max_align_t = ""; +pub const __need_offsetof = ""; +pub const __STDDEF_H = ""; +pub const _PTRDIFF_T = ""; +pub const __CLANG_MAX_ALIGN_T_DEFINED = ""; +pub const offsetof = @compileError("unable to translate C expr: unexpected token 'an identifier'"); +// /home/mason/.cache/zig/p/N-V-__8AAN5NhBR0oTsvnwjPdeNiiDLtEsfXRHd1fv-R3TOv/lib/include/__stddef_offsetof.h:16:9 +pub const _STDIO_H = @as(c_int, 1); +pub const __need___va_list = ""; +pub const __GNUC_VA_LIST = ""; +pub const _____fpos_t_defined = @as(c_int, 1); +pub const ____mbstate_t_defined = @as(c_int, 1); +pub const _____fpos64_t_defined = @as(c_int, 1); +pub const ____FILE_defined = @as(c_int, 1); +pub const __FILE_defined = @as(c_int, 1); +pub const __struct_FILE_defined = @as(c_int, 1); +pub const __getc_unlocked_body = @compileError("TODO postfix inc/dec expr"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/struct_FILE.h:102:9 +pub const __putc_unlocked_body = @compileError("TODO postfix inc/dec expr"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/types/struct_FILE.h:106:9 +pub const _IO_EOF_SEEN = @as(c_int, 0x0010); +pub inline fn __feof_unlocked_body(_fp: anytype) @TypeOf((_fp.*._flags & _IO_EOF_SEEN) != @as(c_int, 0)) { + _ = &_fp; + return (_fp.*._flags & _IO_EOF_SEEN) != @as(c_int, 0); +} +pub const _IO_ERR_SEEN = @as(c_int, 0x0020); +pub inline fn __ferror_unlocked_body(_fp: anytype) @TypeOf((_fp.*._flags & _IO_ERR_SEEN) != @as(c_int, 0)) { + _ = &_fp; + return (_fp.*._flags & _IO_ERR_SEEN) != @as(c_int, 0); +} +pub const _IO_USER_LOCK = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8000, .hex); +pub const __cookie_io_functions_t_defined = @as(c_int, 1); +pub const _VA_LIST_DEFINED = ""; +pub const _IOFBF = @as(c_int, 0); +pub const _IOLBF = @as(c_int, 1); +pub const _IONBF = @as(c_int, 2); +pub const BUFSIZ = @as(c_int, 8192); +pub const EOF = -@as(c_int, 1); +pub const SEEK_SET = @as(c_int, 0); +pub const SEEK_CUR = @as(c_int, 1); +pub const SEEK_END = @as(c_int, 2); +pub const P_tmpdir = "/tmp"; +pub const L_tmpnam = @as(c_int, 20); +pub const TMP_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 238328, .decimal); +pub const _BITS_STDIO_LIM_H = @as(c_int, 1); +pub const FILENAME_MAX = @as(c_int, 4096); +pub const L_ctermid = @as(c_int, 9); +pub const FOPEN_MAX = @as(c_int, 16); +pub const __attr_dealloc_fclose = __attr_dealloc(fclose, @as(c_int, 1)); +pub const __STDBOOL_H = ""; +pub const __bool_true_false_are_defined = @as(c_int, 1); +pub const @"bool" = bool; +pub const @"true" = @as(c_int, 1); +pub const @"false" = @as(c_int, 0); +pub const SPA_STATIC_ASSERT_IMPL = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:27:11 +pub const SPA_ALIGNOF = @compileError("unable to translate C expr: expected '(' instead got ''"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:28:11 +pub const SPA_STATIC_ASSERT = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:39:9 +pub const SPA_CONCAT_NOEXPAND = @compileError("unable to translate C expr: unexpected token '##'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:41:9 +pub inline fn SPA_CONCAT(a: anytype, b: anytype) @TypeOf(SPA_CONCAT_NOEXPAND(a, b)) { + _ = &a; + _ = &b; + return SPA_CONCAT_NOEXPAND(a, b); +} +pub const SPA_FALLTHROUGH = @compileError("unable to translate macro: undefined identifier `fallthrough`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:73:11 +pub inline fn SPA_FLAG_MASK(field: anytype, mask: anytype, flag: anytype) @TypeOf((field & mask) == flag) { + _ = &field; + _ = &mask; + _ = &flag; + return (field & mask) == flag; +} +pub inline fn SPA_FLAG_IS_SET(field: anytype, flag: anytype) @TypeOf(SPA_FLAG_MASK(field, flag, flag)) { + _ = &field; + _ = &flag; + return SPA_FLAG_MASK(field, flag, flag); +} +pub const SPA_FLAG_SET = @compileError("unable to translate C expr: expected ')' instead got '|='"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:81:9 +pub const SPA_FLAG_CLEAR = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:82:9 +pub inline fn SPA_FLAG_UPDATE(field: anytype, flag: anytype, val: anytype) @TypeOf(if (val) SPA_FLAG_SET(field, flag) else SPA_FLAG_CLEAR(field, flag)) { + _ = &field; + _ = &flag; + _ = &val; + return if (val) SPA_FLAG_SET(field, flag) else SPA_FLAG_CLEAR(field, flag); +} +pub inline fn SPA_DIRECTION_REVERSE(d: anytype) @TypeOf(d ^ @as(c_int, 1)) { + _ = &d; + return d ^ @as(c_int, 1); +} +pub inline fn SPA_RECTANGLE(width: anytype, height: anytype) struct_spa_rectangle { + _ = &width; + _ = &height; + return @import("std").mem.zeroInit(struct_spa_rectangle, .{ width, height }); +} +pub inline fn SPA_POINT(x: anytype, y: anytype) struct_spa_point { + _ = &x; + _ = &y; + return @import("std").mem.zeroInit(struct_spa_point, .{ x, y }); +} +pub inline fn SPA_REGION(x: anytype, y: anytype, width: anytype, height: anytype) struct_spa_region { + _ = &x; + _ = &y; + _ = &width; + _ = &height; + return @import("std").mem.zeroInit(struct_spa_region, .{ SPA_POINT(x, y), SPA_RECTANGLE(width, height) }); +} +pub inline fn SPA_FRACTION(num: anytype, denom: anytype) struct_spa_fraction { + _ = # + _ = &denom; + return @import("std").mem.zeroInit(struct_spa_fraction, .{ num, denom }); +} +pub const SPA_N_ELEMENTS = @compileError("unable to translate C expr: unexpected token '('"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:124:9 +pub const SPA_FOR_EACH_ELEMENT = @compileError("unable to translate C expr: unexpected token 'for'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:135:9 +pub const SPA_FOR_EACH_ELEMENT_VAR = @compileError("unable to translate C expr: unexpected token 'for'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:138:9 +pub const SPA_ABS = @compileError("unable to translate macro: undefined identifier `_a`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:141:9 +pub const SPA_MIN = @compileError("unable to translate macro: undefined identifier `_min_a`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:146:9 +pub const SPA_MAX = @compileError("unable to translate macro: undefined identifier `_max_a`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:152:9 +pub const SPA_CLAMP = @compileError("unable to translate macro: undefined identifier `_v`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:158:9 +pub const SPA_CLAMPF = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:166:9 +pub const SPA_CLAMPD = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:170:9 +pub const SPA_SWAP = @compileError("unable to translate macro: undefined identifier `_t`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:176:9 +pub const SPA_TYPECHECK = @compileError("unable to translate macro: undefined identifier `_dummy`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:182:9 +pub const SPA_CMP = @compileError("unable to translate macro: undefined identifier `_a`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:190:9 +pub const SPA_PTROFF = @compileError("unable to translate C expr: unexpected token ')'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:202:9 +pub inline fn SPA_PTROFF_ALIGN(ptr_: anytype, offset_: anytype, alignment_: anytype, type_: anytype) @TypeOf(SPA_PTR_ALIGN(SPA_PTROFF(ptr_, offset_, type_), alignment_, type_)) { + _ = &ptr_; + _ = &offset_; + _ = &alignment_; + _ = &type_; + return SPA_PTR_ALIGN(SPA_PTROFF(ptr_, offset_, type_), alignment_, type_); +} +pub inline fn SPA_MEMBER(b: anytype, o: anytype, t: anytype) @TypeOf(SPA_PTROFF(b, o, t)) { + _ = &b; + _ = &o; + _ = &t; + return SPA_PTROFF(b, o, t); +} +pub inline fn SPA_MEMBER_ALIGN(b: anytype, o: anytype, a: anytype, t: anytype) @TypeOf(SPA_PTROFF_ALIGN(b, o, a, t)) { + _ = &b; + _ = &o; + _ = &a; + _ = &t; + return SPA_PTROFF_ALIGN(b, o, a, t); +} +pub const SPA_CONTAINER_OF = @compileError("unable to translate C expr: unexpected token ')'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:212:9 +pub inline fn SPA_PTRDIFF(p1: anytype, p2: anytype) @TypeOf(@import("std").zig.c_translation.cast(isize, p1) - @import("std").zig.c_translation.cast(isize, p2)) { + _ = &p1; + _ = &p2; + return @import("std").zig.c_translation.cast(isize, p1) - @import("std").zig.c_translation.cast(isize, p2); +} +pub inline fn SPA_PTR_TO_UINT32(p: anytype) u32 { + _ = &p; + return @import("std").zig.c_translation.cast(u32, @import("std").zig.c_translation.cast(usize, p)); +} +pub inline fn SPA_UINT32_TO_PTR(u: anytype) ?*anyopaque { + _ = &u; + return @import("std").zig.c_translation.cast(?*anyopaque, @import("std").zig.c_translation.cast(usize, u)); +} +pub const SPA_TIME_INVALID = @import("std").zig.c_translation.cast(i64, INT64_MIN); +pub const SPA_IDX_INVALID = @import("std").zig.c_translation.cast(c_uint, -@as(c_int, 1)); +pub const SPA_ID_INVALID = @import("std").zig.c_translation.cast(u32, @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffffffff, .hex)); +pub const SPA_NSEC_PER_SEC = @as(c_longlong, 1000000000); +pub const SPA_NSEC_PER_MSEC = @as(c_longlong, 1000000); +pub const SPA_NSEC_PER_USEC = @as(c_longlong, 1000); +pub const SPA_USEC_PER_SEC = @as(c_longlong, 1000000); +pub const SPA_USEC_PER_MSEC = @as(c_longlong, 1000); +pub const SPA_MSEC_PER_SEC = @as(c_longlong, 1000); +pub inline fn SPA_TIMESPEC_TO_NSEC(ts: anytype) @TypeOf((ts.*.tv_sec * SPA_NSEC_PER_SEC) + ts.*.tv_nsec) { + _ = &ts; + return (ts.*.tv_sec * SPA_NSEC_PER_SEC) + ts.*.tv_nsec; +} +pub inline fn SPA_TIMESPEC_TO_USEC(ts: anytype) @TypeOf((ts.*.tv_sec * SPA_USEC_PER_SEC) + @import("std").zig.c_translation.MacroArithmetic.div(ts.*.tv_nsec, SPA_NSEC_PER_USEC)) { + _ = &ts; + return (ts.*.tv_sec * SPA_USEC_PER_SEC) + @import("std").zig.c_translation.MacroArithmetic.div(ts.*.tv_nsec, SPA_NSEC_PER_USEC); +} +pub inline fn SPA_TIMEVAL_TO_NSEC(tv: anytype) @TypeOf((tv.*.tv_sec * SPA_NSEC_PER_SEC) + (tv.*.tv_usec * SPA_NSEC_PER_USEC)) { + _ = &tv; + return (tv.*.tv_sec * SPA_NSEC_PER_SEC) + (tv.*.tv_usec * SPA_NSEC_PER_USEC); +} +pub inline fn SPA_TIMEVAL_TO_USEC(tv: anytype) @TypeOf((tv.*.tv_sec * SPA_USEC_PER_SEC) + tv.*.tv_usec) { + _ = &tv; + return (tv.*.tv_sec * SPA_USEC_PER_SEC) + tv.*.tv_usec; +} +pub const SPA_PRINTF_FUNC = @compileError("unable to translate macro: undefined identifier `format`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:236:9 +pub const SPA_FORMAT_ARG_FUNC = @compileError("unable to translate macro: undefined identifier `format_arg`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:237:9 +pub const SPA_ALIGNED = @compileError("unable to translate macro: undefined identifier `aligned`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:238:9 +pub const SPA_DEPRECATED = @compileError("unable to translate macro: undefined identifier `deprecated`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:239:9 +pub const SPA_EXPORT = @compileError("unable to translate macro: undefined identifier `visibility`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:240:9 +pub const SPA_SENTINEL = @compileError("unable to translate macro: undefined identifier `__sentinel__`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:241:9 +pub const SPA_UNUSED = @compileError("unable to translate macro: undefined identifier `unused`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:242:9 +pub const SPA_NORETURN = @compileError("unable to translate macro: undefined identifier `noreturn`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:243:9 +pub const SPA_WARN_UNUSED_RESULT = @compileError("unable to translate macro: undefined identifier `warn_unused_result`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:244:9 +pub const SPA_BARRIER = @compileError("unable to translate C expr: unexpected token '__asm__'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:245:9 +pub const SPA_API_PROTO = @compileError("unable to translate C expr: unexpected token 'static'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:260:9 +pub const SPA_API_IMPL = @compileError("unable to translate C expr: unexpected token 'static'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:261:9 +pub const SPA_API_UTILS_DEFS = SPA_API_IMPL; +pub const SPA_RESTRICT = @compileError("unable to translate C expr: unexpected token 'restrict'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:274:9 +pub const SPA_ROUND_DOWN = @compileError("unable to translate macro: undefined identifier `_num`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:281:9 +pub const SPA_ROUND_UP = @compileError("unable to translate macro: undefined identifier `_v`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:286:9 +pub const SPA_ROUND_MASK = @compileError("unable to translate C expr: unexpected token '__typeof__'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:292:9 +pub inline fn SPA_ROUND_DOWN_N(num: anytype, @"align": anytype) @TypeOf(num & ~SPA_ROUND_MASK(num, @"align")) { + _ = # + _ = &@"align"; + return num & ~SPA_ROUND_MASK(num, @"align"); +} +pub inline fn SPA_ROUND_UP_N(num: anytype, @"align": anytype) @TypeOf(((num - @as(c_int, 1)) | SPA_ROUND_MASK(num, @"align")) + @as(c_int, 1)) { + _ = # + _ = &@"align"; + return ((num - @as(c_int, 1)) | SPA_ROUND_MASK(num, @"align")) + @as(c_int, 1); +} +pub const SPA_SCALE32 = @compileError("unable to translate macro: undefined identifier `_val`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:297:9 +pub const SPA_SCALE32_UP = @compileError("unable to translate macro: undefined identifier `_val`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:304:9 +pub inline fn SPA_PTR_ALIGNMENT(p: anytype, @"align": anytype) @TypeOf(@import("std").zig.c_translation.cast(usize, p) & (@"align" - @as(c_int, 1))) { + _ = &p; + _ = &@"align"; + return @import("std").zig.c_translation.cast(usize, p) & (@"align" - @as(c_int, 1)); +} +pub inline fn SPA_IS_ALIGNED(p: anytype, @"align": anytype) @TypeOf(SPA_PTR_ALIGNMENT(p, @"align") == @as(c_int, 0)) { + _ = &p; + _ = &@"align"; + return SPA_PTR_ALIGNMENT(p, @"align") == @as(c_int, 0); +} +pub const SPA_PTR_ALIGN = @compileError("unable to translate C expr: unexpected token ')'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:314:9 +pub inline fn SPA_LIKELY(x: anytype) @TypeOf(__builtin_expect(!!(x != 0), @as(c_int, 1))) { + _ = &x; + return __builtin_expect(!!(x != 0), @as(c_int, 1)); +} +pub inline fn SPA_UNLIKELY(x: anytype) @TypeOf(__builtin_expect(!!(x != 0), @as(c_int, 0))) { + _ = &x; + return __builtin_expect(!!(x != 0), @as(c_int, 0)); +} +pub inline fn spa_ptr_type_inside(p1: anytype, s1: anytype, p2: anytype, @"type": anytype, remaining: anytype) @TypeOf(spa_ptr_inside_and_aligned(p1, s1, p2, @import("std").zig.c_translation.sizeof(@"type"), SPA_ALIGNOF(@"type"), remaining)) { + _ = &p1; + _ = &s1; + _ = &p2; + _ = &@"type"; + _ = &remaining; + return spa_ptr_inside_and_aligned(p1, s1, p2, @import("std").zig.c_translation.sizeof(@"type"), SPA_ALIGNOF(@"type"), remaining); +} +pub inline fn SPA_PTR_TO_INT(p: anytype) c_int { + _ = &p; + return @import("std").zig.c_translation.cast(c_int, @import("std").zig.c_translation.cast(isize, p)); +} +pub inline fn SPA_INT_TO_PTR(u: anytype) ?*anyopaque { + _ = &u; + return @import("std").zig.c_translation.cast(?*anyopaque, @import("std").zig.c_translation.cast(isize, u)); +} +pub const SPA_STRINGIFY_1 = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:360:9 +pub const SPA_STRINGIFY = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:361:9 +pub const spa_return_if_fail = @compileError("unable to translate macro: undefined identifier `__FILE__`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:371:9 +pub const spa_return_val_if_fail = @compileError("unable to translate macro: undefined identifier `__FILE__`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:380:9 +pub const spa_assert_se = @compileError("unable to translate macro: undefined identifier `__FILE__`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:392:9 +pub const spa_nop = @compileError("unable to translate C expr: unexpected token 'do'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:410:9 +pub inline fn spa_assert(expr: anytype) @TypeOf(spa_assert_se(expr)) { + _ = &expr; + return spa_assert_se(expr); +} +pub const spa_assert_not_reached = @compileError("unable to translate macro: undefined identifier `__FILE__`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:423:9 +pub inline fn spa_memzero(x: anytype, l: anytype) @TypeOf(memset(x, @as(c_int, 0), l)) { + _ = &x; + _ = &l; + return memset(x, @as(c_int, 0), l); +} +pub inline fn spa_zero(x: anytype) @TypeOf(spa_memzero(&x, @import("std").zig.c_translation.sizeof(x))) { + _ = &x; + return spa_memzero(&x, @import("std").zig.c_translation.sizeof(x)); +} +pub inline fn spa_memcpy(d: anytype, s: anytype, n: anytype) @TypeOf(memcpy(d, s, n)) { + _ = &d; + _ = &s; + _ = &n; + return memcpy(d, s, n); +} +pub inline fn spa_memmove(d: anytype, s: anytype, n: anytype) @TypeOf(memmove(d, s, n)) { + _ = &d; + _ = &s; + _ = &n; + return memmove(d, s, n); +} +pub const spa_aprintf = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:452:9 +pub const PIPEWIRE_H = ""; +pub const SPA_PLUGIN_H = ""; +pub const _ERRNO_H = @as(c_int, 1); +pub const _BITS_ERRNO_H = @as(c_int, 1); +pub const _ASM_GENERIC_ERRNO_H = ""; +pub const _ASM_GENERIC_ERRNO_BASE_H = ""; +pub const EPERM = @as(c_int, 1); +pub const ENOENT = @as(c_int, 2); +pub const ESRCH = @as(c_int, 3); +pub const EINTR = @as(c_int, 4); +pub const EIO = @as(c_int, 5); +pub const ENXIO = @as(c_int, 6); +pub const E2BIG = @as(c_int, 7); +pub const ENOEXEC = @as(c_int, 8); +pub const EBADF = @as(c_int, 9); +pub const ECHILD = @as(c_int, 10); +pub const EAGAIN = @as(c_int, 11); +pub const ENOMEM = @as(c_int, 12); +pub const EACCES = @as(c_int, 13); +pub const EFAULT = @as(c_int, 14); +pub const ENOTBLK = @as(c_int, 15); +pub const EBUSY = @as(c_int, 16); +pub const EEXIST = @as(c_int, 17); +pub const EXDEV = @as(c_int, 18); +pub const ENODEV = @as(c_int, 19); +pub const ENOTDIR = @as(c_int, 20); +pub const EISDIR = @as(c_int, 21); +pub const EINVAL = @as(c_int, 22); +pub const ENFILE = @as(c_int, 23); +pub const EMFILE = @as(c_int, 24); +pub const ENOTTY = @as(c_int, 25); +pub const ETXTBSY = @as(c_int, 26); +pub const EFBIG = @as(c_int, 27); +pub const ENOSPC = @as(c_int, 28); +pub const ESPIPE = @as(c_int, 29); +pub const EROFS = @as(c_int, 30); +pub const EMLINK = @as(c_int, 31); +pub const EPIPE = @as(c_int, 32); +pub const EDOM = @as(c_int, 33); +pub const ERANGE = @as(c_int, 34); +pub const EDEADLK = @as(c_int, 35); +pub const ENAMETOOLONG = @as(c_int, 36); +pub const ENOLCK = @as(c_int, 37); +pub const ENOSYS = @as(c_int, 38); +pub const ENOTEMPTY = @as(c_int, 39); +pub const ELOOP = @as(c_int, 40); +pub const EWOULDBLOCK = EAGAIN; +pub const ENOMSG = @as(c_int, 42); +pub const EIDRM = @as(c_int, 43); +pub const ECHRNG = @as(c_int, 44); +pub const EL2NSYNC = @as(c_int, 45); +pub const EL3HLT = @as(c_int, 46); +pub const EL3RST = @as(c_int, 47); +pub const ELNRNG = @as(c_int, 48); +pub const EUNATCH = @as(c_int, 49); +pub const ENOCSI = @as(c_int, 50); +pub const EL2HLT = @as(c_int, 51); +pub const EBADE = @as(c_int, 52); +pub const EBADR = @as(c_int, 53); +pub const EXFULL = @as(c_int, 54); +pub const ENOANO = @as(c_int, 55); +pub const EBADRQC = @as(c_int, 56); +pub const EBADSLT = @as(c_int, 57); +pub const EDEADLOCK = EDEADLK; +pub const EBFONT = @as(c_int, 59); +pub const ENOSTR = @as(c_int, 60); +pub const ENODATA = @as(c_int, 61); +pub const ETIME = @as(c_int, 62); +pub const ENOSR = @as(c_int, 63); +pub const ENONET = @as(c_int, 64); +pub const ENOPKG = @as(c_int, 65); +pub const EREMOTE = @as(c_int, 66); +pub const ENOLINK = @as(c_int, 67); +pub const EADV = @as(c_int, 68); +pub const ESRMNT = @as(c_int, 69); +pub const ECOMM = @as(c_int, 70); +pub const EPROTO = @as(c_int, 71); +pub const EMULTIHOP = @as(c_int, 72); +pub const EDOTDOT = @as(c_int, 73); +pub const EBADMSG = @as(c_int, 74); +pub const EOVERFLOW = @as(c_int, 75); +pub const ENOTUNIQ = @as(c_int, 76); +pub const EBADFD = @as(c_int, 77); +pub const EREMCHG = @as(c_int, 78); +pub const ELIBACC = @as(c_int, 79); +pub const ELIBBAD = @as(c_int, 80); +pub const ELIBSCN = @as(c_int, 81); +pub const ELIBMAX = @as(c_int, 82); +pub const ELIBEXEC = @as(c_int, 83); +pub const EILSEQ = @as(c_int, 84); +pub const ERESTART = @as(c_int, 85); +pub const ESTRPIPE = @as(c_int, 86); +pub const EUSERS = @as(c_int, 87); +pub const ENOTSOCK = @as(c_int, 88); +pub const EDESTADDRREQ = @as(c_int, 89); +pub const EMSGSIZE = @as(c_int, 90); +pub const EPROTOTYPE = @as(c_int, 91); +pub const ENOPROTOOPT = @as(c_int, 92); +pub const EPROTONOSUPPORT = @as(c_int, 93); +pub const ESOCKTNOSUPPORT = @as(c_int, 94); +pub const EOPNOTSUPP = @as(c_int, 95); +pub const EPFNOSUPPORT = @as(c_int, 96); +pub const EAFNOSUPPORT = @as(c_int, 97); +pub const EADDRINUSE = @as(c_int, 98); +pub const EADDRNOTAVAIL = @as(c_int, 99); +pub const ENETDOWN = @as(c_int, 100); +pub const ENETUNREACH = @as(c_int, 101); +pub const ENETRESET = @as(c_int, 102); +pub const ECONNABORTED = @as(c_int, 103); +pub const ECONNRESET = @as(c_int, 104); +pub const ENOBUFS = @as(c_int, 105); +pub const EISCONN = @as(c_int, 106); +pub const ENOTCONN = @as(c_int, 107); +pub const ESHUTDOWN = @as(c_int, 108); +pub const ETOOMANYREFS = @as(c_int, 109); +pub const ETIMEDOUT = @as(c_int, 110); +pub const ECONNREFUSED = @as(c_int, 111); +pub const EHOSTDOWN = @as(c_int, 112); +pub const EHOSTUNREACH = @as(c_int, 113); +pub const EALREADY = @as(c_int, 114); +pub const EINPROGRESS = @as(c_int, 115); +pub const ESTALE = @as(c_int, 116); +pub const EUCLEAN = @as(c_int, 117); +pub const ENOTNAM = @as(c_int, 118); +pub const ENAVAIL = @as(c_int, 119); +pub const EISNAM = @as(c_int, 120); +pub const EREMOTEIO = @as(c_int, 121); +pub const EDQUOT = @as(c_int, 122); +pub const ENOMEDIUM = @as(c_int, 123); +pub const EMEDIUMTYPE = @as(c_int, 124); +pub const ECANCELED = @as(c_int, 125); +pub const ENOKEY = @as(c_int, 126); +pub const EKEYEXPIRED = @as(c_int, 127); +pub const EKEYREVOKED = @as(c_int, 128); +pub const EKEYREJECTED = @as(c_int, 129); +pub const EOWNERDEAD = @as(c_int, 130); +pub const ENOTRECOVERABLE = @as(c_int, 131); +pub const ERFKILL = @as(c_int, 132); +pub const EHWPOISON = @as(c_int, 133); +pub const ENOTSUP = EOPNOTSUPP; +pub const errno = __errno_location().*; +pub const SPA_HOOK_H = ""; +pub const SPA_LIST_H = ""; +pub const SPA_API_LIST = SPA_API_IMPL; +pub inline fn SPA_LIST_INIT(list: anytype) struct_spa_list { + _ = &list; + return @import("std").mem.zeroInit(struct_spa_list, .{ list, list }); +} +pub inline fn spa_list_is_empty(l: anytype) @TypeOf(l.*.next == l) { + _ = &l; + return l.*.next == l; +} +pub inline fn spa_list_first(head: anytype, @"type": anytype, member: anytype) @TypeOf(SPA_CONTAINER_OF(head.*.next, @"type", member)) { + _ = &head; + _ = &@"type"; + _ = &member; + return SPA_CONTAINER_OF(head.*.next, @"type", member); +} +pub inline fn spa_list_last(head: anytype, @"type": anytype, member: anytype) @TypeOf(SPA_CONTAINER_OF(head.*.prev, @"type", member)) { + _ = &head; + _ = &@"type"; + _ = &member; + return SPA_CONTAINER_OF(head.*.prev, @"type", member); +} +pub inline fn spa_list_append(list: anytype, item: anytype) @TypeOf(spa_list_insert(list.*.prev, item)) { + _ = &list; + _ = &item; + return spa_list_insert(list.*.prev, item); +} +pub inline fn spa_list_prepend(list: anytype, item: anytype) @TypeOf(spa_list_insert(list, item)) { + _ = &list; + _ = &item; + return spa_list_insert(list, item); +} +pub inline fn spa_list_is_end(pos: anytype, head: anytype, member: anytype) @TypeOf((&pos.*.member) == head) { + _ = &pos; + _ = &head; + _ = &member; + return (&pos.*.member) == head; +} +pub const spa_list_next = @compileError("unable to translate C expr: unexpected token '__typeof__'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/list.h:90:9 +pub const spa_list_prev = @compileError("unable to translate C expr: unexpected token '__typeof__'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/list.h:93:9 +pub const spa_list_consume = @compileError("unable to translate C expr: unexpected token 'for'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/list.h:96:9 +pub const spa_list_for_each_next = @compileError("unable to translate C expr: unexpected token 'for'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/list.h:101:9 +pub const spa_list_for_each_prev = @compileError("unable to translate C expr: unexpected token 'for'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/list.h:106:9 +pub inline fn spa_list_for_each(pos: anytype, head: anytype, member: anytype) @TypeOf(spa_list_for_each_next(pos, head, head, member)) { + _ = &pos; + _ = &head; + _ = &member; + return spa_list_for_each_next(pos, head, head, member); +} +pub inline fn spa_list_for_each_reverse(pos: anytype, head: anytype, member: anytype) @TypeOf(spa_list_for_each_prev(pos, head, head, member)) { + _ = &pos; + _ = &head; + _ = &member; + return spa_list_for_each_prev(pos, head, head, member); +} +pub const spa_list_for_each_safe_next = @compileError("unable to translate C expr: unexpected token 'for'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/list.h:117:9 +pub const spa_list_for_each_safe_prev = @compileError("unable to translate C expr: unexpected token 'for'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/list.h:123:9 +pub inline fn spa_list_for_each_safe(pos: anytype, tmp: anytype, head: anytype, member: anytype) @TypeOf(spa_list_for_each_safe_next(pos, tmp, head, head, member)) { + _ = &pos; + _ = &tmp; + _ = &head; + _ = &member; + return spa_list_for_each_safe_next(pos, tmp, head, head, member); +} +pub inline fn spa_list_for_each_safe_reverse(pos: anytype, tmp: anytype, head: anytype, member: anytype) @TypeOf(spa_list_for_each_safe_prev(pos, tmp, head, head, member)) { + _ = &pos; + _ = &tmp; + _ = &head; + _ = &member; + return spa_list_for_each_safe_prev(pos, tmp, head, head, member); +} +pub inline fn spa_list_cursor_start(cursor: anytype, head: anytype, member: anytype) @TypeOf(spa_list_prepend(head, &cursor.member)) { + _ = &cursor; + _ = &head; + _ = &member; + return spa_list_prepend(head, &cursor.member); +} +pub const spa_list_for_each_cursor = @compileError("unable to translate C expr: unexpected token 'for'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/list.h:138:9 +pub inline fn spa_list_cursor_end(cursor: anytype, member: anytype) @TypeOf(spa_list_remove(&cursor.member)) { + _ = &cursor; + _ = &member; + return spa_list_remove(&cursor.member); +} +pub const SPA_API_HOOK = SPA_API_IMPL; +pub inline fn SPA_CALLBACK_VERSION_MIN(c: anytype, v: anytype) @TypeOf((c != 0) and ((v == @as(c_int, 0)) or (c.*.version > (v - @as(c_int, 1))))) { + _ = &c; + _ = &v; + return (c != 0) and ((v == @as(c_int, 0)) or (c.*.version > (v - @as(c_int, 1)))); +} +pub inline fn SPA_CALLBACK_CHECK(c: anytype, m: anytype, v: anytype) @TypeOf((SPA_CALLBACK_VERSION_MIN(c, v) != 0) and (c.*.m != 0)) { + _ = &c; + _ = &m; + _ = &v; + return (SPA_CALLBACK_VERSION_MIN(c, v) != 0) and (c.*.m != 0); +} +pub const SPA_CALLBACKS_INIT = @compileError("unable to translate C expr: unexpected token '}'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:133:9 +pub const SPA_INTERFACE_INIT = @compileError("unable to translate C expr: unexpected token '}'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:156:9 +pub const spa_callbacks_call = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:164:9 +pub const spa_callbacks_call_fast = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:173:9 +pub const spa_callback_version_min = @compileError("unable to translate macro: undefined identifier `_f`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:184:9 +pub const spa_callback_check = @compileError("unable to translate macro: undefined identifier `_f`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:194:9 +pub const spa_callbacks_call_res = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:206:9 +pub const spa_callbacks_call_fast_res = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:213:9 +pub inline fn spa_interface_callback_version_min(iface: anytype, method_type: anytype, vers: anytype) @TypeOf(spa_callback_version_min(&iface.*.cb, method_type, vers)) { + _ = &iface; + _ = &method_type; + _ = &vers; + return spa_callback_version_min(&iface.*.cb, method_type, vers); +} +pub inline fn spa_interface_callback_check(iface: anytype, method_type: anytype, method: anytype, vers: anytype) @TypeOf(spa_callback_check(&iface.*.cb, method_type, method, vers)) { + _ = &iface; + _ = &method_type; + _ = &method; + _ = &vers; + return spa_callback_check(&iface.*.cb, method_type, method, vers); +} +pub const spa_interface_call = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:237:9 +pub const spa_interface_call_fast = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:240:9 +pub const spa_interface_call_res = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:250:9 +pub const spa_interface_call_fast_res = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:253:9 +pub const spa_api_func_v = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:257:9 +pub const spa_api_func_r = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:262:9 +pub const spa_api_func_fast = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:269:9 +pub const spa_api_method_v = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:274:9 +pub const spa_api_method_r = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:280:9 +pub const spa_api_method_null_v = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:288:9 +pub const spa_api_method_null_r = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:297:9 +pub const spa_api_method_fast_v = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:308:9 +pub const spa_api_method_fast_r = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:314:9 +pub const spa_hook_list_call_simple = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:494:9 +pub const spa_hook_list_do_call = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:505:9 +pub const spa_hook_list_call = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:527:9 +pub const spa_hook_list_call_once = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:533:9 +pub const spa_hook_list_call_start = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:535:9 +pub const spa_hook_list_call_once_start = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/hook.h:536:9 +pub const SPA_DICT_H = ""; +pub const SPA_API_DICT = SPA_API_IMPL; +pub inline fn SPA_DICT_ITEM(key: anytype, value: anytype) struct_spa_dict_item { + _ = &key; + _ = &value; + return @import("std").mem.zeroInit(struct_spa_dict_item, .{ key, value }); +} +pub inline fn SPA_DICT_ITEM_INIT(key: anytype, value: anytype) @TypeOf(SPA_DICT_ITEM(key, value)) { + _ = &key; + _ = &value; + return SPA_DICT_ITEM(key, value); +} +pub const SPA_DICT_FLAG_SORTED = @as(c_int, 1) << @as(c_int, 0); +pub inline fn SPA_DICT(items: anytype, n_items: anytype) struct_spa_dict { + _ = &items; + _ = &n_items; + return @import("std").mem.zeroInit(struct_spa_dict, .{ @as(c_int, 0), n_items, items }); +} +pub inline fn SPA_DICT_ARRAY(items: anytype) @TypeOf(SPA_DICT(items, SPA_N_ELEMENTS(items))) { + _ = &items; + return SPA_DICT(items, SPA_N_ELEMENTS(items)); +} +pub const SPA_DICT_ITEMS = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/dict.h:51:9 +pub inline fn SPA_DICT_INIT(items: anytype, n_items: anytype) @TypeOf(SPA_DICT(items, n_items)) { + _ = &items; + _ = &n_items; + return SPA_DICT(items, n_items); +} +pub inline fn SPA_DICT_INIT_ARRAY(items: anytype) @TypeOf(SPA_DICT_ARRAY(items)) { + _ = &items; + return SPA_DICT_ARRAY(items); +} +pub const spa_dict_for_each = @compileError("unable to translate C expr: unexpected token 'for'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/dict.h:56:9 +pub const SPA_API_PLUGIN = SPA_API_IMPL; +pub const SPA_VERSION_HANDLE = @as(c_int, 0); +pub inline fn SPA_SUPPORT_INIT(@"type": anytype, data: anytype) struct_spa_support { + _ = &@"type"; + _ = &data; + return @import("std").mem.zeroInit(struct_spa_support, .{ @"type", data }); +} +pub const SPA_VERSION_HANDLE_FACTORY = @as(c_int, 1); +pub const SPA_HANDLE_FACTORY_ENUM_FUNC_NAME = "spa_handle_factory_enum"; +pub const SPA_KEY_FACTORY_NAME = "factory.name"; +pub const SPA_KEY_FACTORY_AUTHOR = "factory.author"; +pub const SPA_KEY_FACTORY_DESCRIPTION = "factory.description"; +pub const SPA_KEY_FACTORY_USAGE = "factory.usage"; +pub const SPA_KEY_LIBRARY_NAME = "library.name"; +pub const PIPEWIRE_ARRAY_H = ""; +pub const PW_API_ARRAY = @compileError("unable to translate C expr: unexpected token 'static'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/array.h:17:9 +pub inline fn PW_ARRAY_INIT(extend: anytype) struct_pw_array { + _ = &extend; + return @import("std").mem.zeroInit(struct_pw_array, .{ NULL, @as(c_int, 0), @as(c_int, 0), extend }); +} +pub inline fn pw_array_get_len_s(a: anytype, s: anytype) @TypeOf(@import("std").zig.c_translation.MacroArithmetic.div(a.*.size, s)) { + _ = &a; + _ = &s; + return @import("std").zig.c_translation.MacroArithmetic.div(a.*.size, s); +} +pub inline fn pw_array_get_unchecked_s(a: anytype, idx: anytype, s: anytype, t: anytype) @TypeOf(SPA_PTROFF(a.*.data, idx * s, t)) { + _ = &a; + _ = &idx; + _ = &s; + _ = &t; + return SPA_PTROFF(a.*.data, idx * s, t); +} +pub inline fn pw_array_check_index_s(a: anytype, idx: anytype, s: anytype) @TypeOf(idx < pw_array_get_len_s(a, s)) { + _ = &a; + _ = &idx; + _ = &s; + return idx < pw_array_get_len_s(a, s); +} +pub inline fn pw_array_get_len(a: anytype, t: anytype) @TypeOf(pw_array_get_len_s(a, @import("std").zig.c_translation.sizeof(t))) { + _ = &a; + _ = &t; + return pw_array_get_len_s(a, @import("std").zig.c_translation.sizeof(t)); +} +pub inline fn pw_array_get_unchecked(a: anytype, idx: anytype, t: anytype) @TypeOf(pw_array_get_unchecked_s(a, idx, @import("std").zig.c_translation.sizeof(t), t)) { + _ = &a; + _ = &idx; + _ = &t; + return pw_array_get_unchecked_s(a, idx, @import("std").zig.c_translation.sizeof(t), t); +} +pub inline fn pw_array_check_index(a: anytype, idx: anytype, t: anytype) @TypeOf(pw_array_check_index_s(a, idx, @import("std").zig.c_translation.sizeof(t))) { + _ = &a; + _ = &idx; + _ = &t; + return pw_array_check_index_s(a, idx, @import("std").zig.c_translation.sizeof(t)); +} +pub inline fn pw_array_first(a: anytype) @TypeOf(a.*.data) { + _ = &a; + return a.*.data; +} +pub inline fn pw_array_end(a: anytype) @TypeOf(SPA_PTROFF(a.*.data, a.*.size, anyopaque)) { + _ = &a; + return SPA_PTROFF(a.*.data, a.*.size, anyopaque); +} +pub const pw_array_check = @compileError("unable to translate C expr: unexpected token '*'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/array.h:58:9 +pub const pw_array_for_each = @compileError("unable to translate C expr: unexpected token 'for'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/array.h:60:9 +pub const pw_array_consume = @compileError("unable to translate C expr: unexpected token 'for'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/array.h:65:9 +pub const pw_array_remove = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/array.h:70:9 +pub const PIPEWIRE_CLIENT_H = ""; +pub const SPA_PARAM_H = ""; +pub const SPA_PARAM_INFO_SERIAL = @as(c_int, 1) << @as(c_int, 0); +pub const SPA_PARAM_INFO_READ = @as(c_int, 1) << @as(c_int, 1); +pub const SPA_PARAM_INFO_WRITE = @as(c_int, 1) << @as(c_int, 2); +pub const SPA_PARAM_INFO_READWRITE = SPA_PARAM_INFO_WRITE | SPA_PARAM_INFO_READ; +pub inline fn SPA_PARAM_INFO(id: anytype, flags: anytype) struct_spa_param_info { + _ = &id; + _ = &flags; + return @import("std").mem.zeroInit(struct_spa_param_info, .{ id, flags }); +} +pub const SPA_PARAM_BUFFERS_H = ""; +pub const SPA_PARAM_PROFILE_H = ""; +pub const SPA_PARAM_PORT_CONFIG_H = ""; +pub const SPA_PARAM_ROUTE_H = ""; +pub const PIPEWIRE_TYPE_H = ""; +pub const SPA_TYPE_H = ""; +pub const SPA_UTILS_STRING_H = ""; +pub const __need_va_list = ""; +pub const __need_va_arg = ""; +pub const __need___va_copy = ""; +pub const __need_va_copy = ""; +pub const __STDARG_H = ""; +pub const _VA_LIST = ""; +pub const va_start = @compileError("unable to translate macro: undefined identifier `__builtin_va_start`"); +// /home/mason/.cache/zig/p/N-V-__8AAN5NhBR0oTsvnwjPdeNiiDLtEsfXRHd1fv-R3TOv/lib/include/__stdarg_va_arg.h:17:9 +pub const va_end = @compileError("unable to translate macro: undefined identifier `__builtin_va_end`"); +// /home/mason/.cache/zig/p/N-V-__8AAN5NhBR0oTsvnwjPdeNiiDLtEsfXRHd1fv-R3TOv/lib/include/__stdarg_va_arg.h:19:9 +pub const va_arg = @compileError("unable to translate C expr: unexpected token 'an identifier'"); +// /home/mason/.cache/zig/p/N-V-__8AAN5NhBR0oTsvnwjPdeNiiDLtEsfXRHd1fv-R3TOv/lib/include/__stdarg_va_arg.h:20:9 +pub const __va_copy = @compileError("unable to translate macro: undefined identifier `__builtin_va_copy`"); +// /home/mason/.cache/zig/p/N-V-__8AAN5NhBR0oTsvnwjPdeNiiDLtEsfXRHd1fv-R3TOv/lib/include/__stdarg___va_copy.h:11:9 +pub const va_copy = @compileError("unable to translate macro: undefined identifier `__builtin_va_copy`"); +// /home/mason/.cache/zig/p/N-V-__8AAN5NhBR0oTsvnwjPdeNiiDLtEsfXRHd1fv-R3TOv/lib/include/__stdarg_va_copy.h:11:9 +pub const _LOCALE_H = @as(c_int, 1); +pub const _BITS_LOCALE_H = @as(c_int, 1); +pub const __LC_CTYPE = @as(c_int, 0); +pub const __LC_NUMERIC = @as(c_int, 1); +pub const __LC_TIME = @as(c_int, 2); +pub const __LC_COLLATE = @as(c_int, 3); +pub const __LC_MONETARY = @as(c_int, 4); +pub const __LC_MESSAGES = @as(c_int, 5); +pub const __LC_ALL = @as(c_int, 6); +pub const __LC_PAPER = @as(c_int, 7); +pub const __LC_NAME = @as(c_int, 8); +pub const __LC_ADDRESS = @as(c_int, 9); +pub const __LC_TELEPHONE = @as(c_int, 10); +pub const __LC_MEASUREMENT = @as(c_int, 11); +pub const __LC_IDENTIFICATION = @as(c_int, 12); +pub const LC_CTYPE = __LC_CTYPE; +pub const LC_NUMERIC = __LC_NUMERIC; +pub const LC_TIME = __LC_TIME; +pub const LC_COLLATE = __LC_COLLATE; +pub const LC_MONETARY = __LC_MONETARY; +pub const LC_MESSAGES = __LC_MESSAGES; +pub const LC_ALL = __LC_ALL; +pub const LC_PAPER = __LC_PAPER; +pub const LC_NAME = __LC_NAME; +pub const LC_ADDRESS = __LC_ADDRESS; +pub const LC_TELEPHONE = __LC_TELEPHONE; +pub const LC_MEASUREMENT = __LC_MEASUREMENT; +pub const LC_IDENTIFICATION = __LC_IDENTIFICATION; +pub const LC_CTYPE_MASK = @as(c_int, 1) << __LC_CTYPE; +pub const LC_NUMERIC_MASK = @as(c_int, 1) << __LC_NUMERIC; +pub const LC_TIME_MASK = @as(c_int, 1) << __LC_TIME; +pub const LC_COLLATE_MASK = @as(c_int, 1) << __LC_COLLATE; +pub const LC_MONETARY_MASK = @as(c_int, 1) << __LC_MONETARY; +pub const LC_MESSAGES_MASK = @as(c_int, 1) << __LC_MESSAGES; +pub const LC_PAPER_MASK = @as(c_int, 1) << __LC_PAPER; +pub const LC_NAME_MASK = @as(c_int, 1) << __LC_NAME; +pub const LC_ADDRESS_MASK = @as(c_int, 1) << __LC_ADDRESS; +pub const LC_TELEPHONE_MASK = @as(c_int, 1) << __LC_TELEPHONE; +pub const LC_MEASUREMENT_MASK = @as(c_int, 1) << __LC_MEASUREMENT; +pub const LC_IDENTIFICATION_MASK = @as(c_int, 1) << __LC_IDENTIFICATION; +pub const LC_ALL_MASK = ((((((((((LC_CTYPE_MASK | LC_NUMERIC_MASK) | LC_TIME_MASK) | LC_COLLATE_MASK) | LC_MONETARY_MASK) | LC_MESSAGES_MASK) | LC_PAPER_MASK) | LC_NAME_MASK) | LC_ADDRESS_MASK) | LC_TELEPHONE_MASK) | LC_MEASUREMENT_MASK) | LC_IDENTIFICATION_MASK; +pub const LC_GLOBAL_LOCALE = @import("std").zig.c_translation.cast(locale_t, -@as(c_long, 1)); +pub const SPA_API_STRING = SPA_API_IMPL; +pub const SPA_API_TYPE = SPA_API_IMPL; +pub const SPA_TYPE_INFO_BASE = "Spa:"; +pub const SPA_TYPE_INFO_Flags = SPA_TYPE_INFO_BASE ++ "Flags"; +pub const SPA_TYPE_INFO_FLAGS_BASE = SPA_TYPE_INFO_Flags ++ ":"; +pub const SPA_TYPE_INFO_Enum = SPA_TYPE_INFO_BASE ++ "Enum"; +pub const SPA_TYPE_INFO_ENUM_BASE = SPA_TYPE_INFO_Enum ++ ":"; +pub const SPA_TYPE_INFO_Pod = SPA_TYPE_INFO_BASE ++ "Pod"; +pub const SPA_TYPE_INFO_POD_BASE = SPA_TYPE_INFO_Pod ++ ":"; +pub const SPA_TYPE_INFO_Struct = SPA_TYPE_INFO_POD_BASE ++ "Struct"; +pub const SPA_TYPE_INFO_STRUCT_BASE = SPA_TYPE_INFO_Struct ++ ":"; +pub const SPA_TYPE_INFO_Object = SPA_TYPE_INFO_POD_BASE ++ "Object"; +pub const SPA_TYPE_INFO_OBJECT_BASE = SPA_TYPE_INFO_Object ++ ":"; +pub const SPA_TYPE_INFO_Pointer = SPA_TYPE_INFO_BASE ++ "Pointer"; +pub const SPA_TYPE_INFO_POINTER_BASE = SPA_TYPE_INFO_Pointer ++ ":"; +pub const SPA_TYPE_INFO_Interface = SPA_TYPE_INFO_POINTER_BASE ++ "Interface"; +pub const SPA_TYPE_INFO_INTERFACE_BASE = SPA_TYPE_INFO_Interface ++ ":"; +pub const SPA_TYPE_INFO_Event = SPA_TYPE_INFO_OBJECT_BASE ++ "Event"; +pub const SPA_TYPE_INFO_EVENT_BASE = SPA_TYPE_INFO_Event ++ ":"; +pub const SPA_TYPE_INFO_Command = SPA_TYPE_INFO_OBJECT_BASE ++ "Command"; +pub const SPA_TYPE_INFO_COMMAND_BASE = SPA_TYPE_INFO_Command ++ ":"; +pub const PW_TYPE_INFO_BASE = "PipeWire:"; +pub const PW_TYPE_INFO_Object = PW_TYPE_INFO_BASE ++ "Object"; +pub const PW_TYPE_INFO_OBJECT_BASE = PW_TYPE_INFO_Object ++ ":"; +pub const PW_TYPE_INFO_Interface = PW_TYPE_INFO_BASE ++ "Interface"; +pub const PW_TYPE_INFO_INTERFACE_BASE = PW_TYPE_INFO_Interface ++ ":"; +pub const PIPEWIRE_PROXY_H = ""; +pub const PIPEWIRE_PROTOCOL_H = ""; +pub const PIPEWIRE_CONTEXT_H = ""; +pub const PIPEWIRE_CORE_H = ""; +pub const PW_TYPE_INTERFACE_Core = PW_TYPE_INFO_INTERFACE_BASE ++ "Core"; +pub const PW_TYPE_INTERFACE_Registry = PW_TYPE_INFO_INTERFACE_BASE ++ "Registry"; +pub const PW_CORE_PERM_MASK = (PW_PERM_R | PW_PERM_X) | PW_PERM_M; +pub const PW_VERSION_CORE = @as(c_int, 4); +pub const PW_VERSION_REGISTRY = @as(c_int, 3); +pub const PW_API_CORE_IMPL = @compileError("unable to translate C expr: unexpected token 'static'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/core.h:47:9 +pub const PW_API_REGISTRY_IMPL = @compileError("unable to translate C expr: unexpected token 'static'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/core.h:50:9 +pub const PW_DEFAULT_REMOTE = "pipewire-0"; +pub const PW_ID_CORE = @as(c_int, 0); +pub const PW_ID_ANY = @import("std").zig.c_translation.cast(u32, @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffffffff, .hex)); +pub const PW_CORE_CHANGE_MASK_PROPS = @as(c_int, 1) << @as(c_int, 0); +pub const PW_CORE_CHANGE_MASK_ALL = (@as(c_int, 1) << @as(c_int, 1)) - @as(c_int, 1); +pub const PIPEWIRE_PROPERTIES_H = ""; +pub const SPA_UTILS_CLEANUP_H = ""; +pub const spa_exchange = @compileError("unable to translate macro: undefined identifier `_ptr_`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/cleanup.h:8:9 +pub const spa_steal_ptr = @compileError("unable to translate C expr: unexpected token '__typeof__'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/cleanup.h:19:9 +pub const spa_clear_ptr = @compileError("unable to translate macro: undefined identifier `_old_value`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/cleanup.h:24:9 +pub const _UNISTD_H = @as(c_int, 1); +pub const _POSIX_VERSION = @as(c_long, 200809); +pub const __POSIX2_THIS_VERSION = @as(c_long, 200809); +pub const _POSIX2_VERSION = __POSIX2_THIS_VERSION; +pub const _POSIX2_C_VERSION = __POSIX2_THIS_VERSION; +pub const _POSIX2_C_BIND = __POSIX2_THIS_VERSION; +pub const _POSIX2_C_DEV = __POSIX2_THIS_VERSION; +pub const _POSIX2_SW_DEV = __POSIX2_THIS_VERSION; +pub const _POSIX2_LOCALEDEF = __POSIX2_THIS_VERSION; +pub const _XOPEN_VERSION = @as(c_int, 700); +pub const _XOPEN_XCU_VERSION = @as(c_int, 4); +pub const _XOPEN_XPG2 = @as(c_int, 1); +pub const _XOPEN_XPG3 = @as(c_int, 1); +pub const _XOPEN_XPG4 = @as(c_int, 1); +pub const _XOPEN_UNIX = @as(c_int, 1); +pub const _XOPEN_ENH_I18N = @as(c_int, 1); +pub const _XOPEN_LEGACY = @as(c_int, 1); +pub const _BITS_POSIX_OPT_H = @as(c_int, 1); +pub const _POSIX_JOB_CONTROL = @as(c_int, 1); +pub const _POSIX_SAVED_IDS = @as(c_int, 1); +pub const _POSIX_PRIORITY_SCHEDULING = @as(c_long, 200809); +pub const _POSIX_SYNCHRONIZED_IO = @as(c_long, 200809); +pub const _POSIX_FSYNC = @as(c_long, 200809); +pub const _POSIX_MAPPED_FILES = @as(c_long, 200809); +pub const _POSIX_MEMLOCK = @as(c_long, 200809); +pub const _POSIX_MEMLOCK_RANGE = @as(c_long, 200809); +pub const _POSIX_MEMORY_PROTECTION = @as(c_long, 200809); +pub const _POSIX_CHOWN_RESTRICTED = @as(c_int, 0); +pub const _POSIX_VDISABLE = '\x00'; +pub const _POSIX_NO_TRUNC = @as(c_int, 1); +pub const _XOPEN_REALTIME = @as(c_int, 1); +pub const _XOPEN_REALTIME_THREADS = @as(c_int, 1); +pub const _XOPEN_SHM = @as(c_int, 1); +pub const _POSIX_THREADS = @as(c_long, 200809); +pub const _POSIX_REENTRANT_FUNCTIONS = @as(c_int, 1); +pub const _POSIX_THREAD_SAFE_FUNCTIONS = @as(c_long, 200809); +pub const _POSIX_THREAD_PRIORITY_SCHEDULING = @as(c_long, 200809); +pub const _POSIX_THREAD_ATTR_STACKSIZE = @as(c_long, 200809); +pub const _POSIX_THREAD_ATTR_STACKADDR = @as(c_long, 200809); +pub const _POSIX_THREAD_PRIO_INHERIT = @as(c_long, 200809); +pub const _POSIX_THREAD_PRIO_PROTECT = @as(c_long, 200809); +pub const _POSIX_THREAD_ROBUST_PRIO_INHERIT = @as(c_long, 200809); +pub const _POSIX_THREAD_ROBUST_PRIO_PROTECT = -@as(c_int, 1); +pub const _POSIX_SEMAPHORES = @as(c_long, 200809); +pub const _POSIX_REALTIME_SIGNALS = @as(c_long, 200809); +pub const _POSIX_ASYNCHRONOUS_IO = @as(c_long, 200809); +pub const _POSIX_ASYNC_IO = @as(c_int, 1); +pub const _LFS_ASYNCHRONOUS_IO = @as(c_int, 1); +pub const _POSIX_PRIORITIZED_IO = @as(c_long, 200809); +pub const _LFS64_ASYNCHRONOUS_IO = @as(c_int, 1); +pub const _LFS_LARGEFILE = @as(c_int, 1); +pub const _LFS64_LARGEFILE = @as(c_int, 1); +pub const _LFS64_STDIO = @as(c_int, 1); +pub const _POSIX_SHARED_MEMORY_OBJECTS = @as(c_long, 200809); +pub const _POSIX_CPUTIME = @as(c_int, 0); +pub const _POSIX_THREAD_CPUTIME = @as(c_int, 0); +pub const _POSIX_REGEXP = @as(c_int, 1); +pub const _POSIX_READER_WRITER_LOCKS = @as(c_long, 200809); +pub const _POSIX_SHELL = @as(c_int, 1); +pub const _POSIX_TIMEOUTS = @as(c_long, 200809); +pub const _POSIX_SPIN_LOCKS = @as(c_long, 200809); +pub const _POSIX_SPAWN = @as(c_long, 200809); +pub const _POSIX_TIMERS = @as(c_long, 200809); +pub const _POSIX_BARRIERS = @as(c_long, 200809); +pub const _POSIX_MESSAGE_PASSING = @as(c_long, 200809); +pub const _POSIX_THREAD_PROCESS_SHARED = @as(c_long, 200809); +pub const _POSIX_MONOTONIC_CLOCK = @as(c_int, 0); +pub const _POSIX_CLOCK_SELECTION = @as(c_long, 200809); +pub const _POSIX_ADVISORY_INFO = @as(c_long, 200809); +pub const _POSIX_IPV6 = @as(c_long, 200809); +pub const _POSIX_RAW_SOCKETS = @as(c_long, 200809); +pub const _POSIX2_CHAR_TERM = @as(c_long, 200809); +pub const _POSIX_SPORADIC_SERVER = -@as(c_int, 1); +pub const _POSIX_THREAD_SPORADIC_SERVER = -@as(c_int, 1); +pub const _POSIX_TRACE = -@as(c_int, 1); +pub const _POSIX_TRACE_EVENT_FILTER = -@as(c_int, 1); +pub const _POSIX_TRACE_INHERIT = -@as(c_int, 1); +pub const _POSIX_TRACE_LOG = -@as(c_int, 1); +pub const _POSIX_TYPED_MEMORY_OBJECTS = -@as(c_int, 1); +pub const _POSIX_V7_LPBIG_OFFBIG = -@as(c_int, 1); +pub const _POSIX_V6_LPBIG_OFFBIG = -@as(c_int, 1); +pub const _XBS5_LPBIG_OFFBIG = -@as(c_int, 1); +pub const _POSIX_V7_LP64_OFF64 = @as(c_int, 1); +pub const _POSIX_V6_LP64_OFF64 = @as(c_int, 1); +pub const _XBS5_LP64_OFF64 = @as(c_int, 1); +pub const __ILP32_OFF32_CFLAGS = "-m32"; +pub const __ILP32_OFF32_LDFLAGS = "-m32"; +pub const __ILP32_OFFBIG_CFLAGS = "-m32 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64"; +pub const __ILP32_OFFBIG_LDFLAGS = "-m32"; +pub const __LP64_OFF64_CFLAGS = "-m64"; +pub const __LP64_OFF64_LDFLAGS = "-m64"; +pub const STDIN_FILENO = @as(c_int, 0); +pub const STDOUT_FILENO = @as(c_int, 1); +pub const STDERR_FILENO = @as(c_int, 2); +pub const __useconds_t_defined = ""; +pub const __socklen_t_defined = ""; +pub const R_OK = @as(c_int, 4); +pub const W_OK = @as(c_int, 2); +pub const X_OK = @as(c_int, 1); +pub const F_OK = @as(c_int, 0); +pub const L_SET = SEEK_SET; +pub const L_INCR = SEEK_CUR; +pub const L_XTND = SEEK_END; +pub const _SC_PAGE_SIZE = _SC_PAGESIZE; +pub const _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS = _CS_V6_WIDTH_RESTRICTED_ENVS; +pub const _CS_POSIX_V5_WIDTH_RESTRICTED_ENVS = _CS_V5_WIDTH_RESTRICTED_ENVS; +pub const _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS = _CS_V7_WIDTH_RESTRICTED_ENVS; +pub const _GETOPT_POSIX_H = @as(c_int, 1); +pub const _GETOPT_CORE_H = @as(c_int, 1); +pub const F_ULOCK = @as(c_int, 0); +pub const F_LOCK = @as(c_int, 1); +pub const F_TLOCK = @as(c_int, 2); +pub const F_TEST = @as(c_int, 3); +pub inline fn spa_steal_fd(fd: anytype) @TypeOf(spa_exchange(fd, -@as(c_int, 1))) { + _ = &fd; + return spa_exchange(fd, -@as(c_int, 1)); +} +pub const spa_clear_fd = @compileError("unable to translate macro: undefined identifier `_old_value`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/cleanup.h:39:9 +pub const spa_cleanup = @compileError("unable to translate macro: undefined identifier `__cleanup__`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/cleanup.h:51:9 +pub const SPA_DEFINE_AUTO_CLEANUP = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/cleanup.h:53:9 +pub const spa_auto = @compileError("unable to translate macro: undefined identifier `_spa_auto_cleanup_func_`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/cleanup.h:62:9 +pub const SPA_DEFINE_AUTOPTR_CLEANUP = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/cleanup.h:66:9 +pub const spa_autoptr = @compileError("unable to translate macro: undefined identifier `_spa_autoptr_cleanup_func_`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/cleanup.h:75:9 +pub const spa_autofree = spa_cleanup(_spa_autofree_cleanup_func); +pub const spa_autoclose = spa_cleanup(_spa_autoclose_cleanup_func); +pub const _DIRENT_H = @as(c_int, 1); +pub const d_fileno = @compileError("unable to translate macro: undefined identifier `d_ino`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/dirent.h:47:9 +pub const _DIRENT_HAVE_D_RECLEN = ""; +pub const _DIRENT_HAVE_D_OFF = ""; +pub const _DIRENT_HAVE_D_TYPE = ""; +pub const _DIRENT_MATCHES_DIRENT64 = @as(c_int, 1); +pub inline fn _D_EXACT_NAMLEN(d: anytype) @TypeOf(strlen(d.*.d_name)) { + _ = &d; + return strlen(d.*.d_name); +} +pub inline fn _D_ALLOC_NAMLEN(d: anytype) @TypeOf((@import("std").zig.c_translation.cast([*c]u8, d) + d.*.d_reclen) - (&d.*.d_name[@as(usize, @intCast(@as(c_int, 0)))])) { + _ = &d; + return (@import("std").zig.c_translation.cast([*c]u8, d) + d.*.d_reclen) - (&d.*.d_name[@as(usize, @intCast(@as(c_int, 0)))]); +} +pub inline fn IFTODT(mode: anytype) @TypeOf((mode & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o170000, .octal)) >> @as(c_int, 12)) { + _ = &mode; + return (mode & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o170000, .octal)) >> @as(c_int, 12); +} +pub inline fn DTTOIF(dirtype: anytype) @TypeOf(dirtype << @as(c_int, 12)) { + _ = &dirtype; + return dirtype << @as(c_int, 12); +} +pub const _BITS_POSIX1_LIM_H = @as(c_int, 1); +pub const _POSIX_AIO_LISTIO_MAX = @as(c_int, 2); +pub const _POSIX_AIO_MAX = @as(c_int, 1); +pub const _POSIX_ARG_MAX = @as(c_int, 4096); +pub const _POSIX_CHILD_MAX = @as(c_int, 25); +pub const _POSIX_DELAYTIMER_MAX = @as(c_int, 32); +pub const _POSIX_HOST_NAME_MAX = @as(c_int, 255); +pub const _POSIX_LINK_MAX = @as(c_int, 8); +pub const _POSIX_LOGIN_NAME_MAX = @as(c_int, 9); +pub const _POSIX_MAX_CANON = @as(c_int, 255); +pub const _POSIX_MAX_INPUT = @as(c_int, 255); +pub const _POSIX_MQ_OPEN_MAX = @as(c_int, 8); +pub const _POSIX_MQ_PRIO_MAX = @as(c_int, 32); +pub const _POSIX_NAME_MAX = @as(c_int, 14); +pub const _POSIX_NGROUPS_MAX = @as(c_int, 8); +pub const _POSIX_OPEN_MAX = @as(c_int, 20); +pub const _POSIX_PATH_MAX = @as(c_int, 256); +pub const _POSIX_PIPE_BUF = @as(c_int, 512); +pub const _POSIX_RE_DUP_MAX = @as(c_int, 255); +pub const _POSIX_RTSIG_MAX = @as(c_int, 8); +pub const _POSIX_SEM_NSEMS_MAX = @as(c_int, 256); +pub const _POSIX_SEM_VALUE_MAX = @as(c_int, 32767); +pub const _POSIX_SIGQUEUE_MAX = @as(c_int, 32); +pub const _POSIX_SSIZE_MAX = @as(c_int, 32767); +pub const _POSIX_STREAM_MAX = @as(c_int, 8); +pub const _POSIX_SYMLINK_MAX = @as(c_int, 255); +pub const _POSIX_SYMLOOP_MAX = @as(c_int, 8); +pub const _POSIX_TIMER_MAX = @as(c_int, 32); +pub const _POSIX_TTY_NAME_MAX = @as(c_int, 9); +pub const _POSIX_TZNAME_MAX = @as(c_int, 6); +pub const _POSIX_CLOCKRES_MIN = @import("std").zig.c_translation.promoteIntLiteral(c_int, 20000000, .decimal); +pub const __undef_NR_OPEN = ""; +pub const __undef_LINK_MAX = ""; +pub const __undef_OPEN_MAX = ""; +pub const __undef_ARG_MAX = ""; +pub const _LINUX_LIMITS_H = ""; +pub const NR_OPEN = @as(c_int, 1024); +pub const NGROUPS_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65536, .decimal); +pub const ARG_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 131072, .decimal); +pub const LINK_MAX = @as(c_int, 127); +pub const MAX_CANON = @as(c_int, 255); +pub const MAX_INPUT = @as(c_int, 255); +pub const NAME_MAX = @as(c_int, 255); +pub const PATH_MAX = @as(c_int, 4096); +pub const PIPE_BUF = @as(c_int, 4096); +pub const XATTR_NAME_MAX = @as(c_int, 255); +pub const XATTR_SIZE_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65536, .decimal); +pub const XATTR_LIST_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65536, .decimal); +pub const RTSIG_MAX = @as(c_int, 32); +pub const _POSIX_THREAD_KEYS_MAX = @as(c_int, 128); +pub const PTHREAD_KEYS_MAX = @as(c_int, 1024); +pub const _POSIX_THREAD_DESTRUCTOR_ITERATIONS = @as(c_int, 4); +pub const PTHREAD_DESTRUCTOR_ITERATIONS = _POSIX_THREAD_DESTRUCTOR_ITERATIONS; +pub const _POSIX_THREAD_THREADS_MAX = @as(c_int, 64); +pub const AIO_PRIO_DELTA_MAX = @as(c_int, 20); +pub const PTHREAD_STACK_MIN = @as(c_int, 16384); +pub const DELAYTIMER_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const TTY_NAME_MAX = @as(c_int, 32); +pub const LOGIN_NAME_MAX = @as(c_int, 256); +pub const HOST_NAME_MAX = @as(c_int, 64); +pub const MQ_PRIO_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 32768, .decimal); +pub const SEM_VALUE_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const SSIZE_MAX = @compileError("unable to translate macro: undefined identifier `LONG_MAX`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/posix1_lim.h:169:11 +pub const MAXNAMLEN = NAME_MAX; +pub const PW_API_PROPERTIES = @compileError("unable to translate C expr: unexpected token 'static'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/properties.h:19:9 +pub const PW_PROPERTIES_FLAG_NL = @as(c_int, 1) << @as(c_int, 0); +pub const PW_PROPERTIES_FLAG_RECURSE = @as(c_int, 1) << @as(c_int, 1); +pub const PW_PROPERTIES_FLAG_ENCLOSE = @as(c_int, 1) << @as(c_int, 2); +pub const PW_PROPERTIES_FLAG_ARRAY = @as(c_int, 1) << @as(c_int, 3); +pub const PW_PROPERTIES_FLAG_COLORS = @as(c_int, 1) << @as(c_int, 4); +pub const PW_CORE_EVENT_INFO = @as(c_int, 0); +pub const PW_CORE_EVENT_DONE = @as(c_int, 1); +pub const PW_CORE_EVENT_PING = @as(c_int, 2); +pub const PW_CORE_EVENT_ERROR = @as(c_int, 3); +pub const PW_CORE_EVENT_REMOVE_ID = @as(c_int, 4); +pub const PW_CORE_EVENT_BOUND_ID = @as(c_int, 5); +pub const PW_CORE_EVENT_ADD_MEM = @as(c_int, 6); +pub const PW_CORE_EVENT_REMOVE_MEM = @as(c_int, 7); +pub const PW_CORE_EVENT_BOUND_PROPS = @as(c_int, 8); +pub const PW_CORE_EVENT_NUM = @as(c_int, 9); +pub const PW_VERSION_CORE_EVENTS = @as(c_int, 1); +pub const PW_CORE_METHOD_ADD_LISTENER = @as(c_int, 0); +pub const PW_CORE_METHOD_HELLO = @as(c_int, 1); +pub const PW_CORE_METHOD_SYNC = @as(c_int, 2); +pub const PW_CORE_METHOD_PONG = @as(c_int, 3); +pub const PW_CORE_METHOD_ERROR = @as(c_int, 4); +pub const PW_CORE_METHOD_GET_REGISTRY = @as(c_int, 5); +pub const PW_CORE_METHOD_CREATE_OBJECT = @as(c_int, 6); +pub const PW_CORE_METHOD_DESTROY = @as(c_int, 7); +pub const PW_CORE_METHOD_NUM = @as(c_int, 8); +pub const PW_VERSION_CORE_METHODS = @as(c_int, 0); +pub const PW_REGISTRY_EVENT_GLOBAL = @as(c_int, 0); +pub const PW_REGISTRY_EVENT_GLOBAL_REMOVE = @as(c_int, 1); +pub const PW_REGISTRY_EVENT_NUM = @as(c_int, 2); +pub const PW_VERSION_REGISTRY_EVENTS = @as(c_int, 0); +pub const PW_REGISTRY_METHOD_ADD_LISTENER = @as(c_int, 0); +pub const PW_REGISTRY_METHOD_BIND = @as(c_int, 1); +pub const PW_REGISTRY_METHOD_DESTROY = @as(c_int, 2); +pub const PW_REGISTRY_METHOD_NUM = @as(c_int, 3); +pub const PW_VERSION_REGISTRY_METHODS = @as(c_int, 0); +pub const PIPEWIRE_LOOP_H = ""; +pub const SPA_LOOP_H = ""; +pub const SPA_SYSTEM_H = ""; +pub const _TIME_H = @as(c_int, 1); +pub const _BITS_TIME_H = @as(c_int, 1); +pub const CLOCKS_PER_SEC = @import("std").zig.c_translation.cast(__clock_t, @import("std").zig.c_translation.promoteIntLiteral(c_int, 1000000, .decimal)); +pub const CLOCK_REALTIME = @as(c_int, 0); +pub const CLOCK_MONOTONIC = @as(c_int, 1); +pub const CLOCK_PROCESS_CPUTIME_ID = @as(c_int, 2); +pub const CLOCK_THREAD_CPUTIME_ID = @as(c_int, 3); +pub const CLOCK_MONOTONIC_RAW = @as(c_int, 4); +pub const CLOCK_REALTIME_COARSE = @as(c_int, 5); +pub const CLOCK_MONOTONIC_COARSE = @as(c_int, 6); +pub const CLOCK_BOOTTIME = @as(c_int, 7); +pub const CLOCK_REALTIME_ALARM = @as(c_int, 8); +pub const CLOCK_BOOTTIME_ALARM = @as(c_int, 9); +pub const CLOCK_TAI = @as(c_int, 11); +pub const TIMER_ABSTIME = @as(c_int, 1); +pub const __struct_tm_defined = @as(c_int, 1); +pub const __itimerspec_defined = @as(c_int, 1); +pub const TIME_UTC = @as(c_int, 1); +pub inline fn __isleap(year: anytype) @TypeOf((@import("std").zig.c_translation.MacroArithmetic.rem(year, @as(c_int, 4)) == @as(c_int, 0)) and ((@import("std").zig.c_translation.MacroArithmetic.rem(year, @as(c_int, 100)) != @as(c_int, 0)) or (@import("std").zig.c_translation.MacroArithmetic.rem(year, @as(c_int, 400)) == @as(c_int, 0)))) { + _ = &year; + return (@import("std").zig.c_translation.MacroArithmetic.rem(year, @as(c_int, 4)) == @as(c_int, 0)) and ((@import("std").zig.c_translation.MacroArithmetic.rem(year, @as(c_int, 100)) != @as(c_int, 0)) or (@import("std").zig.c_translation.MacroArithmetic.rem(year, @as(c_int, 400)) == @as(c_int, 0))); +} +pub const SPA_API_SYSTEM = SPA_API_IMPL; +pub const SPA_TYPE_INTERFACE_System = SPA_TYPE_INFO_INTERFACE_BASE ++ "System"; +pub const SPA_TYPE_INTERFACE_DataSystem = SPA_TYPE_INFO_INTERFACE_BASE ++ "DataSystem"; +pub const SPA_VERSION_SYSTEM = @as(c_int, 0); +pub const SPA_IO_IN = @as(c_int, 1) << @as(c_int, 0); +pub const SPA_IO_OUT = @as(c_int, 1) << @as(c_int, 2); +pub const SPA_IO_ERR = @as(c_int, 1) << @as(c_int, 3); +pub const SPA_IO_HUP = @as(c_int, 1) << @as(c_int, 4); +pub const SPA_FD_CLOEXEC = @as(c_int, 1) << @as(c_int, 0); +pub const SPA_FD_NONBLOCK = @as(c_int, 1) << @as(c_int, 1); +pub const SPA_FD_EVENT_SEMAPHORE = @as(c_int, 1) << @as(c_int, 2); +pub const SPA_FD_TIMER_ABSTIME = @as(c_int, 1) << @as(c_int, 3); +pub const SPA_FD_TIMER_CANCEL_ON_SET = @as(c_int, 1) << @as(c_int, 4); +pub const SPA_VERSION_SYSTEM_METHODS = @as(c_int, 0); +pub const spa_system_ioctl = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/system.h:117:9 +pub const SPA_API_LOOP = SPA_API_IMPL; +pub const SPA_TYPE_INTERFACE_Loop = SPA_TYPE_INFO_INTERFACE_BASE ++ "Loop"; +pub const SPA_TYPE_INTERFACE_DataLoop = SPA_TYPE_INFO_INTERFACE_BASE ++ "DataLoop"; +pub const SPA_VERSION_LOOP = @as(c_int, 0); +pub const SPA_TYPE_INTERFACE_LoopControl = SPA_TYPE_INFO_INTERFACE_BASE ++ "LoopControl"; +pub const SPA_VERSION_LOOP_CONTROL = @as(c_int, 2); +pub const SPA_TYPE_INTERFACE_LoopUtils = SPA_TYPE_INFO_INTERFACE_BASE ++ "LoopUtils"; +pub const SPA_VERSION_LOOP_UTILS = @as(c_int, 0); +pub const SPA_VERSION_LOOP_METHODS = @as(c_int, 0); +pub const SPA_VERSION_LOOP_CONTROL_HOOKS = @as(c_int, 0); +pub const SPA_VERSION_LOOP_CONTROL_METHODS = @as(c_int, 2); +pub const SPA_VERSION_LOOP_UTILS_METHODS = @as(c_int, 0); +pub const PW_API_LOOP_IMPL = @compileError("unable to translate C expr: unexpected token 'static'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/loop.h:38:9 +pub const PW_VERSION_CONTEXT_EVENTS = @as(c_int, 1); +pub const PIPEWIRE_UTILS_H = ""; +pub const _SYS_UN_H = @as(c_int, 1); +pub const _BITS_SOCKADDR_H = @as(c_int, 1); +pub const __SOCKADDR_COMMON = @compileError("unable to translate macro: undefined identifier `family`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/sockaddr.h:34:9 +pub const __SOCKADDR_COMMON_SIZE = @import("std").zig.c_translation.sizeof(c_ushort); +pub const _SS_SIZE = @as(c_int, 128); +pub const SUN_LEN = @compileError("unable to translate macro: undefined identifier `sun_path`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/sys/un.h:41:10 +pub const SPA_POD_H = ""; +pub const SPA_POD_ALIGN = @as(c_int, 8); +pub const SPA_POD_MAX_SIZE = @as(c_uint, 1) << @as(c_int, 20); +pub inline fn SPA_POD_BODY_SIZE(pod: anytype) @TypeOf(@import("std").zig.c_translation.cast([*c]struct_spa_pod, pod).*.size) { + _ = &pod; + return @import("std").zig.c_translation.cast([*c]struct_spa_pod, pod).*.size; +} +pub inline fn SPA_POD_TYPE(pod: anytype) @TypeOf(@import("std").zig.c_translation.cast([*c]struct_spa_pod, pod).*.type) { + _ = &pod; + return @import("std").zig.c_translation.cast([*c]struct_spa_pod, pod).*.type; +} +pub inline fn SPA_POD_SIZE(pod: anytype) @TypeOf(@import("std").zig.c_translation.cast(u64, @import("std").zig.c_translation.sizeof(struct_spa_pod)) + SPA_POD_BODY_SIZE(pod)) { + _ = &pod; + return @import("std").zig.c_translation.cast(u64, @import("std").zig.c_translation.sizeof(struct_spa_pod)) + SPA_POD_BODY_SIZE(pod); +} +pub inline fn SPA_POD_CONTENTS_SIZE(@"type": anytype, pod: anytype) @TypeOf(SPA_POD_SIZE(pod) - @import("std").zig.c_translation.sizeof(@"type")) { + _ = &@"type"; + _ = &pod; + return SPA_POD_SIZE(pod) - @import("std").zig.c_translation.sizeof(@"type"); +} +pub inline fn SPA_POD_CONTENTS(@"type": anytype, pod: anytype) @TypeOf(SPA_PTROFF(pod, @import("std").zig.c_translation.sizeof(@"type"), anyopaque)) { + _ = &@"type"; + _ = &pod; + return SPA_PTROFF(pod, @import("std").zig.c_translation.sizeof(@"type"), anyopaque); +} +pub const SPA_POD_CONTENTS_CONST = @compileError("unable to translate C expr: unexpected token 'const'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/pod.h:29:9 +pub inline fn SPA_POD_BODY(pod: anytype) @TypeOf(SPA_PTROFF(pod, @import("std").zig.c_translation.sizeof(struct_spa_pod), anyopaque)) { + _ = &pod; + return SPA_PTROFF(pod, @import("std").zig.c_translation.sizeof(struct_spa_pod), anyopaque); +} +pub const SPA_POD_BODY_CONST = @compileError("unable to translate C expr: unexpected token 'const'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/pod.h:31:9 +pub inline fn SPA_POD_IS_VALID(pod: anytype) @TypeOf(SPA_POD_BODY_SIZE(pod) < SPA_POD_MAX_SIZE) { + _ = &pod; + return SPA_POD_BODY_SIZE(pod) < SPA_POD_MAX_SIZE; +} +pub inline fn SPA_POD_CHECK_TYPE(pod: anytype, _type: anytype) @TypeOf((SPA_POD_IS_VALID(pod) != 0) and (pod.*.type == _type)) { + _ = &pod; + _ = &_type; + return (SPA_POD_IS_VALID(pod) != 0) and (pod.*.type == _type); +} +pub inline fn SPA_POD_CHECK(pod: anytype, _type: anytype, _size: anytype) @TypeOf((SPA_POD_CHECK_TYPE(pod, _type) != 0) and (pod.*.size >= _size)) { + _ = &pod; + _ = &_type; + _ = &_size; + return (SPA_POD_CHECK_TYPE(pod, _type) != 0) and (pod.*.size >= _size); +} +pub const SPA_POD_VALUE = @compileError("unable to translate C expr: unexpected token ')'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/pod.h:47:9 +pub inline fn SPA_POD_ARRAY_CHILD(arr: anytype) @TypeOf(&@import("std").zig.c_translation.cast([*c]struct_spa_pod_array, arr).*.body.child) { + _ = &arr; + return &@import("std").zig.c_translation.cast([*c]struct_spa_pod_array, arr).*.body.child; +} +pub inline fn SPA_POD_ARRAY_VALUE_TYPE(arr: anytype) @TypeOf(SPA_POD_ARRAY_CHILD(arr).*.type) { + _ = &arr; + return SPA_POD_ARRAY_CHILD(arr).*.type; +} +pub inline fn SPA_POD_ARRAY_VALUE_SIZE(arr: anytype) @TypeOf(SPA_POD_ARRAY_CHILD(arr).*.size) { + _ = &arr; + return SPA_POD_ARRAY_CHILD(arr).*.size; +} +pub inline fn SPA_POD_ARRAY_N_VALUES(arr: anytype) @TypeOf(if (SPA_POD_ARRAY_VALUE_SIZE(arr)) @import("std").zig.c_translation.MacroArithmetic.div(SPA_POD_BODY_SIZE(arr) - @import("std").zig.c_translation.sizeof(struct_spa_pod_array_body), SPA_POD_ARRAY_VALUE_SIZE(arr)) else @as(c_int, 0)) { + _ = &arr; + return if (SPA_POD_ARRAY_VALUE_SIZE(arr)) @import("std").zig.c_translation.MacroArithmetic.div(SPA_POD_BODY_SIZE(arr) - @import("std").zig.c_translation.sizeof(struct_spa_pod_array_body), SPA_POD_ARRAY_VALUE_SIZE(arr)) else @as(c_int, 0); +} +pub inline fn SPA_POD_ARRAY_VALUES(arr: anytype) @TypeOf(SPA_POD_CONTENTS(struct_spa_pod_array, arr)) { + _ = &arr; + return SPA_POD_CONTENTS(struct_spa_pod_array, arr); +} +pub inline fn SPA_POD_CHOICE_CHILD(choice: anytype) @TypeOf(&@import("std").zig.c_translation.cast([*c]struct_spa_pod_choice, choice).*.body.child) { + _ = &choice; + return &@import("std").zig.c_translation.cast([*c]struct_spa_pod_choice, choice).*.body.child; +} +pub inline fn SPA_POD_CHOICE_TYPE(choice: anytype) @TypeOf(@import("std").zig.c_translation.cast([*c]struct_spa_pod_choice, choice).*.body.type) { + _ = &choice; + return @import("std").zig.c_translation.cast([*c]struct_spa_pod_choice, choice).*.body.type; +} +pub inline fn SPA_POD_CHOICE_FLAGS(choice: anytype) @TypeOf(@import("std").zig.c_translation.cast([*c]struct_spa_pod_choice, choice).*.body.flags) { + _ = &choice; + return @import("std").zig.c_translation.cast([*c]struct_spa_pod_choice, choice).*.body.flags; +} +pub inline fn SPA_POD_CHOICE_VALUE_TYPE(choice: anytype) @TypeOf(SPA_POD_CHOICE_CHILD(choice).*.type) { + _ = &choice; + return SPA_POD_CHOICE_CHILD(choice).*.type; +} +pub inline fn SPA_POD_CHOICE_VALUE_SIZE(choice: anytype) @TypeOf(SPA_POD_CHOICE_CHILD(choice).*.size) { + _ = &choice; + return SPA_POD_CHOICE_CHILD(choice).*.size; +} +pub inline fn SPA_POD_CHOICE_N_VALUES(choice: anytype) @TypeOf(if (SPA_POD_CHOICE_VALUE_SIZE(choice)) @import("std").zig.c_translation.MacroArithmetic.div(SPA_POD_BODY_SIZE(choice) - @import("std").zig.c_translation.sizeof(struct_spa_pod_choice_body), SPA_POD_CHOICE_VALUE_SIZE(choice)) else @as(c_int, 0)) { + _ = &choice; + return if (SPA_POD_CHOICE_VALUE_SIZE(choice)) @import("std").zig.c_translation.MacroArithmetic.div(SPA_POD_BODY_SIZE(choice) - @import("std").zig.c_translation.sizeof(struct_spa_pod_choice_body), SPA_POD_CHOICE_VALUE_SIZE(choice)) else @as(c_int, 0); +} +pub inline fn SPA_POD_CHOICE_VALUES(choice: anytype) @TypeOf(SPA_POD_CONTENTS(struct_spa_pod_choice, choice)) { + _ = &choice; + return SPA_POD_CONTENTS(struct_spa_pod_choice, choice); +} +pub inline fn SPA_POD_STRUCT_BODY(pod: anytype) @TypeOf(SPA_PTROFF(pod, @import("std").zig.c_translation.sizeof(struct_spa_pod), struct_spa_pod)) { + _ = &pod; + return SPA_PTROFF(pod, @import("std").zig.c_translation.sizeof(struct_spa_pod), struct_spa_pod); +} +pub const SPA_POD_STRUCT_BODY_CONST = @compileError("unable to translate C expr: unexpected token 'const'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/pod.h:154:9 +pub inline fn SPA_POD_OBJECT_TYPE(obj: anytype) @TypeOf(@import("std").zig.c_translation.cast([*c]struct_spa_pod_object, obj).*.body.type) { + _ = &obj; + return @import("std").zig.c_translation.cast([*c]struct_spa_pod_object, obj).*.body.type; +} +pub inline fn SPA_POD_OBJECT_ID(obj: anytype) @TypeOf(@import("std").zig.c_translation.cast([*c]struct_spa_pod_object, obj).*.body.id) { + _ = &obj; + return @import("std").zig.c_translation.cast([*c]struct_spa_pod_object, obj).*.body.id; +} +pub inline fn SPA_POD_PROP_SIZE(prop: anytype) @TypeOf(@import("std").zig.c_translation.sizeof(struct_spa_pod_prop) + prop.*.value.size) { + _ = ∝ + return @import("std").zig.c_translation.sizeof(struct_spa_pod_prop) + prop.*.value.size; +} +pub const SPA_POD_PROP_FLAG_READONLY = @as(c_uint, 1) << @as(c_int, 0); +pub const SPA_POD_PROP_FLAG_HARDWARE = @as(c_uint, 1) << @as(c_int, 1); +pub const SPA_POD_PROP_FLAG_HINT_DICT = @as(c_uint, 1) << @as(c_int, 2); +pub const SPA_POD_PROP_FLAG_MANDATORY = @as(c_uint, 1) << @as(c_int, 3); +pub const SPA_POD_PROP_FLAG_DONT_FIXATE = @as(c_uint, 1) << @as(c_int, 4); +pub const SPA_POD_PROP_FLAG_DROP = @as(c_uint, 1) << @as(c_int, 5); +pub inline fn SPA_POD_CONTROL_SIZE(ev: anytype) @TypeOf(@import("std").zig.c_translation.sizeof(struct_spa_pod_control) + ev.*.value.size) { + _ = &ev; + return @import("std").zig.c_translation.sizeof(struct_spa_pod_control) + ev.*.value.size; +} +pub const strndupa = @compileError("unable to translate macro: undefined identifier `__old`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/utils.h:63:10 +pub const strdupa = @compileError("unable to translate macro: undefined identifier `__old`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/utils.h:75:10 +pub const pw_rand32 = @compileError("unable to translate macro: undefined identifier `val`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/utils.h:89:9 +pub const PW_DEPRECATED = @compileError("unable to translate macro: undefined identifier `_v`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/utils.h:96:9 +pub const PW_TYPE_INFO_Protocol = "PipeWire:Protocol"; +pub const PW_TYPE_INFO_PROTOCOL_BASE = PW_TYPE_INFO_Protocol ++ ":"; +pub inline fn pw_protocol_client_connect(c: anytype, p: anytype, cb: anytype, d: anytype) @TypeOf(c.*.connect(c, p, cb, d)) { + _ = &c; + _ = &p; + _ = &cb; + _ = &d; + return c.*.connect(c, p, cb, d); +} +pub inline fn pw_protocol_client_connect_fd(c: anytype, fd: anytype, cl: anytype) @TypeOf(c.*.connect_fd(c, fd, cl)) { + _ = &c; + _ = &fd; + _ = &cl; + return c.*.connect_fd(c, fd, cl); +} +pub inline fn pw_protocol_client_steal_fd(c: anytype) @TypeOf(c.*.steal_fd(c)) { + _ = &c; + return c.*.steal_fd(c); +} +pub inline fn pw_protocol_client_disconnect(c: anytype) @TypeOf(c.*.disconnect(c)) { + _ = &c; + return c.*.disconnect(c); +} +pub inline fn pw_protocol_client_destroy(c: anytype) @TypeOf(c.*.destroy(c)) { + _ = &c; + return c.*.destroy(c); +} +pub inline fn pw_protocol_client_set_paused(c: anytype, p: anytype) @TypeOf(c.*.set_paused(c, p)) { + _ = &c; + _ = &p; + return c.*.set_paused(c, p); +} +pub inline fn pw_protocol_server_destroy(l: anytype) @TypeOf(l.*.destroy(l)) { + _ = &l; + return l.*.destroy(l); +} +pub const PW_PROTOCOL_MARSHAL_FLAG_IMPL = @as(c_int, 1) << @as(c_int, 0); +pub const PW_VERSION_PROTOCOL_IMPLEMENTATION = @as(c_int, 1); +pub const PW_VERSION_PROTOCOL_EVENTS = @as(c_int, 0); +pub const pw_protocol_new_client = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/protocol.h:106:9 +pub const pw_protocol_add_server = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/protocol.h:107:9 +pub const pw_protocol_add_fd_server = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/protocol.h:108:9 +pub const pw_protocol_ext = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/protocol.h:109:9 +pub const PW_VERSION_PROXY_EVENTS = @as(c_int, 1); +pub const pw_proxy_notify = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/proxy.h:179:9 +pub const pw_proxy_call = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/proxy.h:183:9 +pub const pw_proxy_call_res = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/proxy.h:187:9 +pub const PIPEWIRE_PERMISSION_H = ""; +pub const PW_PERM_R = @as(c_int, 0o400); +pub const PW_PERM_W = @as(c_int, 0o200); +pub const PW_PERM_X = @as(c_int, 0o100); +pub const PW_PERM_M = @as(c_int, 0o010); +pub const PW_PERM_L = @as(c_int, 0o020); +pub const PW_PERM_RW = PW_PERM_R | PW_PERM_W; +pub const PW_PERM_RWX = PW_PERM_RW | PW_PERM_X; +pub const PW_PERM_RWXM = PW_PERM_RWX | PW_PERM_M; +pub const PW_PERM_RWXML = PW_PERM_RWXM | PW_PERM_L; +pub inline fn PW_PERM_IS_R(p: anytype) @TypeOf((p & PW_PERM_R) == PW_PERM_R) { + _ = &p; + return (p & PW_PERM_R) == PW_PERM_R; +} +pub inline fn PW_PERM_IS_W(p: anytype) @TypeOf((p & PW_PERM_W) == PW_PERM_W) { + _ = &p; + return (p & PW_PERM_W) == PW_PERM_W; +} +pub inline fn PW_PERM_IS_X(p: anytype) @TypeOf((p & PW_PERM_X) == PW_PERM_X) { + _ = &p; + return (p & PW_PERM_X) == PW_PERM_X; +} +pub inline fn PW_PERM_IS_M(p: anytype) @TypeOf((p & PW_PERM_M) == PW_PERM_M) { + _ = &p; + return (p & PW_PERM_M) == PW_PERM_M; +} +pub inline fn PW_PERM_IS_L(p: anytype) @TypeOf((p & PW_PERM_L) == PW_PERM_L) { + _ = &p; + return (p & PW_PERM_L) == PW_PERM_L; +} +pub const PW_PERM_ALL = PW_PERM_RWXM; +pub const PW_PERM_INVALID = @import("std").zig.c_translation.cast(u32, @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffffffff, .hex)); +pub inline fn PW_PERMISSION_INIT(id: anytype, p: anytype) struct_pw_permission { + _ = &id; + _ = &p; + return @import("std").mem.zeroInit(struct_pw_permission, .{ id, p }); +} +pub const PW_PERMISSION_FORMAT = "%c%c%c%c%c"; +pub inline fn PW_PERMISSION_ARGS(permission: anytype) @TypeOf(if (permission & PW_PERM_L) 'l' else '-') { + _ = &permission; + return blk: { + _ = if (permission & PW_PERM_R) 'r' else '-'; + _ = if (permission & PW_PERM_W) 'w' else '-'; + _ = if (permission & PW_PERM_X) 'x' else '-'; + _ = if (permission & PW_PERM_M) 'm' else '-'; + break :blk if (permission & PW_PERM_L) 'l' else '-'; + }; +} +pub const PW_TYPE_INTERFACE_Client = PW_TYPE_INFO_INTERFACE_BASE ++ "Client"; +pub const PW_CLIENT_PERM_MASK = PW_PERM_RWXM; +pub const PW_VERSION_CLIENT = @as(c_int, 3); +pub const PW_API_CLIENT_IMPL = @compileError("unable to translate C expr: unexpected token 'static'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/client.h:35:9 +pub const PW_ID_CLIENT = @as(c_int, 1); +pub const PW_CLIENT_CHANGE_MASK_PROPS = @as(c_int, 1) << @as(c_int, 0); +pub const PW_CLIENT_CHANGE_MASK_ALL = (@as(c_int, 1) << @as(c_int, 1)) - @as(c_int, 1); +pub const PW_CLIENT_EVENT_INFO = @as(c_int, 0); +pub const PW_CLIENT_EVENT_PERMISSIONS = @as(c_int, 1); +pub const PW_CLIENT_EVENT_NUM = @as(c_int, 2); +pub const PW_VERSION_CLIENT_EVENTS = @as(c_int, 0); +pub const PW_CLIENT_METHOD_ADD_LISTENER = @as(c_int, 0); +pub const PW_CLIENT_METHOD_ERROR = @as(c_int, 1); +pub const PW_CLIENT_METHOD_UPDATE_PROPERTIES = @as(c_int, 2); +pub const PW_CLIENT_METHOD_GET_PERMISSIONS = @as(c_int, 3); +pub const PW_CLIENT_METHOD_UPDATE_PERMISSIONS = @as(c_int, 4); +pub const PW_CLIENT_METHOD_NUM = @as(c_int, 5); +pub const PW_VERSION_CLIENT_METHODS = @as(c_int, 0); +pub const PIPEWIRE_CONF_H = ""; +pub const SPA_UTILS_JSON_H = ""; +pub const _MATH_H = @as(c_int, 1); +pub const _BITS_LIBM_SIMD_DECL_STUBS_H = @as(c_int, 1); +pub const __DECL_SIMD_cos = ""; +pub const __DECL_SIMD_cosf = ""; +pub const __DECL_SIMD_cosl = ""; +pub const __DECL_SIMD_cosf16 = ""; +pub const __DECL_SIMD_cosf32 = ""; +pub const __DECL_SIMD_cosf64 = ""; +pub const __DECL_SIMD_cosf128 = ""; +pub const __DECL_SIMD_cosf32x = ""; +pub const __DECL_SIMD_cosf64x = ""; +pub const __DECL_SIMD_cosf128x = ""; +pub const __DECL_SIMD_sin = ""; +pub const __DECL_SIMD_sinf = ""; +pub const __DECL_SIMD_sinl = ""; +pub const __DECL_SIMD_sinf16 = ""; +pub const __DECL_SIMD_sinf32 = ""; +pub const __DECL_SIMD_sinf64 = ""; +pub const __DECL_SIMD_sinf128 = ""; +pub const __DECL_SIMD_sinf32x = ""; +pub const __DECL_SIMD_sinf64x = ""; +pub const __DECL_SIMD_sinf128x = ""; +pub const __DECL_SIMD_sincos = ""; +pub const __DECL_SIMD_sincosf = ""; +pub const __DECL_SIMD_sincosl = ""; +pub const __DECL_SIMD_sincosf16 = ""; +pub const __DECL_SIMD_sincosf32 = ""; +pub const __DECL_SIMD_sincosf64 = ""; +pub const __DECL_SIMD_sincosf128 = ""; +pub const __DECL_SIMD_sincosf32x = ""; +pub const __DECL_SIMD_sincosf64x = ""; +pub const __DECL_SIMD_sincosf128x = ""; +pub const __DECL_SIMD_log = ""; +pub const __DECL_SIMD_logf = ""; +pub const __DECL_SIMD_logl = ""; +pub const __DECL_SIMD_logf16 = ""; +pub const __DECL_SIMD_logf32 = ""; +pub const __DECL_SIMD_logf64 = ""; +pub const __DECL_SIMD_logf128 = ""; +pub const __DECL_SIMD_logf32x = ""; +pub const __DECL_SIMD_logf64x = ""; +pub const __DECL_SIMD_logf128x = ""; +pub const __DECL_SIMD_exp = ""; +pub const __DECL_SIMD_expf = ""; +pub const __DECL_SIMD_expl = ""; +pub const __DECL_SIMD_expf16 = ""; +pub const __DECL_SIMD_expf32 = ""; +pub const __DECL_SIMD_expf64 = ""; +pub const __DECL_SIMD_expf128 = ""; +pub const __DECL_SIMD_expf32x = ""; +pub const __DECL_SIMD_expf64x = ""; +pub const __DECL_SIMD_expf128x = ""; +pub const __DECL_SIMD_pow = ""; +pub const __DECL_SIMD_powf = ""; +pub const __DECL_SIMD_powl = ""; +pub const __DECL_SIMD_powf16 = ""; +pub const __DECL_SIMD_powf32 = ""; +pub const __DECL_SIMD_powf64 = ""; +pub const __DECL_SIMD_powf128 = ""; +pub const __DECL_SIMD_powf32x = ""; +pub const __DECL_SIMD_powf64x = ""; +pub const __DECL_SIMD_powf128x = ""; +pub const __DECL_SIMD_acos = ""; +pub const __DECL_SIMD_acosf = ""; +pub const __DECL_SIMD_acosl = ""; +pub const __DECL_SIMD_acosf16 = ""; +pub const __DECL_SIMD_acosf32 = ""; +pub const __DECL_SIMD_acosf64 = ""; +pub const __DECL_SIMD_acosf128 = ""; +pub const __DECL_SIMD_acosf32x = ""; +pub const __DECL_SIMD_acosf64x = ""; +pub const __DECL_SIMD_acosf128x = ""; +pub const __DECL_SIMD_atan = ""; +pub const __DECL_SIMD_atanf = ""; +pub const __DECL_SIMD_atanl = ""; +pub const __DECL_SIMD_atanf16 = ""; +pub const __DECL_SIMD_atanf32 = ""; +pub const __DECL_SIMD_atanf64 = ""; +pub const __DECL_SIMD_atanf128 = ""; +pub const __DECL_SIMD_atanf32x = ""; +pub const __DECL_SIMD_atanf64x = ""; +pub const __DECL_SIMD_atanf128x = ""; +pub const __DECL_SIMD_asin = ""; +pub const __DECL_SIMD_asinf = ""; +pub const __DECL_SIMD_asinl = ""; +pub const __DECL_SIMD_asinf16 = ""; +pub const __DECL_SIMD_asinf32 = ""; +pub const __DECL_SIMD_asinf64 = ""; +pub const __DECL_SIMD_asinf128 = ""; +pub const __DECL_SIMD_asinf32x = ""; +pub const __DECL_SIMD_asinf64x = ""; +pub const __DECL_SIMD_asinf128x = ""; +pub const __DECL_SIMD_hypot = ""; +pub const __DECL_SIMD_hypotf = ""; +pub const __DECL_SIMD_hypotl = ""; +pub const __DECL_SIMD_hypotf16 = ""; +pub const __DECL_SIMD_hypotf32 = ""; +pub const __DECL_SIMD_hypotf64 = ""; +pub const __DECL_SIMD_hypotf128 = ""; +pub const __DECL_SIMD_hypotf32x = ""; +pub const __DECL_SIMD_hypotf64x = ""; +pub const __DECL_SIMD_hypotf128x = ""; +pub const __DECL_SIMD_exp2 = ""; +pub const __DECL_SIMD_exp2f = ""; +pub const __DECL_SIMD_exp2l = ""; +pub const __DECL_SIMD_exp2f16 = ""; +pub const __DECL_SIMD_exp2f32 = ""; +pub const __DECL_SIMD_exp2f64 = ""; +pub const __DECL_SIMD_exp2f128 = ""; +pub const __DECL_SIMD_exp2f32x = ""; +pub const __DECL_SIMD_exp2f64x = ""; +pub const __DECL_SIMD_exp2f128x = ""; +pub const __DECL_SIMD_exp10 = ""; +pub const __DECL_SIMD_exp10f = ""; +pub const __DECL_SIMD_exp10l = ""; +pub const __DECL_SIMD_exp10f16 = ""; +pub const __DECL_SIMD_exp10f32 = ""; +pub const __DECL_SIMD_exp10f64 = ""; +pub const __DECL_SIMD_exp10f128 = ""; +pub const __DECL_SIMD_exp10f32x = ""; +pub const __DECL_SIMD_exp10f64x = ""; +pub const __DECL_SIMD_exp10f128x = ""; +pub const __DECL_SIMD_cosh = ""; +pub const __DECL_SIMD_coshf = ""; +pub const __DECL_SIMD_coshl = ""; +pub const __DECL_SIMD_coshf16 = ""; +pub const __DECL_SIMD_coshf32 = ""; +pub const __DECL_SIMD_coshf64 = ""; +pub const __DECL_SIMD_coshf128 = ""; +pub const __DECL_SIMD_coshf32x = ""; +pub const __DECL_SIMD_coshf64x = ""; +pub const __DECL_SIMD_coshf128x = ""; +pub const __DECL_SIMD_expm1 = ""; +pub const __DECL_SIMD_expm1f = ""; +pub const __DECL_SIMD_expm1l = ""; +pub const __DECL_SIMD_expm1f16 = ""; +pub const __DECL_SIMD_expm1f32 = ""; +pub const __DECL_SIMD_expm1f64 = ""; +pub const __DECL_SIMD_expm1f128 = ""; +pub const __DECL_SIMD_expm1f32x = ""; +pub const __DECL_SIMD_expm1f64x = ""; +pub const __DECL_SIMD_expm1f128x = ""; +pub const __DECL_SIMD_sinh = ""; +pub const __DECL_SIMD_sinhf = ""; +pub const __DECL_SIMD_sinhl = ""; +pub const __DECL_SIMD_sinhf16 = ""; +pub const __DECL_SIMD_sinhf32 = ""; +pub const __DECL_SIMD_sinhf64 = ""; +pub const __DECL_SIMD_sinhf128 = ""; +pub const __DECL_SIMD_sinhf32x = ""; +pub const __DECL_SIMD_sinhf64x = ""; +pub const __DECL_SIMD_sinhf128x = ""; +pub const __DECL_SIMD_cbrt = ""; +pub const __DECL_SIMD_cbrtf = ""; +pub const __DECL_SIMD_cbrtl = ""; +pub const __DECL_SIMD_cbrtf16 = ""; +pub const __DECL_SIMD_cbrtf32 = ""; +pub const __DECL_SIMD_cbrtf64 = ""; +pub const __DECL_SIMD_cbrtf128 = ""; +pub const __DECL_SIMD_cbrtf32x = ""; +pub const __DECL_SIMD_cbrtf64x = ""; +pub const __DECL_SIMD_cbrtf128x = ""; +pub const __DECL_SIMD_atan2 = ""; +pub const __DECL_SIMD_atan2f = ""; +pub const __DECL_SIMD_atan2l = ""; +pub const __DECL_SIMD_atan2f16 = ""; +pub const __DECL_SIMD_atan2f32 = ""; +pub const __DECL_SIMD_atan2f64 = ""; +pub const __DECL_SIMD_atan2f128 = ""; +pub const __DECL_SIMD_atan2f32x = ""; +pub const __DECL_SIMD_atan2f64x = ""; +pub const __DECL_SIMD_atan2f128x = ""; +pub const __DECL_SIMD_log10 = ""; +pub const __DECL_SIMD_log10f = ""; +pub const __DECL_SIMD_log10l = ""; +pub const __DECL_SIMD_log10f16 = ""; +pub const __DECL_SIMD_log10f32 = ""; +pub const __DECL_SIMD_log10f64 = ""; +pub const __DECL_SIMD_log10f128 = ""; +pub const __DECL_SIMD_log10f32x = ""; +pub const __DECL_SIMD_log10f64x = ""; +pub const __DECL_SIMD_log10f128x = ""; +pub const __DECL_SIMD_log2 = ""; +pub const __DECL_SIMD_log2f = ""; +pub const __DECL_SIMD_log2l = ""; +pub const __DECL_SIMD_log2f16 = ""; +pub const __DECL_SIMD_log2f32 = ""; +pub const __DECL_SIMD_log2f64 = ""; +pub const __DECL_SIMD_log2f128 = ""; +pub const __DECL_SIMD_log2f32x = ""; +pub const __DECL_SIMD_log2f64x = ""; +pub const __DECL_SIMD_log2f128x = ""; +pub const __DECL_SIMD_log1p = ""; +pub const __DECL_SIMD_log1pf = ""; +pub const __DECL_SIMD_log1pl = ""; +pub const __DECL_SIMD_log1pf16 = ""; +pub const __DECL_SIMD_log1pf32 = ""; +pub const __DECL_SIMD_log1pf64 = ""; +pub const __DECL_SIMD_log1pf128 = ""; +pub const __DECL_SIMD_log1pf32x = ""; +pub const __DECL_SIMD_log1pf64x = ""; +pub const __DECL_SIMD_log1pf128x = ""; +pub const __DECL_SIMD_atanh = ""; +pub const __DECL_SIMD_atanhf = ""; +pub const __DECL_SIMD_atanhl = ""; +pub const __DECL_SIMD_atanhf16 = ""; +pub const __DECL_SIMD_atanhf32 = ""; +pub const __DECL_SIMD_atanhf64 = ""; +pub const __DECL_SIMD_atanhf128 = ""; +pub const __DECL_SIMD_atanhf32x = ""; +pub const __DECL_SIMD_atanhf64x = ""; +pub const __DECL_SIMD_atanhf128x = ""; +pub const __DECL_SIMD_acosh = ""; +pub const __DECL_SIMD_acoshf = ""; +pub const __DECL_SIMD_acoshl = ""; +pub const __DECL_SIMD_acoshf16 = ""; +pub const __DECL_SIMD_acoshf32 = ""; +pub const __DECL_SIMD_acoshf64 = ""; +pub const __DECL_SIMD_acoshf128 = ""; +pub const __DECL_SIMD_acoshf32x = ""; +pub const __DECL_SIMD_acoshf64x = ""; +pub const __DECL_SIMD_acoshf128x = ""; +pub const __DECL_SIMD_erf = ""; +pub const __DECL_SIMD_erff = ""; +pub const __DECL_SIMD_erfl = ""; +pub const __DECL_SIMD_erff16 = ""; +pub const __DECL_SIMD_erff32 = ""; +pub const __DECL_SIMD_erff64 = ""; +pub const __DECL_SIMD_erff128 = ""; +pub const __DECL_SIMD_erff32x = ""; +pub const __DECL_SIMD_erff64x = ""; +pub const __DECL_SIMD_erff128x = ""; +pub const __DECL_SIMD_tanh = ""; +pub const __DECL_SIMD_tanhf = ""; +pub const __DECL_SIMD_tanhl = ""; +pub const __DECL_SIMD_tanhf16 = ""; +pub const __DECL_SIMD_tanhf32 = ""; +pub const __DECL_SIMD_tanhf64 = ""; +pub const __DECL_SIMD_tanhf128 = ""; +pub const __DECL_SIMD_tanhf32x = ""; +pub const __DECL_SIMD_tanhf64x = ""; +pub const __DECL_SIMD_tanhf128x = ""; +pub const __DECL_SIMD_asinh = ""; +pub const __DECL_SIMD_asinhf = ""; +pub const __DECL_SIMD_asinhl = ""; +pub const __DECL_SIMD_asinhf16 = ""; +pub const __DECL_SIMD_asinhf32 = ""; +pub const __DECL_SIMD_asinhf64 = ""; +pub const __DECL_SIMD_asinhf128 = ""; +pub const __DECL_SIMD_asinhf32x = ""; +pub const __DECL_SIMD_asinhf64x = ""; +pub const __DECL_SIMD_asinhf128x = ""; +pub const __DECL_SIMD_erfc = ""; +pub const __DECL_SIMD_erfcf = ""; +pub const __DECL_SIMD_erfcl = ""; +pub const __DECL_SIMD_erfcf16 = ""; +pub const __DECL_SIMD_erfcf32 = ""; +pub const __DECL_SIMD_erfcf64 = ""; +pub const __DECL_SIMD_erfcf128 = ""; +pub const __DECL_SIMD_erfcf32x = ""; +pub const __DECL_SIMD_erfcf64x = ""; +pub const __DECL_SIMD_erfcf128x = ""; +pub const __DECL_SIMD_tan = ""; +pub const __DECL_SIMD_tanf = ""; +pub const __DECL_SIMD_tanl = ""; +pub const __DECL_SIMD_tanf16 = ""; +pub const __DECL_SIMD_tanf32 = ""; +pub const __DECL_SIMD_tanf64 = ""; +pub const __DECL_SIMD_tanf128 = ""; +pub const __DECL_SIMD_tanf32x = ""; +pub const __DECL_SIMD_tanf64x = ""; +pub const __DECL_SIMD_tanf128x = ""; +pub const HUGE_VAL = @compileError("unable to translate macro: undefined identifier `__builtin_huge_val`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:48:10 +pub const HUGE_VALF = __builtin_huge_valf(); +pub const HUGE_VALL = @compileError("unable to translate macro: undefined identifier `__builtin_huge_vall`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:60:11 +pub const INFINITY = __builtin_inff(); +pub const NAN = __builtin_nanf(""); +pub const __GLIBC_FLT_EVAL_METHOD = @compileError("unable to translate macro: undefined identifier `__FLT_EVAL_METHOD__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/bits/flt-eval-method.h:27:11 +pub const __FP_LOGB0_IS_MIN = @as(c_int, 1); +pub const __FP_LOGBNAN_IS_MIN = @as(c_int, 1); +pub const FP_ILOGB0 = -@import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal) - @as(c_int, 1); +pub const FP_ILOGBNAN = -@import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal) - @as(c_int, 1); +pub const __SIMD_DECL = @compileError("unable to translate macro: undefined identifier `__DECL_SIMD_`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:276:9 +pub inline fn __MATHCALL_VEC(function: anytype, suffix: anytype, args: anytype) @TypeOf(__SIMD_DECL(__MATH_PRECNAME(function, suffix)) ++ __MATHCALL(function, suffix, args)) { + _ = &function; + _ = &suffix; + _ = &args; + return __SIMD_DECL(__MATH_PRECNAME(function, suffix)) ++ __MATHCALL(function, suffix, args); +} +pub inline fn __MATHDECL_VEC(@"type": anytype, function: anytype, suffix: anytype, args: anytype) @TypeOf(__SIMD_DECL(__MATH_PRECNAME(function, suffix)) ++ __MATHDECL(@"type", function, suffix, args)) { + _ = &@"type"; + _ = &function; + _ = &suffix; + _ = &args; + return __SIMD_DECL(__MATH_PRECNAME(function, suffix)) ++ __MATHDECL(@"type", function, suffix, args); +} +pub inline fn __MATHCALL(function: anytype, suffix: anytype, args: anytype) @TypeOf(__MATHDECL(_Mdouble_, function, suffix, args)) { + _ = &function; + _ = &suffix; + _ = &args; + return __MATHDECL(_Mdouble_, function, suffix, args); +} +pub const __MATHDECL = @compileError("unable to translate macro: undefined identifier `__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:288:9 +pub inline fn __MATHCALLX(function: anytype, suffix: anytype, args: anytype, attrib: anytype) @TypeOf(__MATHDECLX(_Mdouble_, function, suffix, args, attrib)) { + _ = &function; + _ = &suffix; + _ = &args; + _ = &attrib; + return __MATHDECLX(_Mdouble_, function, suffix, args, attrib); +} +pub const __MATHDECLX = @compileError("unable to translate macro: undefined identifier `__`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:293:9 +pub const __MATHDECL_1_IMPL = @compileError("unable to translate C expr: unexpected token 'extern'"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:296:9 +pub inline fn __MATHDECL_1(@"type": anytype, function: anytype, suffix: anytype, args: anytype) @TypeOf(__MATHDECL_1_IMPL(@"type", function, suffix, args)) { + _ = &@"type"; + _ = &function; + _ = &suffix; + _ = &args; + return __MATHDECL_1_IMPL(@"type", function, suffix, args); +} +pub inline fn __MATHDECL_ALIAS(@"type": anytype, function: anytype, suffix: anytype, args: anytype, alias: anytype) @TypeOf(__MATHDECL_1(@"type", function, suffix, args)) { + _ = &@"type"; + _ = &function; + _ = &suffix; + _ = &args; + _ = &alias; + return __MATHDECL_1(@"type", function, suffix, args); +} +pub const __MATHREDIR = @compileError("unable to translate C expr: unexpected token 'extern'"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:305:9 +pub const _Mdouble_ = f64; +pub inline fn __MATH_PRECNAME(name: anytype, r: anytype) @TypeOf(__CONCAT(name, r)) { + _ = &name; + _ = &r; + return __CONCAT(name, r); +} +pub const __MATH_DECLARING_DOUBLE = @as(c_int, 1); +pub const __MATH_DECLARING_FLOATN = @as(c_int, 0); +pub const __MATH_DECLARE_LDOUBLE = @as(c_int, 1); +pub const __MATHCALL_NARROW_ARGS_1 = @compileError("unable to translate macro: undefined identifier `_Marg_`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:550:9 +pub const __MATHCALL_NARROW_ARGS_2 = @compileError("unable to translate macro: undefined identifier `_Marg_`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:551:9 +pub const __MATHCALL_NARROW_ARGS_3 = @compileError("unable to translate macro: undefined identifier `_Marg_`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:552:9 +pub const __MATHCALL_NARROW_NORMAL = @compileError("unable to translate macro: undefined identifier `_Mret_`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:553:9 +pub const __MATHCALL_NARROW_REDIR = @compileError("unable to translate macro: undefined identifier `_Mret_`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:555:9 +pub inline fn __MATHCALL_NARROW(func: anytype, redir: anytype, nargs: anytype) @TypeOf(__MATHCALL_NARROW_NORMAL(func, nargs)) { + _ = &func; + _ = &redir; + _ = &nargs; + return __MATHCALL_NARROW_NORMAL(func, nargs); +} +pub const __MATH_TG = @compileError("unable to translate macro: undefined identifier `f`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:922:10 +pub const fpclassify = @compileError("unable to translate macro: undefined identifier `__builtin_fpclassify`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:967:11 +pub inline fn signbit(x: anytype) @TypeOf(__builtin_signbit(x)) { + _ = &x; + return __builtin_signbit(x); +} +pub const isfinite = @compileError("unable to translate macro: undefined identifier `__builtin_isfinite`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:994:11 +pub const isnormal = @compileError("unable to translate macro: undefined identifier `__builtin_isnormal`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:1002:11 +pub const MATH_ERRNO = @as(c_int, 1); +pub const MATH_ERREXCEPT = @as(c_int, 2); +pub const math_errhandling = MATH_ERRNO | MATH_ERREXCEPT; +pub const M_E = @as(f64, 2.7182818284590452354); +pub const M_LOG2E = @as(f64, 1.4426950408889634074); +pub const M_LOG10E = @as(f64, 0.43429448190325182765); +pub const M_LN2 = @as(f64, 0.69314718055994530942); +pub const M_LN10 = @as(f64, 2.30258509299404568402); +pub const M_PI = @as(f64, 3.14159265358979323846); +pub const M_PI_2 = @as(f64, 1.57079632679489661923); +pub const M_PI_4 = @as(f64, 0.78539816339744830962); +pub const M_1_PI = @as(f64, 0.31830988618379067154); +pub const M_2_PI = @as(f64, 0.63661977236758134308); +pub const M_2_SQRTPI = @as(f64, 1.12837916709551257390); +pub const M_SQRT2 = @as(f64, 1.41421356237309504880); +pub const M_SQRT1_2 = @as(f64, 0.70710678118654752440); +pub const isgreater = @compileError("unable to translate macro: undefined identifier `__builtin_isgreater`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:1306:11 +pub const isgreaterequal = @compileError("unable to translate macro: undefined identifier `__builtin_isgreaterequal`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:1307:11 +pub const isless = @compileError("unable to translate macro: undefined identifier `__builtin_isless`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:1308:11 +pub const islessequal = @compileError("unable to translate macro: undefined identifier `__builtin_islessequal`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:1309:11 +pub const islessgreater = @compileError("unable to translate macro: undefined identifier `__builtin_islessgreater`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:1310:11 +pub const isunordered = @compileError("unable to translate macro: undefined identifier `__builtin_isunordered`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/math.h:1311:11 +pub const __CLANG_FLOAT_H = ""; +pub const FLT_EVAL_METHOD = @compileError("unable to translate macro: undefined identifier `__FLT_EVAL_METHOD__`"); +// /home/mason/.cache/zig/p/N-V-__8AAN5NhBR0oTsvnwjPdeNiiDLtEsfXRHd1fv-R3TOv/lib/include/float.h:107:9 +pub const FLT_ROUNDS = @compileError("unable to translate macro: undefined identifier `__builtin_flt_rounds`"); +// /home/mason/.cache/zig/p/N-V-__8AAN5NhBR0oTsvnwjPdeNiiDLtEsfXRHd1fv-R3TOv/lib/include/float.h:109:9 +pub const FLT_RADIX = __FLT_RADIX__; +pub const FLT_MANT_DIG = __FLT_MANT_DIG__; +pub const DBL_MANT_DIG = __DBL_MANT_DIG__; +pub const LDBL_MANT_DIG = __LDBL_MANT_DIG__; +pub const DECIMAL_DIG = __DECIMAL_DIG__; +pub const FLT_DIG = __FLT_DIG__; +pub const DBL_DIG = __DBL_DIG__; +pub const LDBL_DIG = __LDBL_DIG__; +pub const FLT_MIN_EXP = __FLT_MIN_EXP__; +pub const DBL_MIN_EXP = __DBL_MIN_EXP__; +pub const LDBL_MIN_EXP = __LDBL_MIN_EXP__; +pub const FLT_MIN_10_EXP = __FLT_MIN_10_EXP__; +pub const DBL_MIN_10_EXP = __DBL_MIN_10_EXP__; +pub const LDBL_MIN_10_EXP = __LDBL_MIN_10_EXP__; +pub const FLT_MAX_EXP = __FLT_MAX_EXP__; +pub const DBL_MAX_EXP = __DBL_MAX_EXP__; +pub const LDBL_MAX_EXP = __LDBL_MAX_EXP__; +pub const FLT_MAX_10_EXP = __FLT_MAX_10_EXP__; +pub const DBL_MAX_10_EXP = __DBL_MAX_10_EXP__; +pub const LDBL_MAX_10_EXP = __LDBL_MAX_10_EXP__; +pub const FLT_MAX = __FLT_MAX__; +pub const DBL_MAX = __DBL_MAX__; +pub const LDBL_MAX = __LDBL_MAX__; +pub const FLT_EPSILON = __FLT_EPSILON__; +pub const DBL_EPSILON = __DBL_EPSILON__; +pub const LDBL_EPSILON = __LDBL_EPSILON__; +pub const FLT_MIN = __FLT_MIN__; +pub const DBL_MIN = __DBL_MIN__; +pub const LDBL_MIN = __LDBL_MIN__; +pub const FLT_TRUE_MIN = __FLT_DENORM_MIN__; +pub const DBL_TRUE_MIN = __DBL_DENORM_MIN__; +pub const LDBL_TRUE_MIN = __LDBL_DENORM_MIN__; +pub const FLT_DECIMAL_DIG = __FLT_DECIMAL_DIG__; +pub const DBL_DECIMAL_DIG = __DBL_DECIMAL_DIG__; +pub const LDBL_DECIMAL_DIG = __LDBL_DECIMAL_DIG__; +pub const FLT_HAS_SUBNORM = __FLT_HAS_DENORM__; +pub const DBL_HAS_SUBNORM = __DBL_HAS_DENORM__; +pub const LDBL_HAS_SUBNORM = __LDBL_HAS_DENORM__; +pub const FLT_NORM_MAX = __FLT_NORM_MAX__; +pub const DBL_NORM_MAX = __DBL_NORM_MAX__; +pub const LDBL_NORM_MAX = __LDBL_NORM_MAX__; +pub const SPA_API_JSON = SPA_API_IMPL; +pub const SPA_JSON_ERROR_FLAG = @as(c_int, 0x100); +pub inline fn SPA_JSON_INIT(data: anytype, size: anytype) struct_spa_json { + _ = &data; + _ = &size; + return @import("std").mem.zeroInit(struct_spa_json, .{ data, data + size, NULL, @as(c_int, 0), @as(c_int, 0) }); +} +pub inline fn SPA_JSON_ENTER(iter: anytype) struct_spa_json { + _ = &iter; + return @import("std").mem.zeroInit(struct_spa_json, .{ iter.*.cur, iter.*.end, iter, iter.*.state & @as(c_int, 0xff0), @as(c_int, 0) }); +} +pub inline fn SPA_JSON_SAVE(iter: anytype) struct_spa_json { + _ = &iter; + return @import("std").mem.zeroInit(struct_spa_json, .{ iter.*.cur, iter.*.end, NULL, iter.*.state, @as(c_int, 0) }); +} +pub inline fn SPA_JSON_START(iter: anytype, p: anytype) struct_spa_json { + _ = &iter; + _ = &p; + return @import("std").mem.zeroInit(struct_spa_json, .{ p, iter.*.end, NULL, @as(c_int, 0), @as(c_int, 0) }); +} +pub const _SPA_ERROR = @compileError("unable to translate macro: undefined identifier `err`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/json-core.h:115:9 +pub const __PUT = @compileError("unable to translate macro: undefined identifier `len`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/json-core.h:596:9 +pub const PIPEWIRE_DEVICE_H = ""; +pub const PW_TYPE_INTERFACE_Device = PW_TYPE_INFO_INTERFACE_BASE ++ "Device"; +pub const PW_DEVICE_PERM_MASK = PW_PERM_RWXM; +pub const PW_VERSION_DEVICE = @as(c_int, 3); +pub const PW_API_DEVICE_IMPL = @compileError("unable to translate C expr: unexpected token 'static'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/device.h:34:9 +pub const PW_DEVICE_CHANGE_MASK_PROPS = @as(c_int, 1) << @as(c_int, 0); +pub const PW_DEVICE_CHANGE_MASK_PARAMS = @as(c_int, 1) << @as(c_int, 1); +pub const PW_DEVICE_CHANGE_MASK_ALL = (@as(c_int, 1) << @as(c_int, 2)) - @as(c_int, 1); +pub const PW_DEVICE_EVENT_INFO = @as(c_int, 0); +pub const PW_DEVICE_EVENT_PARAM = @as(c_int, 1); +pub const PW_DEVICE_EVENT_NUM = @as(c_int, 2); +pub const PW_VERSION_DEVICE_EVENTS = @as(c_int, 0); +pub const PW_DEVICE_METHOD_ADD_LISTENER = @as(c_int, 0); +pub const PW_DEVICE_METHOD_SUBSCRIBE_PARAMS = @as(c_int, 1); +pub const PW_DEVICE_METHOD_ENUM_PARAMS = @as(c_int, 2); +pub const PW_DEVICE_METHOD_SET_PARAM = @as(c_int, 3); +pub const PW_DEVICE_METHOD_NUM = @as(c_int, 4); +pub const PW_VERSION_DEVICE_METHODS = @as(c_int, 0); +pub const PIPEWIRE_BUFFERS_H = ""; +pub const SPA_NODE_H = ""; +pub const SPA_BUFFER_H = ""; +pub const SPA_META_H = ""; +pub const SPA_API_META = SPA_API_IMPL; +pub inline fn SPA_META_TYPE_FEATURES(@"type": anytype, features: anytype) @TypeOf((@"type" << @as(c_int, 16)) | features) { + _ = &@"type"; + _ = &features; + return (@"type" << @as(c_int, 16)) | features; +} +pub const spa_meta_check = @compileError("unable to translate C expr: unexpected token '*'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/buffer/meta.h:71:9 +pub const SPA_META_HEADER_FLAG_DISCONT = @as(c_int, 1) << @as(c_int, 0); +pub const SPA_META_HEADER_FLAG_CORRUPTED = @as(c_int, 1) << @as(c_int, 1); +pub const SPA_META_HEADER_FLAG_MARKER = @as(c_int, 1) << @as(c_int, 2); +pub const SPA_META_HEADER_FLAG_HEADER = @as(c_int, 1) << @as(c_int, 3); +pub const SPA_META_HEADER_FLAG_GAP = @as(c_int, 1) << @as(c_int, 4); +pub const SPA_META_HEADER_FLAG_DELTA_UNIT = @as(c_int, 1) << @as(c_int, 5); +pub const spa_meta_for_each = @compileError("unable to translate C expr: unexpected token 'for'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/buffer/meta.h:102:9 +pub const SPA_META_FEATURE_SYNC_TIMELINE_RELEASE = @as(c_int, 1) << @as(c_int, 0); +pub const SPA_META_SYNC_TIMELINE_UNSCHEDULED_RELEASE = @as(c_int, 1) << @as(c_int, 0); +pub const SPA_API_BUFFER = SPA_API_IMPL; +pub const SPA_CHUNK_FLAG_NONE = @as(c_int, 0); +pub const SPA_CHUNK_FLAG_CORRUPTED = @as(c_uint, 1) << @as(c_int, 0); +pub const SPA_CHUNK_FLAG_EMPTY = @as(c_uint, 1) << @as(c_int, 1); +pub const SPA_DATA_FLAG_NONE = @as(c_int, 0); +pub const SPA_DATA_FLAG_READABLE = @as(c_uint, 1) << @as(c_int, 0); +pub const SPA_DATA_FLAG_WRITABLE = @as(c_uint, 1) << @as(c_int, 1); +pub const SPA_DATA_FLAG_DYNAMIC = @as(c_uint, 1) << @as(c_int, 2); +pub const SPA_DATA_FLAG_READWRITE = SPA_DATA_FLAG_READABLE | SPA_DATA_FLAG_WRITABLE; +pub const SPA_DATA_FLAG_MAPPABLE = @as(c_uint, 1) << @as(c_int, 3); +pub const SPA_EVENT_NODE_H = ""; +pub const SPA_EVENT_H = ""; +pub inline fn SPA_EVENT_TYPE(ev: anytype) @TypeOf(ev.*.body.body.type) { + _ = &ev; + return ev.*.body.body.type; +} +pub inline fn SPA_EVENT_ID(ev: anytype, @"type": anytype) @TypeOf(if (SPA_EVENT_TYPE(ev) == @"type") ev.*.body.body.id else SPA_ID_INVALID) { + _ = &ev; + _ = &@"type"; + return if (SPA_EVENT_TYPE(ev) == @"type") ev.*.body.body.id else SPA_ID_INVALID; +} +pub const SPA_EVENT_INIT_FULL = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/event.h:32:9 +pub inline fn SPA_EVENT_INIT(@"type": anytype, id: anytype) @TypeOf(SPA_EVENT_INIT_FULL(struct_spa_event, @import("std").zig.c_translation.sizeof(struct_spa_event_body), @"type", id)) { + _ = &@"type"; + _ = &id; + return SPA_EVENT_INIT_FULL(struct_spa_event, @import("std").zig.c_translation.sizeof(struct_spa_event_body), @"type", id); +} +pub inline fn SPA_NODE_EVENT_ID(ev: anytype) @TypeOf(SPA_EVENT_ID(ev, SPA_TYPE_EVENT_Node)) { + _ = &ev; + return SPA_EVENT_ID(ev, SPA_TYPE_EVENT_Node); +} +pub inline fn SPA_NODE_EVENT_INIT(id: anytype) @TypeOf(SPA_EVENT_INIT(SPA_TYPE_EVENT_Node, id)) { + _ = &id; + return SPA_EVENT_INIT(SPA_TYPE_EVENT_Node, id); +} +pub const SPA_COMMAND_NODE_H = ""; +pub const SPA_COMMAND_H = ""; +pub inline fn SPA_COMMAND_TYPE(cmd: anytype) @TypeOf(cmd.*.body.body.type) { + _ = &cmd; + return cmd.*.body.body.type; +} +pub inline fn SPA_COMMAND_ID(cmd: anytype, @"type": anytype) @TypeOf(if (SPA_COMMAND_TYPE(cmd) == @"type") cmd.*.body.body.id else SPA_ID_INVALID) { + _ = &cmd; + _ = &@"type"; + return if (SPA_COMMAND_TYPE(cmd) == @"type") cmd.*.body.body.id else SPA_ID_INVALID; +} +pub const SPA_COMMAND_INIT_FULL = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/command.h:33:9 +pub inline fn SPA_COMMAND_INIT(@"type": anytype, id: anytype) @TypeOf(SPA_COMMAND_INIT_FULL(struct_spa_command, @import("std").zig.c_translation.sizeof(struct_spa_command_body), @"type", id)) { + _ = &@"type"; + _ = &id; + return SPA_COMMAND_INIT_FULL(struct_spa_command, @import("std").zig.c_translation.sizeof(struct_spa_command_body), @"type", id); +} +pub inline fn SPA_NODE_COMMAND_ID(cmd: anytype) @TypeOf(SPA_COMMAND_ID(cmd, SPA_TYPE_COMMAND_Node)) { + _ = &cmd; + return SPA_COMMAND_ID(cmd, SPA_TYPE_COMMAND_Node); +} +pub inline fn SPA_NODE_COMMAND_INIT(id: anytype) @TypeOf(SPA_COMMAND_INIT(SPA_TYPE_COMMAND_Node, id)) { + _ = &id; + return SPA_COMMAND_INIT(SPA_TYPE_COMMAND_Node, id); +} +pub const SPA_API_NODE = SPA_API_IMPL; +pub const SPA_TYPE_INTERFACE_Node = SPA_TYPE_INFO_INTERFACE_BASE ++ "Node"; +pub const SPA_VERSION_NODE = @as(c_int, 0); +pub const SPA_NODE_CHANGE_MASK_FLAGS = @as(c_uint, 1) << @as(c_int, 0); +pub const SPA_NODE_CHANGE_MASK_PROPS = @as(c_uint, 1) << @as(c_int, 1); +pub const SPA_NODE_CHANGE_MASK_PARAMS = @as(c_uint, 1) << @as(c_int, 2); +pub const SPA_NODE_FLAG_RT = @as(c_uint, 1) << @as(c_int, 0); +pub const SPA_NODE_FLAG_IN_DYNAMIC_PORTS = @as(c_uint, 1) << @as(c_int, 1); +pub const SPA_NODE_FLAG_OUT_DYNAMIC_PORTS = @as(c_uint, 1) << @as(c_int, 2); +pub const SPA_NODE_FLAG_IN_PORT_CONFIG = @as(c_uint, 1) << @as(c_int, 3); +pub const SPA_NODE_FLAG_OUT_PORT_CONFIG = @as(c_uint, 1) << @as(c_int, 4); +pub const SPA_NODE_FLAG_NEED_CONFIGURE = @as(c_uint, 1) << @as(c_int, 5); +pub const SPA_NODE_FLAG_ASYNC = @as(c_uint, 1) << @as(c_int, 6); +pub const SPA_NODE_INFO_INIT = @compileError("unable to translate C expr: unexpected token '}'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/node/node.h:76:9 +pub const SPA_PORT_CHANGE_MASK_FLAGS = @as(c_uint, 1) << @as(c_int, 0); +pub const SPA_PORT_CHANGE_MASK_RATE = @as(c_uint, 1) << @as(c_int, 1); +pub const SPA_PORT_CHANGE_MASK_PROPS = @as(c_uint, 1) << @as(c_int, 2); +pub const SPA_PORT_CHANGE_MASK_PARAMS = @as(c_uint, 1) << @as(c_int, 3); +pub const SPA_PORT_FLAG_REMOVABLE = @as(c_uint, 1) << @as(c_int, 0); +pub const SPA_PORT_FLAG_OPTIONAL = @as(c_uint, 1) << @as(c_int, 1); +pub const SPA_PORT_FLAG_CAN_ALLOC_BUFFERS = @as(c_uint, 1) << @as(c_int, 2); +pub const SPA_PORT_FLAG_IN_PLACE = @as(c_uint, 1) << @as(c_int, 3); +pub const SPA_PORT_FLAG_NO_REF = @as(c_uint, 1) << @as(c_int, 4); +pub const SPA_PORT_FLAG_LIVE = @as(c_uint, 1) << @as(c_int, 5); +pub const SPA_PORT_FLAG_PHYSICAL = @as(c_uint, 1) << @as(c_int, 6); +pub const SPA_PORT_FLAG_TERMINAL = @as(c_uint, 1) << @as(c_int, 7); +pub const SPA_PORT_FLAG_DYNAMIC_DATA = @as(c_uint, 1) << @as(c_int, 8); +pub const SPA_PORT_INFO_INIT = @compileError("unable to translate C expr: unexpected token '}'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/node/node.h:115:9 +pub const SPA_RESULT_TYPE_NODE_ERROR = @as(c_int, 1); +pub const SPA_RESULT_TYPE_NODE_PARAMS = @as(c_int, 2); +pub const SPA_NODE_EVENT_INFO = @as(c_int, 0); +pub const SPA_NODE_EVENT_PORT_INFO = @as(c_int, 1); +pub const SPA_NODE_EVENT_RESULT = @as(c_int, 2); +pub const SPA_NODE_EVENT_EVENT = @as(c_int, 3); +pub const SPA_NODE_EVENT_NUM = @as(c_int, 4); +pub const SPA_VERSION_NODE_EVENTS = @as(c_int, 0); +pub const SPA_NODE_CALLBACK_READY = @as(c_int, 0); +pub const SPA_NODE_CALLBACK_REUSE_BUFFER = @as(c_int, 1); +pub const SPA_NODE_CALLBACK_XRUN = @as(c_int, 2); +pub const SPA_NODE_CALLBACK_NUM = @as(c_int, 3); +pub const SPA_VERSION_NODE_CALLBACKS = @as(c_int, 0); +pub const SPA_NODE_PARAM_FLAG_TEST_ONLY = @as(c_int, 1) << @as(c_int, 0); +pub const SPA_NODE_PARAM_FLAG_FIXATE = @as(c_int, 1) << @as(c_int, 1); +pub const SPA_NODE_PARAM_FLAG_NEAREST = @as(c_int, 1) << @as(c_int, 2); +pub const SPA_NODE_BUFFERS_FLAG_ALLOC = @as(c_int, 1) << @as(c_int, 0); +pub const SPA_NODE_METHOD_ADD_LISTENER = @as(c_int, 0); +pub const SPA_NODE_METHOD_SET_CALLBACKS = @as(c_int, 1); +pub const SPA_NODE_METHOD_SYNC = @as(c_int, 2); +pub const SPA_NODE_METHOD_ENUM_PARAMS = @as(c_int, 3); +pub const SPA_NODE_METHOD_SET_PARAM = @as(c_int, 4); +pub const SPA_NODE_METHOD_SET_IO = @as(c_int, 5); +pub const SPA_NODE_METHOD_SEND_COMMAND = @as(c_int, 6); +pub const SPA_NODE_METHOD_ADD_PORT = @as(c_int, 7); +pub const SPA_NODE_METHOD_REMOVE_PORT = @as(c_int, 8); +pub const SPA_NODE_METHOD_PORT_ENUM_PARAMS = @as(c_int, 9); +pub const SPA_NODE_METHOD_PORT_SET_PARAM = @as(c_int, 10); +pub const SPA_NODE_METHOD_PORT_USE_BUFFERS = @as(c_int, 11); +pub const SPA_NODE_METHOD_PORT_SET_IO = @as(c_int, 12); +pub const SPA_NODE_METHOD_PORT_REUSE_BUFFER = @as(c_int, 13); +pub const SPA_NODE_METHOD_PROCESS = @as(c_int, 14); +pub const SPA_NODE_METHOD_NUM = @as(c_int, 15); +pub const SPA_VERSION_NODE_METHODS = @as(c_int, 0); +pub const PIPEWIRE_MEM_H = ""; +pub const PW_API_MEM = @compileError("unable to translate C expr: unexpected token 'static'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/mem.h:17:9 +pub const PW_VERSION_MEMPOOL_EVENTS = @as(c_int, 0); +pub const PW_MAP_RANGE_INIT = @compileError("unable to translate C expr: unexpected token '}'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/mem.h:178:9 +pub const PW_BUFFERS_FLAG_NONE = @as(c_int, 0); +pub const PW_BUFFERS_FLAG_NO_MEM = @as(c_int, 1) << @as(c_int, 0); +pub const PW_BUFFERS_FLAG_SHARED = @as(c_int, 1) << @as(c_int, 1); +pub const PW_BUFFERS_FLAG_DYNAMIC = @as(c_int, 1) << @as(c_int, 2); +pub const PW_BUFFERS_FLAG_IN_PRIORITY = @as(c_int, 1) << @as(c_int, 4); +pub const PW_BUFFERS_FLAG_ASYNC = @as(c_int, 1) << @as(c_int, 5); +pub const PIPEWIRE_FACTORY_H = ""; +pub const PW_TYPE_INTERFACE_Factory = PW_TYPE_INFO_INTERFACE_BASE ++ "Factory"; +pub const PW_FACTORY_PERM_MASK = PW_PERM_R | PW_PERM_M; +pub const PW_VERSION_FACTORY = @as(c_int, 3); +pub const PW_API_FACTORY_IMPL = @compileError("unable to translate C expr: unexpected token 'static'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/factory.h:36:9 +pub const PW_FACTORY_CHANGE_MASK_PROPS = @as(c_int, 1) << @as(c_int, 0); +pub const PW_FACTORY_CHANGE_MASK_ALL = (@as(c_int, 1) << @as(c_int, 1)) - @as(c_int, 1); +pub const PW_FACTORY_EVENT_INFO = @as(c_int, 0); +pub const PW_FACTORY_EVENT_NUM = @as(c_int, 1); +pub const PW_VERSION_FACTORY_EVENTS = @as(c_int, 0); +pub const PW_FACTORY_METHOD_ADD_LISTENER = @as(c_int, 0); +pub const PW_FACTORY_METHOD_NUM = @as(c_int, 1); +pub const PW_VERSION_FACTORY_METHODS = @as(c_int, 0); +pub const PIPEWIRE_KEYS_H = ""; +pub const PW_KEY_PROTOCOL = "pipewire.protocol"; +pub const PW_KEY_ACCESS = "pipewire.access"; +pub const PW_KEY_CLIENT_ACCESS = "pipewire.client.access"; +pub const PW_KEY_SEC_PID = "pipewire.sec.pid"; +pub const PW_KEY_SEC_UID = "pipewire.sec.uid"; +pub const PW_KEY_SEC_GID = "pipewire.sec.gid"; +pub const PW_KEY_SEC_LABEL = "pipewire.sec.label"; +pub const PW_KEY_SEC_SOCKET = "pipewire.sec.socket"; +pub const PW_KEY_SEC_ENGINE = "pipewire.sec.engine"; +pub const PW_KEY_SEC_APP_ID = "pipewire.sec.app-id"; +pub const PW_KEY_SEC_INSTANCE_ID = "pipewire.sec.instance-id"; +pub const PW_KEY_LIBRARY_NAME_SYSTEM = "library.name.system"; +pub const PW_KEY_LIBRARY_NAME_LOOP = "library.name.loop"; +pub const PW_KEY_LIBRARY_NAME_DBUS = "library.name.dbus"; +pub const PW_KEY_OBJECT_PATH = "object.path"; +pub const PW_KEY_OBJECT_ID = "object.id"; +pub const PW_KEY_OBJECT_SERIAL = "object.serial"; +pub const PW_KEY_OBJECT_LINGER = "object.linger"; +pub const PW_KEY_OBJECT_REGISTER = "object.register"; +pub const PW_KEY_OBJECT_EXPORT = "object.export"; +pub const PW_KEY_CONFIG_PREFIX = "config.prefix"; +pub const PW_KEY_CONFIG_NAME = "config.name"; +pub const PW_KEY_CONFIG_OVERRIDE_PREFIX = "config.override.prefix"; +pub const PW_KEY_CONFIG_OVERRIDE_NAME = "config.override.name"; +pub const PW_KEY_LOOP_NAME = "loop.name"; +pub const PW_KEY_LOOP_CLASS = "loop.class"; +pub const PW_KEY_LOOP_RT_PRIO = "loop.rt-prio"; +pub const PW_KEY_LOOP_CANCEL = "loop.cancel"; +pub const PW_KEY_CONTEXT_PROFILE_MODULES = "context.profile.modules"; +pub const PW_KEY_USER_NAME = "context.user-name"; +pub const PW_KEY_HOST_NAME = "context.host-name"; +pub const PW_KEY_CORE_NAME = "core.name"; +pub const PW_KEY_CORE_VERSION = "core.version"; +pub const PW_KEY_CORE_DAEMON = "core.daemon"; +pub const PW_KEY_CORE_ID = "core.id"; +pub const PW_KEY_CORE_MONITORS = "core.monitors"; +pub const PW_KEY_CPU_MAX_ALIGN = "cpu.max-align"; +pub const PW_KEY_CPU_CORES = "cpu.cores"; +pub const PW_KEY_PRIORITY_SESSION = "priority.session"; +pub const PW_KEY_PRIORITY_DRIVER = "priority.driver"; +pub const PW_KEY_REMOTE_NAME = "remote.name"; +pub const PW_KEY_REMOTE_INTENTION = "remote.intention"; +pub const PW_KEY_APP_NAME = "application.name"; +pub const PW_KEY_APP_ID = "application.id"; +pub const PW_KEY_APP_VERSION = "application.version"; +pub const PW_KEY_APP_ICON = "application.icon"; +pub const PW_KEY_APP_ICON_NAME = "application.icon-name"; +pub const PW_KEY_APP_LANGUAGE = "application.language"; +pub const PW_KEY_APP_PROCESS_ID = "application.process.id"; +pub const PW_KEY_APP_PROCESS_BINARY = "application.process.binary"; +pub const PW_KEY_APP_PROCESS_USER = "application.process.user"; +pub const PW_KEY_APP_PROCESS_HOST = "application.process.host"; +pub const PW_KEY_APP_PROCESS_MACHINE_ID = "application.process.machine-id"; +pub const PW_KEY_APP_PROCESS_SESSION_ID = "application.process.session-id"; +pub const PW_KEY_WINDOW_X11_DISPLAY = "window.x11.display"; +pub const PW_KEY_CLIENT_ID = "client.id"; +pub const PW_KEY_CLIENT_NAME = "client.name"; +pub const PW_KEY_CLIENT_API = "client.api"; +pub const PW_KEY_NODE_ID = "node.id"; +pub const PW_KEY_NODE_NAME = "node.name"; +pub const PW_KEY_NODE_NICK = "node.nick"; +pub const PW_KEY_NODE_DESCRIPTION = "node.description"; +pub const PW_KEY_NODE_PLUGGED = "node.plugged"; +pub const PW_KEY_NODE_SESSION = "node.session"; +pub const PW_KEY_NODE_GROUP = "node.group"; +pub const PW_KEY_NODE_SYNC_GROUP = "node.sync-group"; +pub const PW_KEY_NODE_SYNC = "node.sync"; +pub const PW_KEY_NODE_TRANSPORT = "node.transport"; +pub const PW_KEY_NODE_EXCLUSIVE = "node.exclusive"; +pub const PW_KEY_NODE_AUTOCONNECT = "node.autoconnect"; +pub const PW_KEY_NODE_LATENCY = "node.latency"; +pub const PW_KEY_NODE_MAX_LATENCY = "node.max-latency"; +pub const PW_KEY_NODE_LOCK_QUANTUM = "node.lock-quantum"; +pub const PW_KEY_NODE_FORCE_QUANTUM = "node.force-quantum"; +pub const PW_KEY_NODE_RATE = "node.rate"; +pub const PW_KEY_NODE_LOCK_RATE = "node.lock-rate"; +pub const PW_KEY_NODE_FORCE_RATE = "node.force-rate"; +pub const PW_KEY_NODE_DONT_RECONNECT = "node.dont-reconnect"; +pub const PW_KEY_NODE_ALWAYS_PROCESS = "node.always-process"; +pub const PW_KEY_NODE_WANT_DRIVER = "node.want-driver"; +pub const PW_KEY_NODE_PAUSE_ON_IDLE = "node.pause-on-idle"; +pub const PW_KEY_NODE_SUSPEND_ON_IDLE = "node.suspend-on-idle"; +pub const PW_KEY_NODE_CACHE_PARAMS = "node.cache-params"; +pub const PW_KEY_NODE_TRANSPORT_SYNC = "node.transport.sync"; +pub const PW_KEY_NODE_DRIVER = "node.driver"; +pub const PW_KEY_NODE_SUPPORTS_LAZY = "node.supports-lazy"; +pub const PW_KEY_NODE_SUPPORTS_REQUEST = "node.supports-request"; +pub const PW_KEY_NODE_DRIVER_ID = "node.driver-id"; +pub const PW_KEY_NODE_ASYNC = "node.async"; +pub const PW_KEY_NODE_LOOP_NAME = "node.loop.name"; +pub const PW_KEY_NODE_LOOP_CLASS = "node.loop.class"; +pub const PW_KEY_NODE_STREAM = "node.stream"; +pub const PW_KEY_NODE_VIRTUAL = "node.virtual"; +pub const PW_KEY_NODE_PASSIVE = "node.passive"; +pub const PW_KEY_NODE_LINK_GROUP = "node.link-group"; +pub const PW_KEY_NODE_NETWORK = "node.network"; +pub const PW_KEY_NODE_TRIGGER = "node.trigger"; +pub const PW_KEY_NODE_CHANNELNAMES = "node.channel-names"; +pub const PW_KEY_NODE_DEVICE_PORT_NAME_PREFIX = "node.device-port-name-prefix"; +pub const PW_KEY_NODE_PHYSICAL = "node.physical"; +pub const PW_KEY_NODE_TERMINAL = "node.terminal"; +pub const PW_KEY_NODE_RELIABLE = "node.reliable"; +pub const PW_KEY_PORT_ID = "port.id"; +pub const PW_KEY_PORT_NAME = "port.name"; +pub const PW_KEY_PORT_DIRECTION = "port.direction"; +pub const PW_KEY_PORT_ALIAS = "port.alias"; +pub const PW_KEY_PORT_PHYSICAL = "port.physical"; +pub const PW_KEY_PORT_TERMINAL = "port.terminal"; +pub const PW_KEY_PORT_CONTROL = "port.control"; +pub const PW_KEY_PORT_MONITOR = "port.monitor"; +pub const PW_KEY_PORT_CACHE_PARAMS = "port.cache-params"; +pub const PW_KEY_PORT_EXTRA = "port.extra"; +pub const PW_KEY_PORT_PASSIVE = "port.passive"; +pub const PW_KEY_PORT_IGNORE_LATENCY = "port.ignore-latency"; +pub const PW_KEY_PORT_GROUP = "port.group"; +pub const PW_KEY_PORT_EXCLUSIVE = "port.exclusive"; +pub const PW_KEY_PORT_RELIABLE = "port.reliable"; +pub const PW_KEY_LINK_ID = "link.id"; +pub const PW_KEY_LINK_INPUT_NODE = "link.input.node"; +pub const PW_KEY_LINK_INPUT_PORT = "link.input.port"; +pub const PW_KEY_LINK_OUTPUT_NODE = "link.output.node"; +pub const PW_KEY_LINK_OUTPUT_PORT = "link.output.port"; +pub const PW_KEY_LINK_PASSIVE = "link.passive"; +pub const PW_KEY_LINK_FEEDBACK = "link.feedback"; +pub const PW_KEY_LINK_ASYNC = "link.async"; +pub const PW_KEY_DEVICE_ID = "device.id"; +pub const PW_KEY_DEVICE_NAME = "device.name"; +pub const PW_KEY_DEVICE_PLUGGED = "device.plugged"; +pub const PW_KEY_DEVICE_NICK = "device.nick"; +pub const PW_KEY_DEVICE_STRING = "device.string"; +pub const PW_KEY_DEVICE_API = "device.api"; +pub const PW_KEY_DEVICE_DESCRIPTION = "device.description"; +pub const PW_KEY_DEVICE_BUS_PATH = "device.bus-path"; +pub const PW_KEY_DEVICE_SERIAL = "device.serial"; +pub const PW_KEY_DEVICE_VENDOR_ID = "device.vendor.id"; +pub const PW_KEY_DEVICE_VENDOR_NAME = "device.vendor.name"; +pub const PW_KEY_DEVICE_PRODUCT_ID = "device.product.id"; +pub const PW_KEY_DEVICE_PRODUCT_NAME = "device.product.name"; +pub const PW_KEY_DEVICE_CLASS = "device.class"; +pub const PW_KEY_DEVICE_FORM_FACTOR = "device.form-factor"; +pub const PW_KEY_DEVICE_BUS = "device.bus"; +pub const PW_KEY_DEVICE_SUBSYSTEM = "device.subsystem"; +pub const PW_KEY_DEVICE_SYSFS_PATH = "device.sysfs.path"; +pub const PW_KEY_DEVICE_ICON = "device.icon"; +pub const PW_KEY_DEVICE_ICON_NAME = "device.icon-name"; +pub const PW_KEY_DEVICE_INTENDED_ROLES = "device.intended-roles"; +pub const PW_KEY_DEVICE_CACHE_PARAMS = "device.cache-params"; +pub const PW_KEY_MODULE_ID = "module.id"; +pub const PW_KEY_MODULE_NAME = "module.name"; +pub const PW_KEY_MODULE_AUTHOR = "module.author"; +pub const PW_KEY_MODULE_DESCRIPTION = "module.description"; +pub const PW_KEY_MODULE_USAGE = "module.usage"; +pub const PW_KEY_MODULE_VERSION = "module.version"; +pub const PW_KEY_MODULE_DEPRECATED = "module.deprecated"; +pub const PW_KEY_FACTORY_ID = "factory.id"; +pub const PW_KEY_FACTORY_NAME = "factory.name"; +pub const PW_KEY_FACTORY_USAGE = "factory.usage"; +pub const PW_KEY_FACTORY_TYPE_NAME = "factory.type.name"; +pub const PW_KEY_FACTORY_TYPE_VERSION = "factory.type.version"; +pub const PW_KEY_STREAM_IS_LIVE = "stream.is-live"; +pub const PW_KEY_STREAM_LATENCY_MIN = "stream.latency.min"; +pub const PW_KEY_STREAM_LATENCY_MAX = "stream.latency.max"; +pub const PW_KEY_STREAM_MONITOR = "stream.monitor"; +pub const PW_KEY_STREAM_DONT_REMIX = "stream.dont-remix"; +pub const PW_KEY_STREAM_CAPTURE_SINK = "stream.capture.sink"; +pub const PW_KEY_MEDIA_TYPE = "media.type"; +pub const PW_KEY_MEDIA_CATEGORY = "media.category"; +pub const PW_KEY_MEDIA_ROLE = "media.role"; +pub const PW_KEY_MEDIA_CLASS = "media.class"; +pub const PW_KEY_MEDIA_NAME = "media.name"; +pub const PW_KEY_MEDIA_TITLE = "media.title"; +pub const PW_KEY_MEDIA_ARTIST = "media.artist"; +pub const PW_KEY_MEDIA_ALBUM = "media.album"; +pub const PW_KEY_MEDIA_COPYRIGHT = "media.copyright"; +pub const PW_KEY_MEDIA_SOFTWARE = "media.software"; +pub const PW_KEY_MEDIA_LANGUAGE = "media.language"; +pub const PW_KEY_MEDIA_FILENAME = "media.filename"; +pub const PW_KEY_MEDIA_ICON = "media.icon"; +pub const PW_KEY_MEDIA_ICON_NAME = "media.icon-name"; +pub const PW_KEY_MEDIA_COMMENT = "media.comment"; +pub const PW_KEY_MEDIA_DATE = "media.date"; +pub const PW_KEY_MEDIA_FORMAT = "media.format"; +pub const PW_KEY_FORMAT_DSP = "format.dsp"; +pub const PW_KEY_AUDIO_CHANNEL = "audio.channel"; +pub const PW_KEY_AUDIO_RATE = "audio.rate"; +pub const PW_KEY_AUDIO_CHANNELS = "audio.channels"; +pub const PW_KEY_AUDIO_FORMAT = "audio.format"; +pub const PW_KEY_AUDIO_ALLOWED_RATES = "audio.allowed-rates"; +pub const PW_KEY_VIDEO_RATE = "video.framerate"; +pub const PW_KEY_VIDEO_FORMAT = "video.format"; +pub const PW_KEY_VIDEO_SIZE = "video.size"; +pub const PW_KEY_TARGET_OBJECT = "target.object"; +pub const PW_KEY_PRIORITY_MASTER = PW_DEPRECATED("priority.master"); +pub const PW_KEY_NODE_TARGET = PW_DEPRECATED("node.target"); +pub const PW_KEY_LOOP_RETRY_TIMEOUT = PW_DEPRECATED("loop.retry-timeout"); +pub const PIPEWIRE_LOG_H = ""; +pub const SPA_LOG_H = ""; +pub const SPA_API_LOG = SPA_API_IMPL; +pub const SPA_LOG_TOPIC_DEFAULT = NULL; +pub const SPA_TYPE_INTERFACE_Log = SPA_TYPE_INFO_INTERFACE_BASE ++ "Log"; +pub const SPA_VERSION_LOG = @as(c_int, 0); +pub const SPA_VERSION_LOG_TOPIC = @as(c_int, 0); +pub const SPA_VERSION_LOG_TOPIC_ENUM = @as(c_int, 0); +pub const SPA_VERSION_LOG_METHODS = @as(c_int, 1); +pub inline fn SPA_LOG_TOPIC(v: anytype, t: anytype) struct_spa_log_topic { + _ = &v; + _ = &t; + return @import("std").mem.zeroInit(struct_spa_log_topic, .{ + .version = v, + .topic = t, + }); +} +pub const spa_log_logt = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:250:9 +pub const spa_logt_lev = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:283:9 +pub const spa_log_lev = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:286:9 +pub const spa_log_log = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:289:9 +pub const spa_log_logv = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:292:9 +pub const spa_log_error = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:295:9 +pub const spa_log_warn = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:296:9 +pub const spa_log_info = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:297:9 +pub const spa_log_debug = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:298:9 +pub const spa_log_trace = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:299:9 +pub const spa_logt_error = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:301:9 +pub const spa_logt_warn = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:302:9 +pub const spa_logt_info = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:303:9 +pub const spa_logt_debug = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:304:9 +pub const spa_logt_trace = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:305:9 +pub const spa_log_trace_fp = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:308:9 +pub const SPA_LOG_TOPIC_ENUM_NAME = "spa_log_topic_enum"; +pub const SPA_LOG_TOPIC_ENUM_DEFINE = @compileError("unable to translate C expr: unexpected token 'struct'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:327:9 +pub const SPA_LOG_TOPIC_REGISTER = @compileError("unable to translate macro: undefined identifier `used`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:340:9 +pub const SPA_LOG_TOPIC_DEFINE = @compileError("unable to translate C expr: unexpected token '='"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:350:9 +pub const SPA_LOG_TOPIC_DEFINE_STATIC = @compileError("unable to translate C expr: unexpected token 'static'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:359:9 +pub const SPA_LOG_TOPIC_ENUM_DEFINE_REGISTERED = @compileError("unable to translate macro: undefined identifier `__start_spa_log_topic`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/support/log.h:369:9 +pub const SPA_KEY_LOG_LEVEL = "log.level"; +pub const SPA_KEY_LOG_COLORS = "log.colors"; +pub const SPA_KEY_LOG_FILE = "log.file"; +pub const SPA_KEY_LOG_TIMESTAMP = "log.timestamp"; +pub const SPA_KEY_LOG_LINE = "log.line"; +pub const SPA_KEY_LOG_PATTERNS = "log.patterns"; +pub const PW_LOG_TOPIC_DEFINE_STATIC = @compileError("unable to translate macro: undefined identifier `constructor`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:89:9 +pub const PW_LOG_TOPIC_STATIC = @compileError("unable to translate macro: undefined identifier `_value`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:108:9 +pub const PW_LOG_TOPIC_EXTERN = @compileError("unable to translate C expr: unexpected token 'extern'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:116:9 +pub const PW_LOG_TOPIC = @compileError("unable to translate macro: undefined identifier `_value`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:123:9 +pub const PW_LOG_TOPIC_INIT = @compileError("unable to translate C expr: unexpected token ';'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:132:9 +pub inline fn pw_log_level_enabled(lev: anytype) @TypeOf(pw_log_level >= lev) { + _ = &lev; + return pw_log_level >= lev; +} +pub inline fn pw_log_topic_enabled(lev: anytype, t: anytype) @TypeOf(if ((t != 0) and (t.*.has_custom_level != 0)) t.*.level >= lev else pw_log_level_enabled(lev)) { + _ = &lev; + _ = &t; + return if ((t != 0) and (t.*.has_custom_level != 0)) t.*.level >= lev else pw_log_level_enabled(lev); +} +pub inline fn pw_log_topic_custom_enabled(lev: anytype, t: anytype) @TypeOf(((t != 0) and (t.*.has_custom_level != 0)) and (t.*.level >= lev)) { + _ = &lev; + _ = &t; + return ((t != 0) and (t.*.has_custom_level != 0)) and (t.*.level >= lev); +} +pub const pw_logtv = @compileError("unable to translate macro: undefined identifier `__FILE__`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:159:9 +pub const pw_logt = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:165:9 +pub const pw_log = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:171:9 +pub const pw_log_error = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:173:9 +pub const pw_log_warn = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:174:9 +pub const pw_log_info = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:175:9 +pub const pw_log_debug = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:176:9 +pub const pw_log_trace = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:177:9 +pub const pw_logt_error = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:179:9 +pub const pw_logt_warn = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:180:9 +pub const pw_logt_info = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:181:9 +pub const pw_logt_debug = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:182:9 +pub const pw_logt_trace = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:183:9 +pub const pw_log_trace_fp = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/log.h:186:9 +pub const PIPEWIRE_LINK_H = ""; +pub const PW_TYPE_INTERFACE_Link = PW_TYPE_INFO_INTERFACE_BASE ++ "Link"; +pub const PW_LINK_PERM_MASK = PW_PERM_R | PW_PERM_X; +pub const PW_VERSION_LINK = @as(c_int, 3); +pub const PW_API_LINK_IMPL = @compileError("unable to translate C expr: unexpected token 'static'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/link.h:40:9 +pub const PW_LINK_CHANGE_MASK_STATE = @as(c_int, 1) << @as(c_int, 0); +pub const PW_LINK_CHANGE_MASK_FORMAT = @as(c_int, 1) << @as(c_int, 1); +pub const PW_LINK_CHANGE_MASK_PROPS = @as(c_int, 1) << @as(c_int, 2); +pub const PW_LINK_CHANGE_MASK_ALL = (@as(c_int, 1) << @as(c_int, 3)) - @as(c_int, 1); +pub const PW_LINK_EVENT_INFO = @as(c_int, 0); +pub const PW_LINK_EVENT_NUM = @as(c_int, 1); +pub const PW_VERSION_LINK_EVENTS = @as(c_int, 0); +pub const PW_LINK_METHOD_ADD_LISTENER = @as(c_int, 0); +pub const PW_LINK_METHOD_NUM = @as(c_int, 1); +pub const PW_VERSION_LINK_METHODS = @as(c_int, 0); +pub const PIPEWIRE_MAIN_LOOP_H = ""; +pub const PW_VERSION_MAIN_LOOP_EVENTS = @as(c_int, 0); +pub const PIPEWIRE_MAP_H = ""; +pub const PW_API_MAP = @compileError("unable to translate C expr: unexpected token 'static'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/map.h:19:9 +pub inline fn PW_MAP_INIT(extend: anytype) struct_pw_map { + _ = &extend; + return @import("std").mem.zeroInit(struct_pw_map, .{ PW_ARRAY_INIT(extend), SPA_ID_INVALID }); +} +pub inline fn pw_map_get_size(m: anytype) @TypeOf(pw_array_get_len(&m.*.items, union_pw_map_item)) { + _ = &m; + return pw_array_get_len(&m.*.items, union_pw_map_item); +} +pub inline fn pw_map_get_item(m: anytype, id: anytype) @TypeOf(pw_array_get_unchecked(&m.*.items, id, union_pw_map_item)) { + _ = &m; + _ = &id; + return pw_array_get_unchecked(&m.*.items, id, union_pw_map_item); +} +pub inline fn pw_map_item_is_free(item: anytype) @TypeOf(item.*.next & @as(c_int, 0x1)) { + _ = &item; + return item.*.next & @as(c_int, 0x1); +} +pub inline fn pw_map_id_is_free(m: anytype, id: anytype) @TypeOf(pw_map_item_is_free(pw_map_get_item(m, id))) { + _ = &m; + _ = &id; + return pw_map_item_is_free(pw_map_get_item(m, id)); +} +pub inline fn pw_map_check_id(m: anytype, id: anytype) @TypeOf(id < pw_map_get_size(m)) { + _ = &m; + _ = &id; + return id < pw_map_get_size(m); +} +pub inline fn pw_map_has_item(m: anytype, id: anytype) @TypeOf((pw_map_check_id(m, id) != 0) and !(pw_map_id_is_free(m, id) != 0)) { + _ = &m; + _ = &id; + return (pw_map_check_id(m, id) != 0) and !(pw_map_id_is_free(m, id) != 0); +} +pub inline fn pw_map_lookup_unchecked(m: anytype, id: anytype) @TypeOf(pw_map_get_item(m, id).*.data) { + _ = &m; + _ = &id; + return pw_map_get_item(m, id).*.data; +} +pub inline fn PW_MAP_ID_TO_PTR(id: anytype) @TypeOf(SPA_UINT32_TO_PTR(id << @as(c_int, 1))) { + _ = &id; + return SPA_UINT32_TO_PTR(id << @as(c_int, 1)); +} +pub inline fn PW_MAP_PTR_TO_ID(p: anytype) @TypeOf(SPA_PTR_TO_UINT32(p) >> @as(c_int, 1)) { + _ = &p; + return SPA_PTR_TO_UINT32(p) >> @as(c_int, 1); +} +pub const PIPEWIRE_MODULE_H = ""; +pub const PW_TYPE_INTERFACE_Module = PW_TYPE_INFO_INTERFACE_BASE ++ "Module"; +pub const PW_MODULE_PERM_MASK = PW_PERM_R | PW_PERM_M; +pub const PW_VERSION_MODULE = @as(c_int, 3); +pub const PW_API_MODULE_IMPL = @compileError("unable to translate C expr: unexpected token 'static'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/module.h:33:9 +pub const PW_MODULE_CHANGE_MASK_PROPS = @as(c_int, 1) << @as(c_int, 0); +pub const PW_MODULE_CHANGE_MASK_ALL = (@as(c_int, 1) << @as(c_int, 1)) - @as(c_int, 1); +pub const PW_MODULE_EVENT_INFO = @as(c_int, 0); +pub const PW_MODULE_EVENT_NUM = @as(c_int, 1); +pub const PW_VERSION_MODULE_EVENTS = @as(c_int, 0); +pub const PW_MODULE_METHOD_ADD_LISTENER = @as(c_int, 0); +pub const PW_MODULE_METHOD_NUM = @as(c_int, 1); +pub const PW_VERSION_MODULE_METHODS = @as(c_int, 0); +pub const PIPEWIRE_NODE_H = ""; +pub const PW_TYPE_INTERFACE_Node = PW_TYPE_INFO_INTERFACE_BASE ++ "Node"; +pub const PW_NODE_PERM_MASK = PW_PERM_RWXML; +pub const PW_VERSION_NODE = @as(c_int, 3); +pub const PW_API_NODE_IMPL = @compileError("unable to translate C expr: unexpected token 'static'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/node.h:38:9 +pub const PW_NODE_CHANGE_MASK_INPUT_PORTS = @as(c_int, 1) << @as(c_int, 0); +pub const PW_NODE_CHANGE_MASK_OUTPUT_PORTS = @as(c_int, 1) << @as(c_int, 1); +pub const PW_NODE_CHANGE_MASK_STATE = @as(c_int, 1) << @as(c_int, 2); +pub const PW_NODE_CHANGE_MASK_PROPS = @as(c_int, 1) << @as(c_int, 3); +pub const PW_NODE_CHANGE_MASK_PARAMS = @as(c_int, 1) << @as(c_int, 4); +pub const PW_NODE_CHANGE_MASK_ALL = (@as(c_int, 1) << @as(c_int, 5)) - @as(c_int, 1); +pub const PW_NODE_EVENT_INFO = @as(c_int, 0); +pub const PW_NODE_EVENT_PARAM = @as(c_int, 1); +pub const PW_NODE_EVENT_NUM = @as(c_int, 2); +pub const PW_VERSION_NODE_EVENTS = @as(c_int, 0); +pub const PW_NODE_METHOD_ADD_LISTENER = @as(c_int, 0); +pub const PW_NODE_METHOD_SUBSCRIBE_PARAMS = @as(c_int, 1); +pub const PW_NODE_METHOD_ENUM_PARAMS = @as(c_int, 2); +pub const PW_NODE_METHOD_SET_PARAM = @as(c_int, 3); +pub const PW_NODE_METHOD_SEND_COMMAND = @as(c_int, 4); +pub const PW_NODE_METHOD_NUM = @as(c_int, 5); +pub const PW_VERSION_NODE_METHODS = @as(c_int, 0); +pub const PIPEWIRE_PORT_H = ""; +pub const PW_TYPE_INTERFACE_Port = PW_TYPE_INFO_INTERFACE_BASE ++ "Port"; +pub const PW_PORT_PERM_MASK = (PW_PERM_R | PW_PERM_X) | PW_PERM_M; +pub const PW_VERSION_PORT = @as(c_int, 3); +pub const PW_API_PORT_IMPL = @compileError("unable to translate C expr: unexpected token 'static'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/pipewire/port.h:38:9 +pub const pw_direction = spa_direction; +pub const PW_DIRECTION_INPUT = SPA_DIRECTION_INPUT; +pub const PW_DIRECTION_OUTPUT = SPA_DIRECTION_OUTPUT; +pub const PW_PORT_CHANGE_MASK_PROPS = @as(c_int, 1) << @as(c_int, 0); +pub const PW_PORT_CHANGE_MASK_PARAMS = @as(c_int, 1) << @as(c_int, 1); +pub const PW_PORT_CHANGE_MASK_ALL = (@as(c_int, 1) << @as(c_int, 2)) - @as(c_int, 1); +pub const PW_PORT_EVENT_INFO = @as(c_int, 0); +pub const PW_PORT_EVENT_PARAM = @as(c_int, 1); +pub const PW_PORT_EVENT_NUM = @as(c_int, 2); +pub const PW_VERSION_PORT_EVENTS = @as(c_int, 0); +pub const PW_PORT_METHOD_ADD_LISTENER = @as(c_int, 0); +pub const PW_PORT_METHOD_SUBSCRIBE_PARAMS = @as(c_int, 1); +pub const PW_PORT_METHOD_ENUM_PARAMS = @as(c_int, 2); +pub const PW_PORT_METHOD_NUM = @as(c_int, 3); +pub const PW_VERSION_PORT_METHODS = @as(c_int, 0); +pub const PIPEWIRE_STREAM_H = ""; +pub const PW_VERSION_STREAM_EVENTS = @as(c_int, 2); +pub const PIPEWIRE_FILTER_H = ""; +pub const SPA_IO_H = ""; +pub const SPA_STATUS_OK = @as(c_int, 0); +pub const SPA_STATUS_NEED_DATA = @as(c_int, 1) << @as(c_int, 0); +pub const SPA_STATUS_HAVE_DATA = @as(c_int, 1) << @as(c_int, 1); +pub const SPA_STATUS_STOPPED = @as(c_int, 1) << @as(c_int, 2); +pub const SPA_STATUS_DRAINED = @as(c_int, 1) << @as(c_int, 3); +pub const SPA_IO_BUFFERS_INIT = @compileError("unable to translate C expr: unexpected token '}'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/node/io.h:85:9 +pub const SPA_IO_MEMORY_INIT = @compileError("unable to translate C expr: unexpected token '}'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/node/io.h:95:9 +pub const SPA_IO_CLOCK_FLAG_FREEWHEEL = @as(c_uint, 1) << @as(c_int, 0); +pub const SPA_IO_CLOCK_FLAG_XRUN_RECOVER = @as(c_uint, 1) << @as(c_int, 1); +pub const SPA_IO_CLOCK_FLAG_LAZY = @as(c_uint, 1) << @as(c_int, 2); +pub const SPA_IO_CLOCK_FLAG_NO_RATE = @as(c_uint, 1) << @as(c_int, 3); +pub const SPA_IO_CLOCK_FLAG_DISCONT = @as(c_uint, 1) << @as(c_int, 4); +pub const SPA_IO_VIDEO_SIZE_VALID = @as(c_int, 1) << @as(c_int, 0); +pub const SPA_IO_SEGMENT_BAR_FLAG_VALID = @as(c_int, 1) << @as(c_int, 0); +pub const SPA_IO_SEGMENT_VIDEO_FLAG_VALID = @as(c_int, 1) << @as(c_int, 0); +pub const SPA_IO_SEGMENT_VIDEO_FLAG_DROP_FRAME = @as(c_int, 1) << @as(c_int, 1); +pub const SPA_IO_SEGMENT_VIDEO_FLAG_PULL_DOWN = @as(c_int, 1) << @as(c_int, 2); +pub const SPA_IO_SEGMENT_VIDEO_FLAG_INTERLACED = @as(c_int, 1) << @as(c_int, 3); +pub const SPA_IO_SEGMENT_FLAG_LOOPING = @as(c_int, 1) << @as(c_int, 0); +pub const SPA_IO_SEGMENT_FLAG_NO_POSITION = @as(c_int, 1) << @as(c_int, 1); +pub const SPA_IO_POSITION_MAX_SEGMENTS = @as(c_int, 8); +pub const SPA_IO_RATE_MATCH_FLAG_ACTIVE = @as(c_int, 1) << @as(c_int, 0); +pub const PW_VERSION_FILTER_EVENTS = @as(c_int, 1); +pub const PIPEWIRE_THREAD_LOOP_H = ""; +pub const PW_VERSION_THREAD_LOOP_EVENTS = @as(c_int, 0); +pub const PIPEWIRE_DATA_LOOP_H = ""; +pub const SPA_THREAD_H = ""; +pub const SPA_API_THREAD = SPA_API_IMPL; +pub const SPA_TYPE_INFO_Thread = SPA_TYPE_INFO_POINTER_BASE ++ "Thread"; +pub const SPA_TYPE_INTERFACE_ThreadUtils = SPA_TYPE_INFO_INTERFACE_BASE ++ "ThreadUtils"; +pub const SPA_VERSION_THREAD_UTILS = @as(c_int, 0); +pub const SPA_VERSION_THREAD_UTILS_METHODS = @as(c_int, 0); +pub const SPA_KEY_THREAD_NAME = "thread.name"; +pub const SPA_KEY_THREAD_STACK_SIZE = "thread.stack-size"; +pub const SPA_KEY_THREAD_AFFINITY = "thread.affinity"; +pub const SPA_KEY_THREAD_CREATOR = "thread.creator"; +pub const PW_VERSION_DATA_LOOP_EVENTS = @as(c_int, 0); +pub const PIPEWIRE_TIMER_QUEUE_H = ""; +pub const PIPEWIRE_VERSION_H = ""; +pub inline fn pw_get_headers_version() @TypeOf("1.5.81") { + return "1.5.81"; +} +pub const PW_API_VERSION = @as(f64, 0.3); +pub const PW_MAJOR = @as(c_int, 1); +pub const PW_MINOR = @as(c_int, 5); +pub const PW_MICRO = @as(c_int, 81); +pub inline fn PW_CHECK_VERSION(major: anytype, minor: anytype, micro: anytype) @TypeOf(((PW_MAJOR > major) or ((PW_MAJOR == major) and (PW_MINOR > minor))) or (((PW_MAJOR == major) and (PW_MINOR == minor)) and (PW_MICRO >= micro))) { + _ = &major; + _ = &minor; + _ = µ + return ((PW_MAJOR > major) or ((PW_MAJOR == major) and (PW_MINOR > minor))) or (((PW_MAJOR == major) and (PW_MINOR == minor)) and (PW_MICRO >= micro)); +} +pub const SPA_PARAM_VIDEO_FORMAT_UTILS_H = ""; +pub const SPA_PARAM_FORMAT_UTILS_H = ""; +pub const SPA_POD_PARSER_H = ""; +pub const SPA_POD_BODY_H = ""; +pub const SPA_ATOMIC_H = ""; +pub const SPA_ATOMIC_CAS = @compileError("unable to translate macro: undefined identifier `__ov`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/atomic.h:12:9 +pub const SPA_ATOMIC_DEC = @compileError("unable to translate macro: undefined identifier `__atomic_sub_fetch`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/atomic.h:19:9 +pub const SPA_ATOMIC_INC = @compileError("unable to translate macro: undefined identifier `__atomic_add_fetch`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/atomic.h:20:9 +pub const SPA_ATOMIC_LOAD = @compileError("unable to translate macro: undefined identifier `__atomic_load_n`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/atomic.h:21:9 +pub const SPA_LOAD_ONCE = @compileError("unable to translate macro: undefined identifier `__atomic_load_n`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/atomic.h:22:9 +pub const SPA_STORE_ONCE = @compileError("unable to translate macro: undefined identifier `__atomic_store_n`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/atomic.h:23:9 +pub const SPA_ATOMIC_STORE = @compileError("unable to translate macro: undefined identifier `__atomic_store_n`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/atomic.h:24:9 +pub const SPA_ATOMIC_XCHG = @compileError("unable to translate macro: undefined identifier `__atomic_exchange_n`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/atomic.h:25:9 +pub inline fn SPA_SEQ_WRITE(s: anytype) @TypeOf(SPA_ATOMIC_INC(s)) { + _ = &s; + return SPA_ATOMIC_INC(s); +} +pub inline fn SPA_SEQ_WRITE_SUCCESS(s1: anytype, s2: anytype) @TypeOf(((s1 + @as(c_int, 1)) == s2) and ((s2 & @as(c_int, 1)) == @as(c_int, 0))) { + _ = &s1; + _ = &s2; + return ((s1 + @as(c_int, 1)) == s2) and ((s2 & @as(c_int, 1)) == @as(c_int, 0)); +} +pub inline fn SPA_SEQ_READ(s: anytype) @TypeOf(SPA_ATOMIC_LOAD(s)) { + _ = &s; + return SPA_ATOMIC_LOAD(s); +} +pub inline fn SPA_SEQ_READ_SUCCESS(s1: anytype, s2: anytype) @TypeOf((s1 == s2) and ((s2 & @as(c_int, 1)) == @as(c_int, 0))) { + _ = &s1; + _ = &s2; + return (s1 == s2) and ((s2 & @as(c_int, 1)) == @as(c_int, 0)); +} +pub const SPA_API_POD_BODY = SPA_API_IMPL; +pub const SPA_POD_BODY_LOAD_ONCE = @compileError("unable to translate C expr: expected ')' instead got '='"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:109:9 +pub const SPA_POD_BODY_LOAD_FIELD_ONCE = @compileError("unable to translate C expr: expected ')' instead got '='"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/body.h:110:9 +pub const SPA_POD_VARARG_H = ""; +pub const SPA_POD_Prop = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/vararg.h:21:9 +pub const SPA_POD_Propf = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/vararg.h:23:9 +pub const SPA_POD_Control = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/vararg.h:26:9 +pub inline fn SPA_CHOICE_RANGE(def: anytype, min: anytype, max: anytype) @TypeOf(max) { + _ = &def; + _ = &min; + _ = &max; + return blk: { + _ = @as(c_int, 3); + _ = &def; + _ = &min; + break :blk max; + }; +} +pub inline fn SPA_CHOICE_STEP(def: anytype, min: anytype, max: anytype, step: anytype) @TypeOf(step) { + _ = &def; + _ = &min; + _ = &max; + _ = &step; + return blk: { + _ = @as(c_int, 4); + _ = &def; + _ = &min; + _ = &max; + break :blk step; + }; +} +pub const SPA_CHOICE_ENUM = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/vararg.h:31:9 +pub inline fn SPA_CHOICE_FLAGS(flags: anytype) @TypeOf(flags) { + _ = &flags; + return blk: { + _ = @as(c_int, 1); + break :blk flags; + }; +} +pub inline fn SPA_CHOICE_FEATURES(features: anytype) @TypeOf(features) { + _ = &features; + return blk: { + _ = @as(c_int, 1); + break :blk features; + }; +} +pub inline fn SPA_CHOICE_BOOL(def: anytype) @TypeOf(!(def != 0)) { + _ = &def; + return blk: { + _ = @as(c_int, 3); + _ = &def; + _ = &def; + break :blk !(def != 0); + }; +} +pub inline fn SPA_POD_Bool(val: anytype) @TypeOf(val) { + _ = &val; + return blk: { + _ = "b"; + break :blk val; + }; +} +pub inline fn SPA_POD_CHOICE_Bool(def: anytype) @TypeOf(SPA_CHOICE_BOOL(def)) { + _ = &def; + return blk: { + _ = "?eb"; + break :blk SPA_CHOICE_BOOL(def); + }; +} +pub inline fn SPA_POD_Id(val: anytype) @TypeOf(val) { + _ = &val; + return blk: { + _ = "I"; + break :blk val; + }; +} +pub const SPA_POD_CHOICE_ENUM_Id = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/vararg.h:40:9 +pub inline fn SPA_POD_Int(val: anytype) @TypeOf(val) { + _ = &val; + return blk: { + _ = "i"; + break :blk val; + }; +} +pub const SPA_POD_CHOICE_ENUM_Int = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/vararg.h:43:9 +pub inline fn SPA_POD_CHOICE_RANGE_Int(def: anytype, min: anytype, max: anytype) @TypeOf(SPA_CHOICE_RANGE(def, min, max)) { + _ = &def; + _ = &min; + _ = &max; + return blk: { + _ = "?ri"; + break :blk SPA_CHOICE_RANGE(def, min, max); + }; +} +pub inline fn SPA_POD_CHOICE_STEP_Int(def: anytype, min: anytype, max: anytype, step: anytype) @TypeOf(SPA_CHOICE_STEP(def, min, max, step)) { + _ = &def; + _ = &min; + _ = &max; + _ = &step; + return blk: { + _ = "?si"; + break :blk SPA_CHOICE_STEP(def, min, max, step); + }; +} +pub inline fn SPA_POD_CHOICE_FLAGS_Int(flags: anytype) @TypeOf(SPA_CHOICE_FLAGS(flags)) { + _ = &flags; + return blk: { + _ = "?fi"; + break :blk SPA_CHOICE_FLAGS(flags); + }; +} +pub inline fn SPA_POD_CHOICE_FEATURES_Int(features: anytype) @TypeOf(SPA_CHOICE_FEATURES(features)) { + _ = &features; + return blk: { + _ = "?Fi"; + break :blk SPA_CHOICE_FEATURES(features); + }; +} +pub inline fn SPA_POD_Long(val: anytype) @TypeOf(val) { + _ = &val; + return blk: { + _ = "l"; + break :blk val; + }; +} +pub const SPA_POD_CHOICE_ENUM_Long = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/vararg.h:50:9 +pub inline fn SPA_POD_CHOICE_RANGE_Long(def: anytype, min: anytype, max: anytype) @TypeOf(SPA_CHOICE_RANGE(def, min, max)) { + _ = &def; + _ = &min; + _ = &max; + return blk: { + _ = "?rl"; + break :blk SPA_CHOICE_RANGE(def, min, max); + }; +} +pub inline fn SPA_POD_CHOICE_STEP_Long(def: anytype, min: anytype, max: anytype, step: anytype) @TypeOf(SPA_CHOICE_STEP(def, min, max, step)) { + _ = &def; + _ = &min; + _ = &max; + _ = &step; + return blk: { + _ = "?sl"; + break :blk SPA_CHOICE_STEP(def, min, max, step); + }; +} +pub inline fn SPA_POD_CHOICE_FLAGS_Long(flags: anytype) @TypeOf(SPA_CHOICE_FLAGS(flags)) { + _ = &flags; + return blk: { + _ = "?fl"; + break :blk SPA_CHOICE_FLAGS(flags); + }; +} +pub inline fn SPA_POD_CHOICE_FEATURES_LONG(features: anytype) @TypeOf(SPA_CHOICE_FEATURES(features)) { + _ = &features; + return blk: { + _ = "?Fl"; + break :blk SPA_CHOICE_FEATURES(features); + }; +} +pub inline fn SPA_POD_Float(val: anytype) @TypeOf(val) { + _ = &val; + return blk: { + _ = "f"; + break :blk val; + }; +} +pub const SPA_POD_CHOICE_ENUM_Float = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/vararg.h:57:9 +pub inline fn SPA_POD_CHOICE_RANGE_Float(def: anytype, min: anytype, max: anytype) @TypeOf(SPA_CHOICE_RANGE(def, min, max)) { + _ = &def; + _ = &min; + _ = &max; + return blk: { + _ = "?rf"; + break :blk SPA_CHOICE_RANGE(def, min, max); + }; +} +pub inline fn SPA_POD_CHOICE_STEP_Float(def: anytype, min: anytype, max: anytype, step: anytype) @TypeOf(SPA_CHOICE_STEP(def, min, max, step)) { + _ = &def; + _ = &min; + _ = &max; + _ = &step; + return blk: { + _ = "?sf"; + break :blk SPA_CHOICE_STEP(def, min, max, step); + }; +} +pub inline fn SPA_POD_Double(val: anytype) @TypeOf(val) { + _ = &val; + return blk: { + _ = "d"; + break :blk val; + }; +} +pub const SPA_POD_CHOICE_ENUM_Double = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/vararg.h:62:9 +pub inline fn SPA_POD_CHOICE_RANGE_Double(def: anytype, min: anytype, max: anytype) @TypeOf(SPA_CHOICE_RANGE(def, min, max)) { + _ = &def; + _ = &min; + _ = &max; + return blk: { + _ = "?rd"; + break :blk SPA_CHOICE_RANGE(def, min, max); + }; +} +pub inline fn SPA_POD_CHOICE_STEP_Double(def: anytype, min: anytype, max: anytype, step: anytype) @TypeOf(SPA_CHOICE_STEP(def, min, max, step)) { + _ = &def; + _ = &min; + _ = &max; + _ = &step; + return blk: { + _ = "?sd"; + break :blk SPA_CHOICE_STEP(def, min, max, step); + }; +} +pub inline fn SPA_POD_String(val: anytype) @TypeOf(val) { + _ = &val; + return blk: { + _ = "s"; + break :blk val; + }; +} +pub inline fn SPA_POD_Stringn(val: anytype, len: anytype) @TypeOf(len) { + _ = &val; + _ = &len; + return blk: { + _ = "S"; + _ = &val; + break :blk len; + }; +} +pub inline fn SPA_POD_Bytes(val: anytype, len: anytype) @TypeOf(len) { + _ = &val; + _ = &len; + return blk: { + _ = "y"; + _ = &val; + break :blk len; + }; +} +pub inline fn SPA_POD_Rectangle(val: anytype) @TypeOf(val) { + _ = &val; + return blk: { + _ = "R"; + break :blk val; + }; +} +pub const SPA_POD_CHOICE_ENUM_Rectangle = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/vararg.h:72:9 +pub inline fn SPA_POD_CHOICE_RANGE_Rectangle(def: anytype, min: anytype, max: anytype) @TypeOf(SPA_CHOICE_RANGE(def, min, max)) { + _ = &def; + _ = &min; + _ = &max; + return blk: { + _ = "?rR"; + break :blk SPA_CHOICE_RANGE(def, min, max); + }; +} +pub inline fn SPA_POD_CHOICE_STEP_Rectangle(def: anytype, min: anytype, max: anytype, step: anytype) @TypeOf(SPA_CHOICE_STEP(def, min, max, step)) { + _ = &def; + _ = &min; + _ = &max; + _ = &step; + return blk: { + _ = "?sR"; + break :blk SPA_CHOICE_STEP(def, min, max, step); + }; +} +pub inline fn SPA_POD_Fraction(val: anytype) @TypeOf(val) { + _ = &val; + return blk: { + _ = "F"; + break :blk val; + }; +} +pub const SPA_POD_CHOICE_ENUM_Fraction = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/vararg.h:77:9 +pub inline fn SPA_POD_CHOICE_RANGE_Fraction(def: anytype, min: anytype, max: anytype) @TypeOf(SPA_CHOICE_RANGE(def, min, max)) { + _ = &def; + _ = &min; + _ = &max; + return blk: { + _ = "?rF"; + break :blk SPA_CHOICE_RANGE(def, min, max); + }; +} +pub inline fn SPA_POD_CHOICE_STEP_Fraction(def: anytype, min: anytype, max: anytype, step: anytype) @TypeOf(SPA_CHOICE_STEP(def, min, max, step)) { + _ = &def; + _ = &min; + _ = &max; + _ = &step; + return blk: { + _ = "?sF"; + break :blk SPA_CHOICE_STEP(def, min, max, step); + }; +} +pub inline fn SPA_POD_Array(csize: anytype, ctype: anytype, n_vals: anytype, vals: anytype) @TypeOf(vals) { + _ = &csize; + _ = &ctype; + _ = &n_vals; + _ = &vals; + return blk: { + _ = "a"; + _ = &csize; + _ = &ctype; + _ = &n_vals; + break :blk vals; + }; +} +pub inline fn SPA_POD_Pointer(@"type": anytype, val: anytype) @TypeOf(val) { + _ = &@"type"; + _ = &val; + return blk: { + _ = "p"; + _ = &@"type"; + break :blk val; + }; +} +pub inline fn SPA_POD_Fd(val: anytype) @TypeOf(val) { + _ = &val; + return blk: { + _ = "h"; + break :blk val; + }; +} +pub inline fn SPA_POD_None() @TypeOf(NULL) { + return blk: { + _ = "P"; + break :blk NULL; + }; +} +pub inline fn SPA_POD_Pod(val: anytype) @TypeOf(val) { + _ = &val; + return blk: { + _ = "P"; + break :blk val; + }; +} +pub inline fn SPA_POD_PodObject(val: anytype) @TypeOf(val) { + _ = &val; + return blk: { + _ = "O"; + break :blk val; + }; +} +pub inline fn SPA_POD_PodStruct(val: anytype) @TypeOf(val) { + _ = &val; + return blk: { + _ = "T"; + break :blk val; + }; +} +pub inline fn SPA_POD_PodChoice(val: anytype) @TypeOf(val) { + _ = &val; + return blk: { + _ = "V"; + break :blk val; + }; +} +pub inline fn SPA_POD_PodBody(val: anytype, body: anytype) @TypeOf(body) { + _ = &val; + _ = &body; + return blk: { + _ = "Q"; + _ = &val; + break :blk body; + }; +} +pub inline fn SPA_POD_PodBodyObject(val: anytype, body: anytype) @TypeOf(body) { + _ = &val; + _ = &body; + return blk: { + _ = "N"; + _ = &val; + break :blk body; + }; +} +pub inline fn SPA_POD_PodBodyStruct(val: anytype, body: anytype) @TypeOf(body) { + _ = &val; + _ = &body; + return blk: { + _ = "U"; + _ = &val; + break :blk body; + }; +} +pub inline fn SPA_POD_PodBodyChoice(val: anytype, body: anytype) @TypeOf(body) { + _ = &val; + _ = &body; + return blk: { + _ = "W"; + _ = &val; + break :blk body; + }; +} +pub const SPA_API_POD_PARSER = SPA_API_IMPL; +pub const SPA_POD_PARSER_INIT = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/parser.h:44:9 +pub const SPA_POD_PARSER_COLLECT_BODY = @compileError("unable to translate macro: undefined identifier `res`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/parser.h:576:9 +pub inline fn SPA_POD_PARSER_COLLECT(pod: anytype, _type: anytype, args: anytype) @TypeOf(SPA_POD_PARSER_COLLECT_BODY(pod, SPA_POD_BODY_CONST(pod), _type, args)) { + _ = &pod; + _ = &_type; + _ = &args; + return SPA_POD_PARSER_COLLECT_BODY(pod, SPA_POD_BODY_CONST(pod), _type, args); +} +pub const SPA_POD_PARSER_SKIP = @compileError("unable to translate C expr: unexpected token 'do'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/parser.h:748:9 +pub inline fn SPA_POD_OPT_Bool(val: anytype) @TypeOf("?" ++ SPA_POD_Bool(val)) { + _ = &val; + return "?" ++ SPA_POD_Bool(val); +} +pub inline fn SPA_POD_OPT_Id(val: anytype) @TypeOf("?" ++ SPA_POD_Id(val)) { + _ = &val; + return "?" ++ SPA_POD_Id(val); +} +pub inline fn SPA_POD_OPT_Int(val: anytype) @TypeOf("?" ++ SPA_POD_Int(val)) { + _ = &val; + return "?" ++ SPA_POD_Int(val); +} +pub inline fn SPA_POD_OPT_Long(val: anytype) @TypeOf("?" ++ SPA_POD_Long(val)) { + _ = &val; + return "?" ++ SPA_POD_Long(val); +} +pub inline fn SPA_POD_OPT_Float(val: anytype) @TypeOf("?" ++ SPA_POD_Float(val)) { + _ = &val; + return "?" ++ SPA_POD_Float(val); +} +pub inline fn SPA_POD_OPT_Double(val: anytype) @TypeOf("?" ++ SPA_POD_Double(val)) { + _ = &val; + return "?" ++ SPA_POD_Double(val); +} +pub inline fn SPA_POD_OPT_String(val: anytype) @TypeOf("?" ++ SPA_POD_String(val)) { + _ = &val; + return "?" ++ SPA_POD_String(val); +} +pub inline fn SPA_POD_OPT_Stringn(val: anytype, len: anytype) @TypeOf("?" ++ SPA_POD_Stringn(val, len)) { + _ = &val; + _ = &len; + return "?" ++ SPA_POD_Stringn(val, len); +} +pub inline fn SPA_POD_OPT_Bytes(val: anytype, len: anytype) @TypeOf("?" ++ SPA_POD_Bytes(val, len)) { + _ = &val; + _ = &len; + return "?" ++ SPA_POD_Bytes(val, len); +} +pub inline fn SPA_POD_OPT_Rectangle(val: anytype) @TypeOf("?" ++ SPA_POD_Rectangle(val)) { + _ = &val; + return "?" ++ SPA_POD_Rectangle(val); +} +pub inline fn SPA_POD_OPT_Fraction(val: anytype) @TypeOf("?" ++ SPA_POD_Fraction(val)) { + _ = &val; + return "?" ++ SPA_POD_Fraction(val); +} +pub inline fn SPA_POD_OPT_Array(csize: anytype, ctype: anytype, n_vals: anytype, vals: anytype) @TypeOf("?" ++ SPA_POD_Array(csize, ctype, n_vals, vals)) { + _ = &csize; + _ = &ctype; + _ = &n_vals; + _ = &vals; + return "?" ++ SPA_POD_Array(csize, ctype, n_vals, vals); +} +pub inline fn SPA_POD_OPT_Pointer(@"type": anytype, val: anytype) @TypeOf("?" ++ SPA_POD_Pointer(@"type", val)) { + _ = &@"type"; + _ = &val; + return "?" ++ SPA_POD_Pointer(@"type", val); +} +pub inline fn SPA_POD_OPT_Fd(val: anytype) @TypeOf("?" ++ SPA_POD_Fd(val)) { + _ = &val; + return "?" ++ SPA_POD_Fd(val); +} +pub inline fn SPA_POD_OPT_Pod(val: anytype) @TypeOf("?" ++ SPA_POD_Pod(val)) { + _ = &val; + return "?" ++ SPA_POD_Pod(val); +} +pub inline fn SPA_POD_OPT_PodObject(val: anytype) @TypeOf("?" ++ SPA_POD_PodObject(val)) { + _ = &val; + return "?" ++ SPA_POD_PodObject(val); +} +pub inline fn SPA_POD_OPT_PodStruct(val: anytype) @TypeOf("?" ++ SPA_POD_PodStruct(val)) { + _ = &val; + return "?" ++ SPA_POD_PodStruct(val); +} +pub inline fn SPA_POD_OPT_PodChoice(val: anytype) @TypeOf("?" ++ SPA_POD_PodChoice(val)) { + _ = &val; + return "?" ++ SPA_POD_PodChoice(val); +} +pub inline fn SPA_POD_OPT_PodBody(val: anytype, body: anytype) @TypeOf("?" ++ SPA_POD_PodBody(val, body)) { + _ = &val; + _ = &body; + return "?" ++ SPA_POD_PodBody(val, body); +} +pub inline fn SPA_POD_OPT_PodBodyObject(val: anytype, body: anytype) @TypeOf("?" ++ SPA_POD_PodBodyObject(val, body)) { + _ = &val; + _ = &body; + return "?" ++ SPA_POD_PodBodyObject(val, body); +} +pub inline fn SPA_POD_OPT_PodBodyStruct(val: anytype, body: anytype) @TypeOf("?" ++ SPA_POD_PodBodyStruct(val, body)) { + _ = &val; + _ = &body; + return "?" ++ SPA_POD_PodBodyStruct(val, body); +} +pub inline fn SPA_POD_OPT_PodBodyChoice(val: anytype, body: anytype) @TypeOf("?" ++ SPA_POD_PodBodyChoice(val, body)) { + _ = &val; + _ = &body; + return "?" ++ SPA_POD_PodBodyChoice(val, body); +} +pub const spa_pod_parser_get_object = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/parser.h:875:9 +pub const spa_pod_parser_get_struct = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/parser.h:886:9 +pub const spa_pod_body_parse_object = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/parser.h:897:9 +pub const spa_pod_parse_object = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/parser.h:904:9 +pub const spa_pod_body_parse_struct = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/parser.h:907:9 +pub const spa_pod_parse_struct = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/parser.h:914:9 +pub const SPA_PARAM_FORMAT_H = ""; +pub const SPA_KEY_FORMAT_DSP = "format.dsp"; +pub const SPA_API_FORMAT_UTILS = SPA_API_IMPL; +pub const SPA_PARAM_VIDEO_FORMAT_H = ""; +pub const SPA_VIDEO_RAW_H = ""; +pub const SPA_VIDEO_CHROMA_H = ""; +pub const SPA_VIDEO_COLOR_H = ""; +pub const SPA_VIDEO_MULTIVIEW_H = ""; +pub const SPA_VIDEO_MAX_PLANES = @as(c_int, 4); +pub const SPA_VIDEO_MAX_COMPONENTS = @as(c_int, 4); +pub const SPA_VIDEO_INFO_RAW_INIT = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/param/video/raw.h:192:9 +pub const SPA_VIDEO_DSP_H = ""; +pub const SPA_VIDEO_INFO_DSP_INIT = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/param/video/dsp.h:25:9 +pub const SPA_VIDEO_ENCODED_H = ""; +pub const SPA_VIDEO_H264_H = ""; +pub const SPA_VIDEO_MJPG_H = ""; +pub const SPA_VIDEO_RAW_UTILS_H = ""; +pub const SPA_POD_ITER_H = ""; +pub const SPA_API_POD_ITER = SPA_API_IMPL; +pub const SPA_POD_ARRAY_BODY_FOREACH = @compileError("unable to translate C expr: unexpected token 'for'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/iter.h:82:9 +pub inline fn SPA_POD_ARRAY_FOREACH(obj: anytype, iter: anytype) @TypeOf(SPA_POD_ARRAY_BODY_FOREACH(&obj.*.body, SPA_POD_BODY_SIZE(obj), iter)) { + _ = &obj; + _ = &iter; + return SPA_POD_ARRAY_BODY_FOREACH(&obj.*.body, SPA_POD_BODY_SIZE(obj), iter); +} +pub const SPA_POD_CHOICE_BODY_FOREACH = @compileError("unable to translate C expr: unexpected token 'for'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/iter.h:90:9 +pub inline fn SPA_POD_CHOICE_FOREACH(obj: anytype, iter: anytype) @TypeOf(SPA_POD_CHOICE_BODY_FOREACH(&obj.*.body, SPA_POD_BODY_SIZE(obj), iter)) { + _ = &obj; + _ = &iter; + return SPA_POD_CHOICE_BODY_FOREACH(&obj.*.body, SPA_POD_BODY_SIZE(obj), iter); +} +pub const SPA_POD_FOREACH = @compileError("unable to translate C expr: unexpected token 'for'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/iter.h:98:9 +pub inline fn SPA_POD_STRUCT_FOREACH(obj: anytype, iter: anytype) @TypeOf(SPA_POD_FOREACH(SPA_POD_STRUCT_BODY(obj), SPA_POD_BODY_SIZE(obj), iter)) { + _ = &obj; + _ = &iter; + return SPA_POD_FOREACH(SPA_POD_STRUCT_BODY(obj), SPA_POD_BODY_SIZE(obj), iter); +} +pub const SPA_POD_OBJECT_BODY_FOREACH = @compileError("unable to translate C expr: unexpected token 'for'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/iter.h:106:9 +pub inline fn SPA_POD_OBJECT_FOREACH(obj: anytype, iter: anytype) @TypeOf(SPA_POD_OBJECT_BODY_FOREACH(&obj.*.body, SPA_POD_BODY_SIZE(obj), iter)) { + _ = &obj; + _ = &iter; + return SPA_POD_OBJECT_BODY_FOREACH(&obj.*.body, SPA_POD_BODY_SIZE(obj), iter); +} +pub const SPA_POD_SEQUENCE_BODY_FOREACH = @compileError("unable to translate C expr: unexpected token 'for'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/iter.h:114:9 +pub inline fn SPA_POD_SEQUENCE_FOREACH(seq: anytype, iter: anytype) @TypeOf(SPA_POD_SEQUENCE_BODY_FOREACH(&seq.*.body, SPA_POD_BODY_SIZE(seq), iter)) { + _ = &seq; + _ = &iter; + return SPA_POD_SEQUENCE_BODY_FOREACH(&seq.*.body, SPA_POD_BODY_SIZE(seq), iter); +} +pub const spa_pod_copy_array = @compileError("unable to translate C expr: expected ')' instead got '['"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/iter.h:219:9 +pub const SPA_POD_BUILDER_H = ""; +pub const SPA_API_POD_BUILDER = SPA_API_IMPL; +pub const SPA_POD_BUILDER_FLAG_BODY = @as(c_int, 1) << @as(c_int, 0); +pub const SPA_POD_BUILDER_FLAG_FIRST = @as(c_int, 1) << @as(c_int, 1); +pub const SPA_VERSION_POD_BUILDER_CALLBACKS = @as(c_int, 0); +pub const SPA_POD_BUILDER_INIT = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:60:9 +pub inline fn SPA_POD_INIT(size: anytype, @"type": anytype) struct_spa_pod { + _ = &size; + _ = &@"type"; + return @import("std").mem.zeroInit(struct_spa_pod, .{ size, @"type" }); +} +pub inline fn SPA_POD_INIT_None() @TypeOf(SPA_POD_INIT(@as(c_int, 0), SPA_TYPE_None)) { + return SPA_POD_INIT(@as(c_int, 0), SPA_TYPE_None); +} +pub const SPA_POD_INIT_Bool = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:261:9 +pub const SPA_POD_INIT_Id = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:269:9 +pub const SPA_POD_INIT_Int = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:277:9 +pub const SPA_POD_INIT_Long = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:285:9 +pub const SPA_POD_INIT_Float = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:293:9 +pub const SPA_POD_INIT_Double = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:301:9 +pub const SPA_POD_INIT_String = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:309:9 +pub const SPA_POD_INIT_Bytes = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:336:9 +pub const SPA_POD_INIT_Pointer = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:353:9 +pub const SPA_POD_INIT_Fd = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:362:9 +pub const SPA_POD_INIT_Rectangle = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:370:9 +pub const SPA_POD_INIT_Fraction = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:379:9 +pub const SPA_POD_INIT_CHOICE_BODY = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:411:9 +pub const SPA_POD_INIT_Choice = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:414:9 +pub const SPA_POD_INIT_Struct = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:432:9 +pub const SPA_POD_INIT_Object = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:444:9 +pub const SPA_POD_INIT_Prop = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:458:9 +pub const SPA_POD_INIT_Sequence = @compileError("unable to translate C expr: unexpected token '{'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:468:9 +pub const SPA_POD_BUILDER_COLLECT = @compileError("unable to translate macro: undefined identifier `strval`"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:514:9 +pub const spa_pod_builder_add_object = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:697:9 +pub const spa_pod_builder_add_struct = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:706:9 +pub const spa_pod_builder_add_sequence = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:715:9 +pub const SPA_API_VIDEO_RAW_UTILS = SPA_API_IMPL; +pub const SPA_VIDEO_DSP_UTILS_H = ""; +pub const SPA_API_VIDEO_DSP_UTILS = SPA_API_IMPL; +pub const SPA_VIDEO_H264_UTILS_H = ""; +pub const SPA_API_VIDEO_H264_UTILS = SPA_API_IMPL; +pub const SPA_VIDEO_H265_UTILS_H = ""; +pub const SPA_VIDEO_H265_H = ""; +pub const SPA_API_VIDEO_H265_UTILS = SPA_API_IMPL; +pub const SPA_VIDEO_MJPG_UTILS_H = ""; +pub const SPA_API_VIDEO_MJPG_UTILS = SPA_API_IMPL; +pub const SPA_API_VIDEO_FORMAT_UTILS = SPA_API_IMPL; +pub const SPA_DEBUG_FORMAT_H = ""; +pub const SPA_DEBUG_CONTEXT_H = ""; +pub const _CTYPE_H = @as(c_int, 1); +pub inline fn _ISbit(bit: anytype) @TypeOf(if (bit < @as(c_int, 8)) (@as(c_int, 1) << bit) << @as(c_int, 8) else (@as(c_int, 1) << bit) >> @as(c_int, 8)) { + _ = &bit; + return if (bit < @as(c_int, 8)) (@as(c_int, 1) << bit) << @as(c_int, 8) else (@as(c_int, 1) << bit) >> @as(c_int, 8); +} +pub inline fn __isctype(c: anytype, @"type": anytype) @TypeOf(__ctype_b_loc().*[@as(usize, @intCast(@import("std").zig.c_translation.cast(c_int, c)))] & @import("std").zig.c_translation.cast(c_ushort, @"type")) { + _ = &c; + _ = &@"type"; + return __ctype_b_loc().*[@as(usize, @intCast(@import("std").zig.c_translation.cast(c_int, c)))] & @import("std").zig.c_translation.cast(c_ushort, @"type"); +} +pub inline fn __isascii(c: anytype) @TypeOf((c & ~@as(c_int, 0x7f)) == @as(c_int, 0)) { + _ = &c; + return (c & ~@as(c_int, 0x7f)) == @as(c_int, 0); +} +pub inline fn __toascii(c: anytype) @TypeOf(c & @as(c_int, 0x7f)) { + _ = &c; + return c & @as(c_int, 0x7f); +} +pub const __exctype = @compileError("unable to translate C expr: unexpected token 'extern'"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/ctype.h:102:9 +pub const __tobody = @compileError("unable to translate macro: undefined identifier `__res`"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/ctype.h:155:9 +pub inline fn __isctype_l(c: anytype, @"type": anytype, locale: anytype) @TypeOf(locale.*.__ctype_b[@as(usize, @intCast(@import("std").zig.c_translation.cast(c_int, c)))] & @import("std").zig.c_translation.cast(c_ushort, @"type")) { + _ = &c; + _ = &@"type"; + _ = &locale; + return locale.*.__ctype_b[@as(usize, @intCast(@import("std").zig.c_translation.cast(c_int, c)))] & @import("std").zig.c_translation.cast(c_ushort, @"type"); +} +pub const __exctype_l = @compileError("unable to translate C expr: unexpected token 'extern'"); +// /nix/store/r25srliigrrv5q3n7y8ms6z10spvjcd9-glibc-2.40-66-dev/include/ctype.h:244:10 +pub inline fn __isalnum_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISalnum, l)) { + _ = &c; + _ = &l; + return __isctype_l(c, _ISalnum, l); +} +pub inline fn __isalpha_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISalpha, l)) { + _ = &c; + _ = &l; + return __isctype_l(c, _ISalpha, l); +} +pub inline fn __iscntrl_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _IScntrl, l)) { + _ = &c; + _ = &l; + return __isctype_l(c, _IScntrl, l); +} +pub inline fn __isdigit_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISdigit, l)) { + _ = &c; + _ = &l; + return __isctype_l(c, _ISdigit, l); +} +pub inline fn __islower_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISlower, l)) { + _ = &c; + _ = &l; + return __isctype_l(c, _ISlower, l); +} +pub inline fn __isgraph_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISgraph, l)) { + _ = &c; + _ = &l; + return __isctype_l(c, _ISgraph, l); +} +pub inline fn __isprint_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISprint, l)) { + _ = &c; + _ = &l; + return __isctype_l(c, _ISprint, l); +} +pub inline fn __ispunct_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISpunct, l)) { + _ = &c; + _ = &l; + return __isctype_l(c, _ISpunct, l); +} +pub inline fn __isspace_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISspace, l)) { + _ = &c; + _ = &l; + return __isctype_l(c, _ISspace, l); +} +pub inline fn __isupper_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISupper, l)) { + _ = &c; + _ = &l; + return __isctype_l(c, _ISupper, l); +} +pub inline fn __isxdigit_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISxdigit, l)) { + _ = &c; + _ = &l; + return __isctype_l(c, _ISxdigit, l); +} +pub inline fn __isblank_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISblank, l)) { + _ = &c; + _ = &l; + return __isctype_l(c, _ISblank, l); +} +pub inline fn __isascii_l(c: anytype, l: anytype) @TypeOf(__isascii(c)) { + _ = &c; + _ = &l; + return blk_1: { + _ = &l; + break :blk_1 __isascii(c); + }; +} +pub inline fn __toascii_l(c: anytype, l: anytype) @TypeOf(__toascii(c)) { + _ = &c; + _ = &l; + return blk_1: { + _ = &l; + break :blk_1 __toascii(c); + }; +} +pub inline fn isascii_l(c: anytype, l: anytype) @TypeOf(__isascii_l(c, l)) { + _ = &c; + _ = &l; + return __isascii_l(c, l); +} +pub inline fn toascii_l(c: anytype, l: anytype) @TypeOf(__toascii_l(c, l)) { + _ = &c; + _ = &l; + return __toascii_l(c, l); +} +pub const spa_debugn = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/debug/context.h:24:9 +pub const spa_debug = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/debug/context.h:27:9 +pub const SPA_API_DEBUG_CONTEXT = SPA_API_IMPL; +pub const spa_debugc = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/debug/context.h:43:9 +pub const SPA_DEBUG_TYPES_H = ""; +pub const SPA_TYPE_INFO_H = ""; +pub const SPA_ENUM_TYPES_H = ""; +pub const SPA_TYPE_INFO_Direction = SPA_TYPE_INFO_ENUM_BASE ++ "Direction"; +pub const SPA_TYPE_INFO_DIRECTION_BASE = SPA_TYPE_INFO_Direction ++ ":"; +pub const SPA_TYPE_INFO_Choice = SPA_TYPE_INFO_ENUM_BASE ++ "Choice"; +pub const SPA_TYPE_INFO_CHOICE_BASE = SPA_TYPE_INFO_Choice ++ ":"; +pub const SPA_DEVICE_TYPE_INFO_H = ""; +pub const SPA_EVENT_DEVICE_H = ""; +pub inline fn SPA_DEVICE_EVENT_ID(ev: anytype) @TypeOf(SPA_EVENT_ID(ev, SPA_TYPE_EVENT_Device)) { + _ = &ev; + return SPA_EVENT_ID(ev, SPA_TYPE_EVENT_Device); +} +pub inline fn SPA_DEVICE_EVENT_INIT(id: anytype) @TypeOf(SPA_EVENT_INIT(SPA_TYPE_EVENT_Device, id)) { + _ = &id; + return SPA_EVENT_INIT(SPA_TYPE_EVENT_Device, id); +} +pub const SPA_TYPE_INFO_DeviceEvent = SPA_TYPE_INFO_EVENT_BASE ++ "Device"; +pub const SPA_TYPE_INFO_DEVICE_EVENT_BASE = SPA_TYPE_INFO_DeviceEvent ++ ":"; +pub const SPA_TYPE_INFO_DeviceEventId = SPA_TYPE_INFO_ENUM_BASE ++ "DeviceEventId"; +pub const SPA_TYPE_INFO_DEVICE_EVENT_ID_BASE = SPA_TYPE_INFO_DeviceEventId ++ ":"; +pub const SPA_NODE_TYPES_H = ""; +pub const SPA_TYPE_INFO_IO = SPA_TYPE_INFO_ENUM_BASE ++ "IO"; +pub const SPA_TYPE_INFO_IO_BASE = SPA_TYPE_INFO_IO ++ ":"; +pub const SPA_TYPE_INFO_NodeEvent = SPA_TYPE_INFO_EVENT_BASE ++ "Node"; +pub const SPA_TYPE_INFO_NODE_EVENT_BASE = SPA_TYPE_INFO_NodeEvent ++ ":"; +pub const SPA_TYPE_INFO_NodeCommand = SPA_TYPE_INFO_COMMAND_BASE ++ "Node"; +pub const SPA_TYPE_INFO_NODE_COMMAND_BASE = SPA_TYPE_INFO_NodeCommand ++ ":"; +pub const SPA_PARAM_TYPE_INFO_H = ""; +pub const SPA_PARAM_TYPES_H = ""; +pub const SPA_PARAM_PROPS_H = ""; +pub const SPA_BUFFER_TYPES_H = ""; +pub const SPA_TYPE_INFO_Buffer = SPA_TYPE_INFO_POINTER_BASE ++ "Buffer"; +pub const SPA_TYPE_INFO_BUFFER_BASE = SPA_TYPE_INFO_Buffer ++ ":"; +pub const SPA_TYPE_INFO_Data = SPA_TYPE_INFO_ENUM_BASE ++ "Data"; +pub const SPA_TYPE_INFO_DATA_BASE = SPA_TYPE_INFO_Data ++ ":"; +pub const SPA_TYPE_INFO_DATA_Fd = SPA_TYPE_INFO_DATA_BASE ++ "Fd"; +pub const SPA_TYPE_INFO_DATA_FD_BASE = SPA_TYPE_INFO_DATA_Fd ++ ":"; +pub const SPA_TYPE_INFO_Meta = SPA_TYPE_INFO_POINTER_BASE ++ "Meta"; +pub const SPA_TYPE_INFO_META_BASE = SPA_TYPE_INFO_Meta ++ ":"; +pub const SPA_TYPE_INFO_META_Array = SPA_TYPE_INFO_META_BASE ++ "Array"; +pub const SPA_TYPE_INFO_META_ARRAY_BASE = SPA_TYPE_INFO_META_Array ++ ":"; +pub const SPA_TYPE_INFO_META_Region = SPA_TYPE_INFO_META_BASE ++ "Region"; +pub const SPA_TYPE_INFO_META_REGION_BASE = SPA_TYPE_INFO_META_Region ++ ":"; +pub const SPA_TYPE_INFO_META_ARRAY_Region = SPA_TYPE_INFO_META_ARRAY_BASE ++ "Region"; +pub const SPA_TYPE_INFO_META_ARRAY_REGION_BASE = SPA_TYPE_INFO_META_ARRAY_Region ++ ":"; +pub const SPA_TYPE_INFO_META_Transformation = SPA_TYPE_INFO_ENUM_BASE ++ "Meta:Transformation"; +pub const SPA_TYPE_INFO_META_TRANSFORMATION_BASE = SPA_TYPE_INFO_META_Transformation ++ ":"; +pub const SPA_TYPE_INFO_ParamId = SPA_TYPE_INFO_ENUM_BASE ++ "ParamId"; +pub const SPA_TYPE_INFO_PARAM_ID_BASE = SPA_TYPE_INFO_ParamId ++ ":"; +pub const SPA_TYPE_INFO_Param = SPA_TYPE_INFO_OBJECT_BASE ++ "Param"; +pub const SPA_TYPE_INFO_PARAM_BASE = SPA_TYPE_INFO_Param ++ ":"; +pub const SPA_AUDIO_TYPES_H = ""; +pub const SPA_AUDIO_RAW_TYPES_H = ""; +pub const SPA_AUDIO_RAW_H = ""; +pub const SPA_ENDIAN_H = ""; +pub const _BYTESWAP_H = @as(c_int, 1); +pub inline fn bswap_16(x: anytype) @TypeOf(__bswap_16(x)) { + _ = &x; + return __bswap_16(x); +} +pub inline fn bswap_32(x: anytype) @TypeOf(__bswap_32(x)) { + _ = &x; + return __bswap_32(x); +} +pub inline fn bswap_64(x: anytype) @TypeOf(__bswap_64(x)) { + _ = &x; + return __bswap_64(x); +} +pub const SPA_AUDIO_MAX_CHANNELS = @as(c_uint, 128); +pub inline fn SPA_AUDIO_FORMAT_IS_INTERLEAVED(fmt: anytype) @TypeOf((fmt > SPA_AUDIO_FORMAT_START_Interleaved) and (fmt < SPA_AUDIO_FORMAT_START_Planar)) { + _ = &fmt; + return (fmt > SPA_AUDIO_FORMAT_START_Interleaved) and (fmt < SPA_AUDIO_FORMAT_START_Planar); +} +pub inline fn SPA_AUDIO_FORMAT_IS_PLANAR(fmt: anytype) @TypeOf((fmt > SPA_AUDIO_FORMAT_START_Planar) and (fmt < SPA_AUDIO_FORMAT_START_Other)) { + _ = &fmt; + return (fmt > SPA_AUDIO_FORMAT_START_Planar) and (fmt < SPA_AUDIO_FORMAT_START_Other); +} +pub const SPA_AUDIO_FLAG_NONE = @as(c_int, 0); +pub const SPA_AUDIO_FLAG_UNPOSITIONED = @as(c_int, 1) << @as(c_int, 0); +pub const SPA_AUDIO_INFO_RAW_INIT = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/param/audio/raw.h:281:9 +pub const SPA_KEY_AUDIO_FORMAT = "audio.format"; +pub const SPA_KEY_AUDIO_CHANNEL = "audio.channel"; +pub const SPA_KEY_AUDIO_CHANNELS = "audio.channels"; +pub const SPA_KEY_AUDIO_RATE = "audio.rate"; +pub const SPA_KEY_AUDIO_POSITION = "audio.position"; +pub const SPA_KEY_AUDIO_ALLOWED_RATES = "audio.allowed-rates"; +pub const SPA_API_AUDIO_RAW_TYPES = SPA_API_IMPL; +pub const SPA_TYPE_INFO_AudioFormat = SPA_TYPE_INFO_ENUM_BASE ++ "AudioFormat"; +pub const SPA_TYPE_INFO_AUDIO_FORMAT_BASE = SPA_TYPE_INFO_AudioFormat ++ ":"; +pub const SPA_TYPE_INFO_AudioFlags = SPA_TYPE_INFO_FLAGS_BASE ++ "AudioFlags"; +pub const SPA_TYPE_INFO_AUDIO_FLAGS_BASE = SPA_TYPE_INFO_AudioFlags ++ ":"; +pub const SPA_TYPE_INFO_AudioChannel = SPA_TYPE_INFO_ENUM_BASE ++ "AudioChannel"; +pub const SPA_TYPE_INFO_AUDIO_CHANNEL_BASE = SPA_TYPE_INFO_AudioChannel ++ ":"; +pub const SPA_TYPE_INFO_AudioVolumeRampScale = SPA_TYPE_INFO_ENUM_BASE ++ "AudioVolumeRampScale"; +pub const SPA_TYPE_INFO_AUDIO_VOLUME_RAMP_SCALE_BASE = SPA_TYPE_INFO_AudioVolumeRampScale ++ ":"; +pub const SPA_AUDIO_IEC958_TYPES_H = ""; +pub const SPA_AUDIO_IEC958_H = ""; +pub const SPA_AUDIO_INFO_IEC958_INIT = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/param/audio/iec958.h:39:9 +pub const SPA_API_AUDIO_IEC958_TYPES = SPA_API_IMPL; +pub const SPA_TYPE_INFO_AudioIEC958Codec = SPA_TYPE_INFO_ENUM_BASE ++ "AudioIEC958Codec"; +pub const SPA_TYPE_INFO_AUDIO_IEC958_CODEC_BASE = SPA_TYPE_INFO_AudioIEC958Codec ++ ":"; +pub const SPA_AUDIO_MP3_TYPES_H = ""; +pub const SPA_AUDIO_MP3_H = ""; +pub const SPA_AUDIO_INFO_MP3_INIT = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/param/audio/mp3.h:43:9 +pub const SPA_TYPE_INFO_AudioMP3ChannelMode = SPA_TYPE_INFO_ENUM_BASE ++ "AudioMP3ChannelMode"; +pub const SPA_TYPE_INFO_AUDIO_MP3_CHANNEL_MODE_BASE = SPA_TYPE_INFO_AudioMP3ChannelMode ++ ":"; +pub const SPA_AUDIO_AAC_TYPES_H = ""; +pub const SPA_AUDIO_AAC_H = ""; +pub const SPA_AUDIO_INFO_AAC_INIT = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/param/audio/aac.h:46:9 +pub const SPA_TYPE_INFO_AudioAACStreamFormat = SPA_TYPE_INFO_ENUM_BASE ++ "AudioAACStreamFormat"; +pub const SPA_TYPE_INFO_AUDIO_AAC_STREAM_FORMAT_BASE = SPA_TYPE_INFO_AudioAACStreamFormat ++ ":"; +pub const SPA_AUDIO_WMA_TYPES_H = ""; +pub const SPA_AUDIO_WMA_H = ""; +pub const SPA_AUDIO_INFO_WMA_INIT = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/param/audio/wma.h:42:9 +pub const SPA_TYPE_INFO_AudioWMAProfile = SPA_TYPE_INFO_ENUM_BASE ++ "AudioWMAProfile"; +pub const SPA_TYPE_INFO_AUDIO_WMA_PROFILE_BASE = SPA_TYPE_INFO_AudioWMAProfile ++ ":"; +pub const SPA_AUDIO_AMR_TYPES_H = ""; +pub const SPA_AUDIO_AMR_H = ""; +pub const SPA_AUDIO_INFO_AMR_INIT = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/param/audio/amr.h:31:9 +pub const SPA_TYPE_INFO_AudioAMRBandMode = SPA_TYPE_INFO_ENUM_BASE ++ "AudioAMRBandMode"; +pub const SPA_TYPE_INFO_AUDIO_AMR_BAND_MODE_BASE = SPA_TYPE_INFO_AudioAMRBandMode ++ ":"; +pub const SPA_AUDIO_DTS_TYPES_H = ""; +pub const SPA_AUDIO_DTS_H = ""; +pub const SPA_AUDIO_INFO_DTS_INIT = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/param/audio/dts.h:41:9 +pub const SPA_TYPE_INFO_AudioDTSExtType = SPA_TYPE_INFO_ENUM_BASE ++ "AudioDTSExtType"; +pub const SPA_TYPE_INFO_AUDIO_DTS_EXT_TYPE_BASE = SPA_TYPE_INFO_AudioDTSExtType ++ ":"; +pub const SPA_TYPE_INFO_ParamBitorder = SPA_TYPE_INFO_ENUM_BASE ++ "ParamBitorder"; +pub const SPA_TYPE_INFO_PARAM_BITORDER_BASE = SPA_TYPE_INFO_ParamBitorder ++ ":"; +pub const SPA_TYPE_INFO_ParamAvailability = SPA_TYPE_INFO_ENUM_BASE ++ "ParamAvailability"; +pub const SPA_TYPE_INFO_PARAM_AVAILABILITY_BASE = SPA_TYPE_INFO_ParamAvailability ++ ":"; +pub const SPA_PARAM_BUFFERS_TYPES_H = ""; +pub const SPA_TYPE_INFO_PARAM_Meta = SPA_TYPE_INFO_PARAM_BASE ++ "Meta"; +pub const SPA_TYPE_INFO_PARAM_META_BASE = SPA_TYPE_INFO_PARAM_Meta ++ ":"; +pub const SPA_TYPE_INFO_PARAM_IO = SPA_TYPE_INFO_PARAM_BASE ++ "IO"; +pub const SPA_TYPE_INFO_PARAM_IO_BASE = SPA_TYPE_INFO_PARAM_IO ++ ":"; +pub const SPA_TYPE_INFO_PARAM_Buffers = SPA_TYPE_INFO_PARAM_BASE ++ "Buffers"; +pub const SPA_TYPE_INFO_PARAM_BUFFERS_BASE = SPA_TYPE_INFO_PARAM_Buffers ++ ":"; +pub const SPA_TYPE_INFO_PARAM_BlockInfo = SPA_TYPE_INFO_PARAM_BUFFERS_BASE ++ "BlockInfo"; +pub const SPA_TYPE_INFO_PARAM_BLOCK_INFO_BASE = SPA_TYPE_INFO_PARAM_BlockInfo ++ ":"; +pub const SPA_PARAM_PROPS_TYPES_H = ""; +pub const SPA_BLUETOOTH_TYPES_H = ""; +pub const SPA_BLUETOOTH_AUDIO_H = ""; +pub const SPA_TYPE_INFO_BluetoothAudioCodec = SPA_TYPE_INFO_ENUM_BASE ++ "BluetoothAudioCodec"; +pub const SPA_TYPE_INFO_BLUETOOTH_AUDIO_CODEC_BASE = SPA_TYPE_INFO_BluetoothAudioCodec ++ ":"; +pub const SPA_TYPE_INFO_Props = SPA_TYPE_INFO_PARAM_BASE ++ "Props"; +pub const SPA_TYPE_INFO_PROPS_BASE = SPA_TYPE_INFO_Props ++ ":"; +pub const SPA_TYPE_INFO_PropInfo = SPA_TYPE_INFO_PARAM_BASE ++ "PropInfo"; +pub const SPA_TYPE_INFO_PROP_INFO_BASE = SPA_TYPE_INFO_PropInfo ++ ":"; +pub const SPA_PARAM_FORMAT_TYPES_H = ""; +pub const SPA_VIDEO_TYPES_H = ""; +pub const SPA_VIDEO_COLOR_TYPES_H = ""; +pub const SPA_TYPE_INFO_VideColorRange = SPA_TYPE_INFO_ENUM_BASE ++ "VideoColorRange"; +pub const SPA_TYPE_INFO_VIDEO_COLOR_RANGE_BASE = SPA_TYPE_INFO_VideColorRange ++ ":"; +pub const SPA_TYPE_INFO_VideoColorMatrix = SPA_TYPE_INFO_ENUM_BASE ++ "VideoColorMatrix"; +pub const SPA_TYPE_INFO_VIDEO_COLOR_MATRIX_BASE = SPA_TYPE_INFO_VideoColorMatrix ++ ":"; +pub const SPA_TYPE_INFO_VideoTransferFunction = SPA_TYPE_INFO_ENUM_BASE ++ "VideoTransferFunction"; +pub const SPA_TYPE_INFO_VIDEO_TRANSFER_FUNCTION_BASE = SPA_TYPE_INFO_VideoTransferFunction ++ ":"; +pub const SPA_TYPE_INFO_VideoColorPrimaries = SPA_TYPE_INFO_ENUM_BASE ++ "VideoColorPrimaries"; +pub const SPA_TYPE_INFO_VIDEO_COLOR_PRIMARIES_BASE = SPA_TYPE_INFO_VideoColorPrimaries ++ ":"; +pub const SPA_VIDEO_RAW_TYPES_H = ""; +pub const SPA_API_VIDEO_RAW_TYPES = SPA_API_IMPL; +pub const SPA_TYPE_INFO_VideoFormat = SPA_TYPE_INFO_ENUM_BASE ++ "VideoFormat"; +pub const SPA_TYPE_INFO_VIDEO_FORMAT_BASE = SPA_TYPE_INFO_VideoFormat ++ ":"; +pub const SPA_TYPE_INFO_VideoFlags = SPA_TYPE_INFO_FLAGS_BASE ++ "VideoFlags"; +pub const SPA_TYPE_INFO_VIDEO_FLAGS_BASE = SPA_TYPE_INFO_VideoFlags ++ ":"; +pub const SPA_TYPE_INFO_VideoInterlaceMode = SPA_TYPE_INFO_ENUM_BASE ++ "VideoInterlaceMode"; +pub const SPA_TYPE_INFO_VIDEO_INTERLACE_MODE_BASE = SPA_TYPE_INFO_VideoInterlaceMode ++ ":"; +pub const SPA_CONTROL_TYPES_H = ""; +pub const SPA_CONTROL_H = ""; +pub const SPA_TYPE_INFO_Control = SPA_TYPE_INFO_ENUM_BASE ++ "Control"; +pub const SPA_TYPE_INFO_CONTROL_BASE = SPA_TYPE_INFO_Control ++ ":"; +pub const SPA_TYPE_INFO_Format = SPA_TYPE_INFO_PARAM_BASE ++ "Format"; +pub const SPA_TYPE_INFO_FORMAT_BASE = SPA_TYPE_INFO_Format ++ ":"; +pub const SPA_TYPE_INFO_MediaType = SPA_TYPE_INFO_ENUM_BASE ++ "MediaType"; +pub const SPA_TYPE_INFO_MEDIA_TYPE_BASE = SPA_TYPE_INFO_MediaType ++ ":"; +pub const SPA_TYPE_INFO_MediaSubtype = SPA_TYPE_INFO_ENUM_BASE ++ "MediaSubtype"; +pub const SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE = SPA_TYPE_INFO_MediaSubtype ++ ":"; +pub const SPA_TYPE_INFO_FormatAudio = SPA_TYPE_INFO_FORMAT_BASE ++ "Audio"; +pub const SPA_TYPE_INFO_FORMAT_AUDIO_BASE = SPA_TYPE_INFO_FormatAudio ++ ":"; +pub const SPA_TYPE_INFO_FORMAT_AUDIO_AAC = SPA_TYPE_INFO_FORMAT_AUDIO_BASE ++ "AAC"; +pub const SPA_TYPE_INFO_FORMAT_AUDIO_AAC_BASE = SPA_TYPE_INFO_FORMAT_AUDIO_AAC ++ ":"; +pub const SPA_TYPE_INFO_FORMAT_AUDIO_WMA = SPA_TYPE_INFO_FORMAT_AUDIO_BASE ++ "WMA"; +pub const SPA_TYPE_INFO_FORMAT_AUDIO_WMA_BASE = SPA_TYPE_INFO_FORMAT_AUDIO_WMA ++ ":"; +pub const SPA_TYPE_INFO_FORMAT_AUDIO_AMR = SPA_TYPE_INFO_FORMAT_AUDIO_BASE ++ "AMR"; +pub const SPA_TYPE_INFO_FORMAT_AUDIO_AMR_BASE = SPA_TYPE_INFO_FORMAT_AUDIO_AMR ++ ":"; +pub const SPA_TYPE_INFO_FORMAT_AUDIO_MP3 = SPA_TYPE_INFO_FORMAT_AUDIO_BASE ++ "MP3"; +pub const SPA_TYPE_INFO_FORMAT_AUDIO_MP3_BASE = SPA_TYPE_INFO_FORMAT_AUDIO_MP3 ++ ":"; +pub const SPA_TYPE_INFO_FORMAT_AUDIO_DTS = SPA_TYPE_INFO_FORMAT_AUDIO_BASE ++ "DTS"; +pub const SPA_TYPE_INFO_FORMAT_AUDIO_DTS_BASE = SPA_TYPE_INFO_FORMAT_AUDIO_DTS ++ ":"; +pub const SPA_TYPE_INFO_FormatVideo = SPA_TYPE_INFO_FORMAT_BASE ++ "Video"; +pub const SPA_TYPE_INFO_FORMAT_VIDEO_BASE = SPA_TYPE_INFO_FormatVideo ++ ":"; +pub const SPA_TYPE_INFO_FORMAT_VIDEO_H264 = SPA_TYPE_INFO_FORMAT_VIDEO_BASE ++ "H264"; +pub const SPA_TYPE_INFO_FORMAT_VIDEO_H264_BASE = SPA_TYPE_INFO_FORMAT_VIDEO_H264 ++ ":"; +pub const SPA_TYPE_INFO_FormatControl = SPA_TYPE_INFO_FORMAT_BASE ++ "Control"; +pub const SPA_TYPE_INFO_FORMAT_CONTROL_BASE = SPA_TYPE_INFO_FormatControl ++ ":"; +pub const SPA_PARAM_LATENCY_TYPES_H = ""; +pub const SPA_PARAM_LATENY_H = ""; +pub const SPA_LATENCY_INFO = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/param/latency.h:59:9 +pub const SPA_LATENCY_INFO_UNSET = @compileError("unable to translate C expr: unexpected token '.'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/param/latency.h:60:9 +pub const SPA_PROCESS_LATENCY_INFO_INIT = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/param/latency.h:85:9 +pub const SPA_TYPE_INFO_PARAM_Latency = SPA_TYPE_INFO_PARAM_BASE ++ "Latency"; +pub const SPA_TYPE_INFO_PARAM_LATENCY_BASE = SPA_TYPE_INFO_PARAM_Latency ++ ":"; +pub const SPA_TYPE_INFO_PARAM_ProcessLatency = SPA_TYPE_INFO_PARAM_BASE ++ "ProcessLatency"; +pub const SPA_TYPE_INFO_PARAM_PROCESS_LATENCY_BASE = SPA_TYPE_INFO_PARAM_ProcessLatency ++ ":"; +pub const SPA_PARAM_PORT_CONFIG_TYPES_H = ""; +pub const SPA_TYPE_INFO_ParamPortConfigMode = SPA_TYPE_INFO_ENUM_BASE ++ "ParamPortConfigMode"; +pub const SPA_TYPE_INFO_PARAM_PORT_CONFIG_MODE_BASE = SPA_TYPE_INFO_ParamPortConfigMode ++ ":"; +pub const SPA_TYPE_INFO_PARAM_PortConfig = SPA_TYPE_INFO_PARAM_BASE ++ "PortConfig"; +pub const SPA_TYPE_INFO_PARAM_PORT_CONFIG_BASE = SPA_TYPE_INFO_PARAM_PortConfig ++ ":"; +pub const SPA_PARAM_PROFILER_TYPES_H = ""; +pub const SPA_PARAM_PROFILER_H = ""; +pub const SPA_TYPE_INFO_Profiler = SPA_TYPE_INFO_OBJECT_BASE ++ "Profiler"; +pub const SPA_TYPE_INFO_PROFILER_BASE = SPA_TYPE_INFO_Profiler ++ ":"; +pub const SPA_PARAM_PROFILE_TYPES_H = ""; +pub const SPA_TYPE_INFO_PARAM_Profile = SPA_TYPE_INFO_PARAM_BASE ++ "Profile"; +pub const SPA_TYPE_INFO_PARAM_PROFILE_BASE = SPA_TYPE_INFO_PARAM_Profile ++ ":"; +pub const SPA_PARAM_ROUTE_TYPES_H = ""; +pub const SPA_TYPE_INFO_PARAM_Route = SPA_TYPE_INFO_PARAM_BASE ++ "Route"; +pub const SPA_TYPE_INFO_PARAM_ROUTE_BASE = SPA_TYPE_INFO_PARAM_Route ++ ":"; +pub const SPA_PARAM_TAG_TYPES_H = ""; +pub const SPA_PARAM_TAG_H = ""; +pub const SPA_TAG_INFO = @compileError("unable to translate C expr: expected ')' instead got '...'"); +// .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/param/tag.h:36:9 +pub const SPA_TYPE_INFO_PARAM_Tag = SPA_TYPE_INFO_PARAM_BASE ++ "Tag"; +pub const SPA_TYPE_INFO_PARAM_TAG_BASE = SPA_TYPE_INFO_PARAM_Tag ++ ":"; +pub const SPA_TYPE_ROOT = spa_types; +pub const SPA_API_DEBUG_TYPES = SPA_API_IMPL; +pub const SPA_API_DEBUG_FORMAT = SPA_API_IMPL; +pub const timespec = struct_timespec; +pub const sigval = union_sigval; +pub const sigevent = struct_sigevent; +pub const _fpx_sw_bytes = struct__fpx_sw_bytes; +pub const _fpreg = struct__fpreg; +pub const _fpxreg = struct__fpxreg; +pub const _xmmreg = struct__xmmreg; +pub const _fpstate = struct__fpstate; +pub const sigcontext = struct_sigcontext; +pub const _xsave_hdr = struct__xsave_hdr; +pub const _ymmh_state = struct__ymmh_state; +pub const _xstate = struct__xstate; +pub const _libc_fpxreg = struct__libc_fpxreg; +pub const _libc_xmmreg = struct__libc_xmmreg; +pub const _libc_fpstate = struct__libc_fpstate; +pub const __pthread_internal_list = struct___pthread_internal_list; +pub const __pthread_internal_slist = struct___pthread_internal_slist; +pub const __pthread_mutex_s = struct___pthread_mutex_s; +pub const __pthread_rwlock_arch_t = struct___pthread_rwlock_arch_t; +pub const __pthread_cond_s = struct___pthread_cond_s; +pub const timeval = struct_timeval; +pub const random_data = struct_random_data; +pub const drand48_data = struct_drand48_data; +pub const __locale_struct = struct___locale_struct; +pub const _G_fpos_t = struct__G_fpos_t; +pub const _G_fpos64_t = struct__G_fpos64_t; +pub const _IO_marker = struct__IO_marker; +pub const _IO_codecvt = struct__IO_codecvt; +pub const _IO_wide_data = struct__IO_wide_data; +pub const _IO_FILE = struct__IO_FILE; +pub const _IO_cookie_io_functions_t = struct__IO_cookie_io_functions_t; +pub const spa_direction = enum_spa_direction; +pub const spa_rectangle = struct_spa_rectangle; +pub const spa_point = struct_spa_point; +pub const spa_region = struct_spa_region; +pub const spa_fraction = struct_spa_fraction; +pub const spa_error_location = struct_spa_error_location; +pub const spa_list = struct_spa_list; +pub const spa_callbacks = struct_spa_callbacks; +pub const spa_interface = struct_spa_interface; +pub const spa_hook_list = struct_spa_hook_list; +pub const spa_hook = struct_spa_hook; +pub const spa_dict_item = struct_spa_dict_item; +pub const spa_dict = struct_spa_dict; +pub const spa_handle = struct_spa_handle; +pub const spa_interface_info = struct_spa_interface_info; +pub const spa_support = struct_spa_support; +pub const spa_handle_factory = struct_spa_handle_factory; +pub const pw_array = struct_pw_array; +pub const spa_param_type = enum_spa_param_type; +pub const spa_param_info = struct_spa_param_info; +pub const spa_param_bitorder = enum_spa_param_bitorder; +pub const spa_param_availability = enum_spa_param_availability; +pub const spa_param_buffers = enum_spa_param_buffers; +pub const spa_param_meta = enum_spa_param_meta; +pub const spa_param_io = enum_spa_param_io; +pub const spa_param_profile = enum_spa_param_profile; +pub const spa_param_port_config_mode = enum_spa_param_port_config_mode; +pub const spa_param_port_config = enum_spa_param_port_config; +pub const spa_param_route = enum_spa_param_route; +pub const lconv = struct_lconv; +pub const spa_strbuf = struct_spa_strbuf; +pub const spa_type_info = struct_spa_type_info; +pub const pw_proxy = struct_pw_proxy; +pub const pw_protocol = struct_pw_protocol; +pub const pw_context = struct_pw_context; +pub const pw_global = struct_pw_global; +pub const pw_impl_client = struct_pw_impl_client; +pub const pw_impl_node = struct_pw_impl_node; +pub const pw_core = struct_pw_core; +pub const pw_registry = struct_pw_registry; +pub const pw_core_info = struct_pw_core_info; +pub const dirent = struct_dirent; +pub const __dirstream = struct___dirstream; +pub const pw_properties = struct_pw_properties; +pub const pw_core_events = struct_pw_core_events; +pub const pw_core_methods = struct_pw_core_methods; +pub const pw_registry_events = struct_pw_registry_events; +pub const pw_registry_methods = struct_pw_registry_methods; +pub const pw_client = struct_pw_client; +pub const pw_mempool = struct_pw_mempool; +pub const tm = struct_tm; +pub const itimerspec = struct_itimerspec; +pub const spa_system = struct_spa_system; +pub const spa_poll_event = struct_spa_poll_event; +pub const spa_system_methods = struct_spa_system_methods; +pub const spa_loop = struct_spa_loop; +pub const spa_loop_control = struct_spa_loop_control; +pub const spa_loop_utils = struct_spa_loop_utils; +pub const spa_source = struct_spa_source; +pub const spa_loop_methods = struct_spa_loop_methods; +pub const spa_loop_control_hooks = struct_spa_loop_control_hooks; +pub const spa_loop_control_methods = struct_spa_loop_control_methods; +pub const spa_loop_utils_methods = struct_spa_loop_utils_methods; +pub const pw_loop = struct_pw_loop; +pub const pw_context_events = struct_pw_context_events; +pub const pw_data_loop = struct_pw_data_loop; +pub const pw_work_queue = struct_pw_work_queue; +pub const pw_timer_queue = struct_pw_timer_queue; +pub const pw_export_type = struct_pw_export_type; +pub const sockaddr_un = struct_sockaddr_un; +pub const spa_pod = struct_spa_pod; +pub const spa_pod_bool = struct_spa_pod_bool; +pub const spa_pod_id = struct_spa_pod_id; +pub const spa_pod_int = struct_spa_pod_int; +pub const spa_pod_long = struct_spa_pod_long; +pub const spa_pod_float = struct_spa_pod_float; +pub const spa_pod_double = struct_spa_pod_double; +pub const spa_pod_string = struct_spa_pod_string; +pub const spa_pod_bytes = struct_spa_pod_bytes; +pub const spa_pod_rectangle = struct_spa_pod_rectangle; +pub const spa_pod_fraction = struct_spa_pod_fraction; +pub const spa_pod_bitmap = struct_spa_pod_bitmap; +pub const spa_pod_array_body = struct_spa_pod_array_body; +pub const spa_pod_array = struct_spa_pod_array; +pub const spa_choice_type = enum_spa_choice_type; +pub const spa_pod_choice_body = struct_spa_pod_choice_body; +pub const spa_pod_choice = struct_spa_pod_choice; +pub const spa_pod_struct = struct_spa_pod_struct; +pub const spa_pod_object_body = struct_spa_pod_object_body; +pub const spa_pod_object = struct_spa_pod_object; +pub const spa_pod_pointer_body = struct_spa_pod_pointer_body; +pub const spa_pod_pointer = struct_spa_pod_pointer; +pub const spa_pod_fd = struct_spa_pod_fd; +pub const spa_pod_prop = struct_spa_pod_prop; +pub const spa_pod_control = struct_spa_pod_control; +pub const spa_pod_sequence_body = struct_spa_pod_sequence_body; +pub const spa_pod_sequence = struct_spa_pod_sequence; +pub const pw_protocol_client = struct_pw_protocol_client; +pub const pw_protocol_server = struct_pw_protocol_server; +pub const pw_protocol_marshal = struct_pw_protocol_marshal; +pub const pw_protocol_implementation = struct_pw_protocol_implementation; +pub const pw_protocol_events = struct_pw_protocol_events; +pub const pw_proxy_events = struct_pw_proxy_events; +pub const pw_permission = struct_pw_permission; +pub const pw_client_info = struct_pw_client_info; +pub const pw_client_events = struct_pw_client_events; +pub const pw_client_methods = struct_pw_client_methods; +pub const spa_json = struct_spa_json; +pub const pw_device = struct_pw_device; +pub const pw_device_info = struct_pw_device_info; +pub const pw_device_events = struct_pw_device_events; +pub const pw_device_methods = struct_pw_device_methods; +pub const spa_meta_type = enum_spa_meta_type; +pub const spa_meta = struct_spa_meta; +pub const spa_meta_header = struct_spa_meta_header; +pub const spa_meta_region = struct_spa_meta_region; +pub const spa_meta_bitmap = struct_spa_meta_bitmap; +pub const spa_meta_cursor = struct_spa_meta_cursor; +pub const spa_meta_control = struct_spa_meta_control; +pub const spa_meta_busy = struct_spa_meta_busy; +pub const spa_meta_videotransform_value = enum_spa_meta_videotransform_value; +pub const spa_meta_videotransform = struct_spa_meta_videotransform; +pub const spa_meta_sync_timeline = struct_spa_meta_sync_timeline; +pub const spa_data_type = enum_spa_data_type; +pub const spa_chunk = struct_spa_chunk; +pub const spa_data = struct_spa_data; +pub const spa_buffer = struct_spa_buffer; +pub const spa_event_body = struct_spa_event_body; +pub const spa_event = struct_spa_event; +pub const spa_node_event = enum_spa_node_event; +pub const spa_event_node = enum_spa_event_node; +pub const spa_command_body = struct_spa_command_body; +pub const spa_command = struct_spa_command; +pub const spa_node_command = enum_spa_node_command; +pub const spa_command_node = enum_spa_command_node; +pub const spa_node = struct_spa_node; +pub const spa_node_info = struct_spa_node_info; +pub const spa_port_info = struct_spa_port_info; +pub const spa_result_node_error = struct_spa_result_node_error; +pub const spa_result_node_params = struct_spa_result_node_params; +pub const spa_node_events = struct_spa_node_events; +pub const spa_node_callbacks = struct_spa_node_callbacks; +pub const spa_node_methods = struct_spa_node_methods; +pub const pw_memblock_flags = enum_pw_memblock_flags; +pub const pw_memmap_flags = enum_pw_memmap_flags; +pub const pw_memchunk = struct_pw_memchunk; +pub const pw_memmap = struct_pw_memmap; +pub const pw_memblock = struct_pw_memblock; +pub const pw_mempool_events = struct_pw_mempool_events; +pub const pw_map_range = struct_pw_map_range; +pub const pw_buffers = struct_pw_buffers; +pub const pw_factory = struct_pw_factory; +pub const pw_factory_info = struct_pw_factory_info; +pub const pw_factory_events = struct_pw_factory_events; +pub const pw_factory_methods = struct_pw_factory_methods; +pub const spa_log_level = enum_spa_log_level; +pub const spa_log = struct_spa_log; +pub const spa_log_topic = struct_spa_log_topic; +pub const spa_log_topic_enum = struct_spa_log_topic_enum; +pub const spa_log_methods = struct_spa_log_methods; +pub const pw_link = struct_pw_link; +pub const pw_link_state = enum_pw_link_state; +pub const pw_link_info = struct_pw_link_info; +pub const pw_link_events = struct_pw_link_events; +pub const pw_link_methods = struct_pw_link_methods; +pub const pw_main_loop = struct_pw_main_loop; +pub const pw_main_loop_events = struct_pw_main_loop_events; +pub const pw_map_item = union_pw_map_item; +pub const pw_map = struct_pw_map; +pub const pw_module = struct_pw_module; +pub const pw_module_info = struct_pw_module_info; +pub const pw_module_events = struct_pw_module_events; +pub const pw_module_methods = struct_pw_module_methods; +pub const pw_node = struct_pw_node; +pub const pw_node_state = enum_pw_node_state; +pub const pw_node_info = struct_pw_node_info; +pub const pw_node_events = struct_pw_node_events; +pub const pw_node_methods = struct_pw_node_methods; +pub const pw_port = struct_pw_port; +pub const pw_port_info = struct_pw_port_info; +pub const pw_port_events = struct_pw_port_events; +pub const pw_port_methods = struct_pw_port_methods; +pub const pw_stream = struct_pw_stream; +pub const pw_stream_state = enum_pw_stream_state; +pub const pw_buffer = struct_pw_buffer; +pub const pw_stream_control = struct_pw_stream_control; +pub const pw_time = struct_pw_time; +pub const pw_stream_events = struct_pw_stream_events; +pub const pw_stream_flags = enum_pw_stream_flags; +pub const pw_filter = struct_pw_filter; +pub const spa_io_type = enum_spa_io_type; +pub const spa_io_buffers = struct_spa_io_buffers; +pub const spa_io_memory = struct_spa_io_memory; +pub const spa_io_range = struct_spa_io_range; +pub const spa_io_clock = struct_spa_io_clock; +pub const spa_io_video_size = struct_spa_io_video_size; +pub const spa_io_latency = struct_spa_io_latency; +pub const spa_io_sequence = struct_spa_io_sequence; +pub const spa_io_segment_bar = struct_spa_io_segment_bar; +pub const spa_io_segment_video = struct_spa_io_segment_video; +pub const spa_io_segment = struct_spa_io_segment; +pub const spa_io_position_state = enum_spa_io_position_state; +pub const spa_io_position = struct_spa_io_position; +pub const spa_io_rate_match = struct_spa_io_rate_match; +pub const spa_io_async_buffers = struct_spa_io_async_buffers; +pub const pw_filter_state = enum_pw_filter_state; +pub const pw_filter_events = struct_pw_filter_events; +pub const pw_filter_flags = enum_pw_filter_flags; +pub const pw_filter_port_flags = enum_pw_filter_port_flags; +pub const pw_thread_loop = struct_pw_thread_loop; +pub const pw_thread_loop_events = struct_pw_thread_loop_events; +pub const spa_thread = struct_spa_thread; +pub const spa_thread_utils = struct_spa_thread_utils; +pub const spa_thread_utils_methods = struct_spa_thread_utils_methods; +pub const pw_data_loop_events = struct_pw_data_loop_events; +pub const pw_timer = struct_pw_timer; +pub const spa_pod_frame = struct_spa_pod_frame; +pub const spa_pod_parser_state = struct_spa_pod_parser_state; +pub const spa_pod_parser = struct_spa_pod_parser; +pub const spa_media_type = enum_spa_media_type; +pub const spa_media_subtype = enum_spa_media_subtype; +pub const spa_format = enum_spa_format; +pub const spa_video_chroma_site = enum_spa_video_chroma_site; +pub const spa_video_color_range = enum_spa_video_color_range; +pub const spa_video_color_matrix = enum_spa_video_color_matrix; +pub const spa_video_transfer_function = enum_spa_video_transfer_function; +pub const spa_video_color_primaries = enum_spa_video_color_primaries; +pub const spa_video_colorimetry = struct_spa_video_colorimetry; +pub const spa_video_multiview_mode = enum_spa_video_multiview_mode; +pub const spa_video_multiview_flags = enum_spa_video_multiview_flags; +pub const spa_video_format = enum_spa_video_format; +pub const spa_video_flags = enum_spa_video_flags; +pub const spa_video_interlace_mode = enum_spa_video_interlace_mode; +pub const spa_video_info_raw = struct_spa_video_info_raw; +pub const spa_video_info_dsp = struct_spa_video_info_dsp; +pub const spa_h264_stream_format = enum_spa_h264_stream_format; +pub const spa_h264_alignment = enum_spa_h264_alignment; +pub const spa_video_info_h264 = struct_spa_video_info_h264; +pub const spa_video_info_mjpg = struct_spa_video_info_mjpg; +pub const spa_video_info = struct_spa_video_info; +pub const spa_pod_builder_state = struct_spa_pod_builder_state; +pub const spa_pod_builder = struct_spa_pod_builder; +pub const spa_pod_builder_callbacks = struct_spa_pod_builder_callbacks; +pub const spa_h265_stream_format = enum_spa_h265_stream_format; +pub const spa_h265_alignment = enum_spa_h265_alignment; +pub const spa_video_info_h265 = struct_spa_video_info_h265; +pub const spa_debug_context = struct_spa_debug_context; +pub const spa_device_event = enum_spa_device_event; +pub const spa_event_device = enum_spa_event_device; +pub const spa_prop_info = enum_spa_prop_info; +pub const spa_prop = enum_spa_prop; +pub const spa_audio_format = enum_spa_audio_format; +pub const spa_audio_channel = enum_spa_audio_channel; +pub const spa_audio_volume_ramp_scale = enum_spa_audio_volume_ramp_scale; +pub const spa_audio_info_raw = struct_spa_audio_info_raw; +pub const spa_audio_iec958_codec = enum_spa_audio_iec958_codec; +pub const spa_audio_info_iec958 = struct_spa_audio_info_iec958; +pub const spa_audio_mp3_channel_mode = enum_spa_audio_mp3_channel_mode; +pub const spa_audio_info_mp3 = struct_spa_audio_info_mp3; +pub const spa_audio_aac_stream_format = enum_spa_audio_aac_stream_format; +pub const spa_audio_info_aac = struct_spa_audio_info_aac; +pub const spa_audio_wma_profile = enum_spa_audio_wma_profile; +pub const spa_audio_info_wma = struct_spa_audio_info_wma; +pub const spa_audio_amr_band_mode = enum_spa_audio_amr_band_mode; +pub const spa_audio_info_amr = struct_spa_audio_info_amr; +pub const spa_audio_dts_ext_type = enum_spa_audio_dts_ext_type; +pub const spa_audio_info_dts = struct_spa_audio_info_dts; +pub const spa_bluetooth_audio_codec = enum_spa_bluetooth_audio_codec; +pub const spa_control_type = enum_spa_control_type; +pub const spa_param_latency = enum_spa_param_latency; +pub const spa_latency_info = struct_spa_latency_info; +pub const spa_param_process_latency = enum_spa_param_process_latency; +pub const spa_process_latency_info = struct_spa_process_latency_info; +pub const spa_profiler = enum_spa_profiler; +pub const spa_param_tag = enum_spa_param_tag; +pub const spa_tag_info = struct_spa_tag_info; From 35059f98bbf97d3b19ab5c5281e481dcf84e7fa7 Mon Sep 17 00:00:00 2001 From: Mason Remaley Date: Fri, 14 Nov 2025 15:23:39 -0800 Subject: [PATCH 10/11] Fixes bitcasts of sizeofs --- src/c.zig | 72 +++++++++++++++++++++++++++---------------------------- 1 file changed, 36 insertions(+), 36 deletions(-) diff --git a/src/c.zig b/src/c.zig index 268275c..3d7d3c6 100644 --- a/src/c.zig +++ b/src/c.zig @@ -7412,7 +7412,7 @@ pub fn pw_map_for_each(arg_map: [*c]const struct_pw_map, arg_func: ?*const fn (? _ = &res; { item = @as(@TypeOf(item), @ptrCast(@alignCast((&map.*.items).*.data))); - while (@as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(item))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(union_pw_map_item))))))) <= @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr((&map.*.items).*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast((&map.*.items).*.size))))))) : (item += 1) { + while (@as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(item))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(union_pw_map_item)))))))) <= @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr((&map.*.items).*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast((&map.*.items).*.size))))))) : (item += 1) { if (!((item.*.next & @as(usize, @bitCast(@as(c_long, @as(c_int, 1))))) != 0)) if ((blk: { const tmp = func.?(item.*.data, data); res = tmp; @@ -8542,7 +8542,7 @@ pub fn spa_pod_parser_pod(arg_parser: [*c]struct_spa_pod_parser, arg_pod: [*c]co _ = &parser; var pod = arg_pod; _ = &pod; - spa_pod_parser_init(parser, @as(?*const anyopaque, @ptrCast(pod)), @as(u32, @bitCast(@as(c_uint, @truncate(@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size)))))))); + spa_pod_parser_init(parser, @as(?*const anyopaque, @ptrCast(pod)), @as(u32, @bitCast(@as(c_uint, @truncate(@as(u64, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size)))))))); } pub fn spa_pod_parser_init_pod_body(arg_parser: [*c]struct_spa_pod_parser, arg_pod: [*c]const struct_spa_pod, arg_body: ?*const anyopaque) callconv(.c) void { var parser = arg_parser; @@ -8651,7 +8651,7 @@ pub fn spa_pod_parser_get_header(arg_parser: [*c]struct_spa_pod_parser, arg_head _ = &body; var f: [*c]struct_spa_pod_frame = parser.*.state.frame; _ = &f; - var size: u32 = @as(u32, @bitCast(@as(c_uint, @truncate(if (f != null) @as(u64, @bitCast(@as(c_ulong, f.*.offset))) +% (@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, (&f.*.pod).*.size)))) else @as(u64, @bitCast(@as(c_ulong, parser.*.size))))))); + var size: u32 = @as(u32, @bitCast(@as(c_uint, @truncate(if (f != null) @as(u64, @bitCast(@as(c_ulong, f.*.offset))) +% (@as(u64, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))) +% @as(u64, @bitCast(@as(c_ulong, (&f.*.pod).*.size)))) else @as(u64, @bitCast(@as(c_ulong, parser.*.size))))))); _ = &size; return spa_pod_parser_read_header(parser, parser.*.state.offset, size, header, header_size, pod_offset, body); } @@ -8679,7 +8679,7 @@ pub fn spa_pod_parser_advance(arg_parser: [*c]struct_spa_pod_parser, arg_pod: [* _ = &parser; var pod = arg_pod; _ = &pod; - parser.*.state.offset +%= @as(u32, @bitCast(@as(c_uint, @truncate((((@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size)))) -% @as(u64, @bitCast(@as(c_long, @as(c_int, 1))))) | @as(@TypeOf(@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size)))), @bitCast(@as(c_long, @as(c_int, 8) - @as(c_int, 1))))) +% @as(u64, @bitCast(@as(c_long, @as(c_int, 1)))))))); + parser.*.state.offset +%= @as(u32, @bitCast(@as(c_uint, @truncate((((@as(u64, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size)))) -% @as(u64, @bitCast(@as(c_long, @as(c_int, 1))))) | @as(@TypeOf(@as(u64, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size)))), @bitCast(@as(c_long, @as(c_int, 8) - @as(c_int, 1))))) +% @as(u64, @bitCast(@as(c_long, @as(c_int, 1)))))))); } pub fn spa_pod_parser_next_body(arg_parser: [*c]struct_spa_pod_parser, arg_pod: [*c]struct_spa_pod, arg_body: [*c]?*const anyopaque) callconv(.c) c_int { var parser = arg_parser; @@ -9337,7 +9337,7 @@ pub fn spa_pod_parser_can_collect(arg_pod: [*c]const struct_spa_pod, arg_type: u _ = &pod; var @"type" = arg_type; _ = &@"type"; - return spa_pod_parser_body_can_collect(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), @"type"); + return spa_pod_parser_body_can_collect(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), @"type"); } // /home/mason/.cache/zig/p/N-V-__8AAN5NhBR0oTsvnwjPdeNiiDLtEsfXRHd1fv-R3TOv/lib/include/__stdarg_va_arg.h:20:26: warning: unsupported stmt class VAArgExprClass @@ -9460,7 +9460,7 @@ pub fn spa_format_parse(arg_format: [*c]const struct_spa_pod, arg_media_type: [* return blk: { var _p: struct_spa_pod_parser = undefined; _ = &_p; - spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod)))))))); + spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod))))))))); break :blk blk_1: { var _f: struct_spa_pod_frame = undefined; _ = &_f; @@ -9731,12 +9731,12 @@ pub fn spa_pod_is_inside(arg_pod: ?*const anyopaque, arg_size: u32, arg_iter: ?* pub fn spa_pod_next(arg_iter: ?*const anyopaque) callconv(.c) ?*anyopaque { var iter = arg_iter; _ = &iter; - return @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(iter))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast((((@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(iter)))).*.size)))) -% @as(u64, @bitCast(@as(c_long, @as(c_int, 1))))) | @as(@TypeOf(@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(iter)))).*.size)))), @bitCast(@as(c_long, @as(c_int, 8) - @as(c_int, 1))))) +% @as(u64, @bitCast(@as(c_long, @as(c_int, 1)))))))))); + return @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(iter))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast((((@as(u64, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(iter)))).*.size)))) -% @as(u64, @bitCast(@as(c_long, @as(c_int, 1))))) | @as(@TypeOf(@as(u64, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(iter)))).*.size)))), @bitCast(@as(c_long, @as(c_int, 8) - @as(c_int, 1))))) +% @as(u64, @bitCast(@as(c_long, @as(c_int, 1)))))))))); } pub fn spa_pod_prop_first(arg_body: [*c]const struct_spa_pod_object_body) callconv(.c) [*c]struct_spa_pod_prop { var body = arg_body; _ = &body; - return @as([*c]struct_spa_pod_prop, @ptrFromInt(@as(usize, @intCast(@intFromPtr(body))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod_object_body))))))); + return @as([*c]struct_spa_pod_prop, @ptrFromInt(@as(usize, @intCast(@intFromPtr(body))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod_object_body)))))))); } pub fn spa_pod_prop_is_inside(arg_body: [*c]const struct_spa_pod_object_body, arg_size: u32, arg_iter: [*c]const struct_spa_pod_prop) callconv(.c) bool { var body = arg_body; @@ -9757,7 +9757,7 @@ pub fn spa_pod_prop_next(arg_iter: [*c]const struct_spa_pod_prop) callconv(.c) [ pub fn spa_pod_control_first(arg_body: [*c]const struct_spa_pod_sequence_body) callconv(.c) [*c]struct_spa_pod_control { var body = arg_body; _ = &body; - return @as([*c]struct_spa_pod_control, @ptrFromInt(@as(usize, @intCast(@intFromPtr(body))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod_sequence_body))))))); + return @as([*c]struct_spa_pod_control, @ptrFromInt(@as(usize, @intCast(@intFromPtr(body))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod_sequence_body)))))))); } pub fn spa_pod_control_is_inside(arg_body: [*c]const struct_spa_pod_sequence_body, arg_size: u32, arg_iter: [*c]const struct_spa_pod_control) callconv(.c) bool { var body = arg_body; @@ -9796,49 +9796,49 @@ pub fn spa_pod_get_bool(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]bool) _ = &pod; var value = arg_value; _ = &value; - return spa_pod_body_get_bool(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); + return spa_pod_body_get_bool(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), value); } pub fn spa_pod_get_id(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]u32) callconv(.c) c_int { var pod = arg_pod; _ = &pod; var value = arg_value; _ = &value; - return spa_pod_body_get_id(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); + return spa_pod_body_get_id(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), value); } pub fn spa_pod_get_int(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]i32) callconv(.c) c_int { var pod = arg_pod; _ = &pod; var value = arg_value; _ = &value; - return spa_pod_body_get_int(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); + return spa_pod_body_get_int(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), value); } pub fn spa_pod_get_long(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]i64) callconv(.c) c_int { var pod = arg_pod; _ = &pod; var value = arg_value; _ = &value; - return spa_pod_body_get_long(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); + return spa_pod_body_get_long(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), value); } pub fn spa_pod_get_float(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]f32) callconv(.c) c_int { var pod = arg_pod; _ = &pod; var value = arg_value; _ = &value; - return spa_pod_body_get_float(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); + return spa_pod_body_get_float(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), value); } pub fn spa_pod_get_double(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]f64) callconv(.c) c_int { var pod = arg_pod; _ = &pod; var value = arg_value; _ = &value; - return spa_pod_body_get_double(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); + return spa_pod_body_get_double(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), value); } pub fn spa_pod_get_string(arg_pod: [*c]const struct_spa_pod, arg_value: [*c][*c]const u8) callconv(.c) c_int { var pod = arg_pod; _ = &pod; var value = arg_value; _ = &value; - return spa_pod_body_get_string(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); + return spa_pod_body_get_string(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), value); } pub fn spa_pod_copy_string(arg_pod: [*c]const struct_spa_pod, arg_maxlen: usize, arg_dest: [*c]u8) callconv(.c) c_int { var pod = arg_pod; @@ -9847,7 +9847,7 @@ pub fn spa_pod_copy_string(arg_pod: [*c]const struct_spa_pod, arg_maxlen: usize, _ = &maxlen; var dest = arg_dest; _ = &dest; - return spa_pod_body_copy_string(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), dest, maxlen); + return spa_pod_body_copy_string(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), dest, maxlen); } pub fn spa_pod_get_bytes(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]?*const anyopaque, arg_len: [*c]u32) callconv(.c) c_int { var pod = arg_pod; @@ -9856,7 +9856,7 @@ pub fn spa_pod_get_bytes(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]?*con _ = &value; var len = arg_len; _ = &len; - return spa_pod_body_get_bytes(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value, len); + return spa_pod_body_get_bytes(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), value, len); } pub fn spa_pod_get_pointer(arg_pod: [*c]const struct_spa_pod, arg_type: [*c]u32, arg_value: [*c]?*const anyopaque) callconv(.c) c_int { var pod = arg_pod; @@ -9865,28 +9865,28 @@ pub fn spa_pod_get_pointer(arg_pod: [*c]const struct_spa_pod, arg_type: [*c]u32, _ = &@"type"; var value = arg_value; _ = &value; - return spa_pod_body_get_pointer(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), @"type", value); + return spa_pod_body_get_pointer(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), @"type", value); } pub fn spa_pod_get_fd(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]i64) callconv(.c) c_int { var pod = arg_pod; _ = &pod; var value = arg_value; _ = &value; - return spa_pod_body_get_fd(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); + return spa_pod_body_get_fd(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), value); } pub fn spa_pod_get_rectangle(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]struct_spa_rectangle) callconv(.c) c_int { var pod = arg_pod; _ = &pod; var value = arg_value; _ = &value; - return spa_pod_body_get_rectangle(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); + return spa_pod_body_get_rectangle(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), value); } pub fn spa_pod_get_fraction(arg_pod: [*c]const struct_spa_pod, arg_value: [*c]struct_spa_fraction) callconv(.c) c_int { var pod = arg_pod; _ = &pod; var value = arg_value; _ = &value; - return spa_pod_body_get_fraction(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), value); + return spa_pod_body_get_fraction(pod, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), value); } pub fn spa_pod_get_array_full(arg_pod: [*c]const struct_spa_pod, arg_n_values: [*c]u32, arg_val_size: [*c]u32, arg_val_type: [*c]u32) callconv(.c) ?*anyopaque { var pod = arg_pod; @@ -9897,7 +9897,7 @@ pub fn spa_pod_get_array_full(arg_pod: [*c]const struct_spa_pod, arg_n_values: [ _ = &val_size; var val_type = arg_val_type; _ = &val_type; - return @as(?*anyopaque, @ptrCast(@constCast(@volatileCast(spa_pod_body_get_array_values(pod, @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), n_values, val_size, val_type))))); + return @as(?*anyopaque, @ptrCast(@constCast(@volatileCast(spa_pod_body_get_array_values(pod, @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(pod))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), n_values, val_size, val_type))))); } pub fn spa_pod_get_array(arg_pod: [*c]const struct_spa_pod, arg_n_values: [*c]u32) callconv(.c) ?*anyopaque { var pod = arg_pod; @@ -9954,7 +9954,7 @@ pub fn spa_pod_get_values(arg_pod: [*c]const struct_spa_pod, arg_n_vals: [*c]u32 _ = &@"type"; var size: u32 = undefined; _ = &size; - _ = spa_pod_choice_body_get_values(p, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(p))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), n_vals, choice, &size, &@"type"); + _ = spa_pod_choice_body_get_values(p, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(p))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), n_vals, choice, &size, &@"type"); return @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(&p.*.body.child)))); } else { n_vals.* = 1; @@ -10162,7 +10162,7 @@ pub fn spa_pod_builder_deref_fallback(arg_builder: [*c]struct_spa_pod_builder, a if ((@as(c_ulong, @bitCast(@as(c_ulong, offset))) +% @as(c_ulong, 8)) <= @as(c_ulong, @bitCast(@as(c_ulong, size)))) { var pod: [*c]struct_spa_pod = @as([*c]struct_spa_pod, @ptrFromInt(@as(usize, @intCast(@intFromPtr(builder.*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, offset))))))); _ = &pod; - if (((@as(u64, @bitCast(@as(c_ulong, offset))) +% (@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, pod.*.size))))) <= @as(u64, @bitCast(@as(c_ulong, size)))) and (pod.*.size < (@as(c_uint, 1) << @intCast(20)))) return pod; + if (((@as(u64, @bitCast(@as(c_ulong, offset))) +% (@as(u64, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))) +% @as(u64, @bitCast(@as(c_ulong, pod.*.size))))) <= @as(u64, @bitCast(@as(c_ulong, size)))) and (pod.*.size < (@as(c_uint, 1) << @intCast(20)))) return pod; } return fallback; } @@ -10178,7 +10178,7 @@ pub fn spa_pod_builder_frame(arg_builder: [*c]struct_spa_pod_builder, arg_frame: _ = &builder; var frame = arg_frame; _ = &frame; - if ((@as(u64, @bitCast(@as(c_ulong, frame.*.offset))) +% (@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, (&frame.*.pod).*.size))))) <= @as(u64, @bitCast(@as(c_ulong, builder.*.size)))) return @as([*c]struct_spa_pod, @ptrFromInt(@as(usize, @intCast(@intFromPtr(builder.*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, frame.*.offset))))))); + if ((@as(u64, @bitCast(@as(c_ulong, frame.*.offset))) +% (@as(u64, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))) +% @as(u64, @bitCast(@as(c_ulong, (&frame.*.pod).*.size))))) <= @as(u64, @bitCast(@as(c_ulong, builder.*.size)))) return @as([*c]struct_spa_pod, @ptrFromInt(@as(usize, @intCast(@intFromPtr(builder.*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, frame.*.offset))))))); return null; } pub fn spa_pod_builder_push(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame, arg_pod: [*c]const struct_spa_pod, arg_offset: u32) callconv(.c) void { @@ -10351,7 +10351,7 @@ pub fn spa_pod_builder_primitive_body(arg_builder: [*c]struct_spa_pod_builder, a _ = &res; var r: c_int = undefined; _ = &r; - var size: u32 = @as(u32, @bitCast(@as(c_uint, @truncate(((@as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(p)))).*.size)))) -% @as(u64, @bitCast(@as(c_ulong, body_size)))) -% @as(u64, @bitCast(@as(c_ulong, suffix_size))))))); + var size: u32 = @as(u32, @bitCast(@as(c_uint, @truncate(((@as(u64, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(p)))).*.size)))) -% @as(u64, @bitCast(@as(c_ulong, body_size)))) -% @as(u64, @bitCast(@as(c_ulong, suffix_size))))))); _ = &size; if (builder.*.state.flags != @as(u32, @bitCast(@as(c_int, 1) << @intCast(0)))) { { @@ -10391,7 +10391,7 @@ pub fn spa_pod_builder_primitive(arg_builder: [*c]struct_spa_pod_builder, arg_p: _ = &builder; var p = arg_p; _ = &p; - return spa_pod_builder_primitive_body(builder, p, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(p))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))), p.*.size, null, @as(u32, @bitCast(@as(c_int, 0)))); + return spa_pod_builder_primitive_body(builder, p, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(p))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), p.*.size, null, @as(u32, @bitCast(@as(c_int, 0)))); } pub fn spa_pod_builder_none(arg_builder: [*c]struct_spa_pod_builder) callconv(.c) c_int { var builder = arg_builder; @@ -10889,7 +10889,7 @@ pub fn spa_pod_copy(arg_pod: [*c]const struct_spa_pod) callconv(.c) [*c]struct_s _ = &size; var c: [*c]struct_spa_pod = undefined; _ = &c; - size = @as(u64, @bitCast(@sizeOf(struct_spa_pod))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size))); + size = @as(u64, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))) +% @as(u64, @bitCast(@as(c_ulong, @as([*c]struct_spa_pod, @ptrCast(@constCast(@volatileCast(pod)))).*.size))); if ((blk: { const tmp = @as([*c]struct_spa_pod, @ptrCast(@alignCast(malloc(size)))); c = tmp; @@ -10918,7 +10918,7 @@ pub fn spa_format_video_raw_parse(arg_format: [*c]const struct_spa_pod, arg_info return blk: { var _p: struct_spa_pod_parser = undefined; _ = &_p; - spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod)))))))); + spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod))))))))); break :blk blk_1: { var _f: struct_spa_pod_frame = undefined; _ = &_f; @@ -11028,7 +11028,7 @@ pub fn spa_format_video_dsp_parse(arg_format: [*c]const struct_spa_pod, arg_info return blk: { var _p: struct_spa_pod_parser = undefined; _ = &_p; - spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod)))))))); + spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod))))))))); break :blk blk_1: { var _f: struct_spa_pod_frame = undefined; _ = &_f; @@ -11074,7 +11074,7 @@ pub fn spa_format_video_h264_parse(arg_format: [*c]const struct_spa_pod, arg_inf return blk: { var _p: struct_spa_pod_parser = undefined; _ = &_p; - spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod)))))))); + spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod))))))))); break :blk blk_1: { var _f: struct_spa_pod_frame = undefined; _ = &_f; @@ -11144,7 +11144,7 @@ pub fn spa_format_video_h265_parse(arg_format: [*c]const struct_spa_pod, arg_inf return blk: { var _p: struct_spa_pod_parser = undefined; _ = &_p; - spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod)))))))); + spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod))))))))); break :blk blk_1: { var _f: struct_spa_pod_frame = undefined; _ = &_f; @@ -11198,7 +11198,7 @@ pub fn spa_format_video_mjpg_parse(arg_format: [*c]const struct_spa_pod, arg_inf return blk: { var _p: struct_spa_pod_parser = undefined; _ = &_p; - spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod)))))))); + spa_pod_parser_init_pod_body(&_p, format, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(format))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod))))))))); break :blk blk_1: { var _f: struct_spa_pod_frame = undefined; _ = &_f; @@ -16855,7 +16855,7 @@ pub fn spa_debug_strbuf_format_value(arg_buffer: [*c]struct_spa_strbuf, arg_info _ = spa_strbuf_append(buffer, "< "); if (b.*.child.size >= spa_pod_type_size(b.*.child.type)) { { - p = @as(@TypeOf(p), @ptrCast(@as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(b))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod_array_body))))))))); + p = @as(@TypeOf(p), @ptrCast(@as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(b))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod_array_body)))))))))); while ((b.*.child.size > @as(u32, @bitCast(@as(c_int, 0)))) and (@as(c_int, @intFromBool(spa_ptrinside(@as(?*const anyopaque, @ptrCast(b)), @as(usize, @bitCast(@as(c_ulong, size))), p, @as(usize, @bitCast(@as(c_ulong, b.*.child.size))), null))) != 0)) : (p = @as(@TypeOf(p), @ptrCast(@as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(p))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, b.*.child.size)))))))))) { if ((blk: { const ref = &i; @@ -16957,7 +16957,7 @@ pub fn spa_debugc_format(arg_ctx: [*c]struct_spa_debug_context, arg_indent: c_in @"type" = val.*.type; size = val.*.size; if ((((@"type" < @as(u32, @bitCast(SPA_TYPE_None))) or (@"type" >= @as(u32, @bitCast(_SPA_TYPE_LAST)))) or (n_vals < @as(u32, @bitCast(@as(c_int, 1))))) or (size < spa_pod_type_size(@"type"))) continue; - vals = @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(val))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@sizeOf(struct_spa_pod))))))); + vals = @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(val))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))); ti = spa_debug_type_find(info, prop.*.key); key = if (ti != null) ti.*.name else null; spa_strbuf_init(&buf, @as([*c]u8, @ptrCast(@alignCast(&buffer[@as(usize, @intCast(0))]))), @sizeOf([1024]u8)); From df3ec15fe67a40bc7316ea1d54b55955e83489f6 Mon Sep 17 00:00:00 2001 From: Mason Remaley Date: Fri, 14 Nov 2025 16:21:06 -0800 Subject: [PATCH 11/11] WIP: progress porting example to Zig --- build.zig | 42 +++ build.zig.zon | 4 + src/c.zig | 109 +++--- src/screen_play.zig | 842 ++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 943 insertions(+), 54 deletions(-) create mode 100644 src/screen_play.zig diff --git a/build.zig b/build.zig index e5ec658..009eff5 100644 --- a/build.zig +++ b/build.zig @@ -321,6 +321,42 @@ pub fn build(b: *std.Build) void { run_cmd.addArgs(args); } } + + { + const zin = b.dependency("zin", .{ + .optimize = optimize, + .target = target, + }); + + const screen_play = b.addExecutable(.{ + .name = "zscreen_play", + .root_module = b.createModule(.{ + .root_source_file = b.path("src/screen_play.zig"), + .target = target, + .optimize = optimize, + .imports = &.{ + .{ .name = "zin", .module = zin.module("zin") }, + }, + }), + }); + screen_play.addIncludePath(b.path("src")); // XXX: temp + b.installArtifact(screen_play); + + var dep: std.Build.Dependency = .{ .builder = b }; + linkAndInstall(b, &dep, screen_play); + + const run_step = b.step("zscreen-play", "Run the screen-play example"); + + const run_cmd = b.addRunArtifact(screen_play); + run_cmd.setCwd(.{ .cwd_relative = b.getInstallPath(.bin, "") }); + run_step.dependOn(&run_cmd.step); + + run_cmd.step.dependOn(b.getInstallStep()); + + if (b.args) |args| { + run_cmd.addArgs(args); + } + } } /// You may call this externally to link to libpipewire and install its dependencies alongside the @@ -349,6 +385,12 @@ const flags: []const []const u8 = &.{ "-Wno-pedantic", "-D_GNU_SOURCE", "-DFASTPATH", + // Translate C can't translate some of the variadic functions API so they get demoted to + // externs. However, since they're present only in headers and marked as `SPA_API_IMPL` which + // which defaults to `static inline`, the symbols end up being missing. We instead mark them as + // weak so that we don't get duplicate symbols, but are still able to reference the C + // implementations. + "-DSPA_API_IMPL=__attribute__((weak))", }; pub const PluginAndModuleCtx = struct { diff --git a/build.zig.zon b/build.zig.zon index a3888ec..8a2f58e 100644 --- a/build.zig.zon +++ b/build.zig.zon @@ -20,6 +20,10 @@ .url = "git+https://github.com/allyourcodebase/SDL3#af9c32ce4824e0ad4337447434c40f2b672faf94", .hash = "sdl-0.0.0-i4QD0btgqAABajEXrQnyZr1xVsk7LM48w2nBmuQ5gdfr", }, + .zin = .{ + .url = "git+https://github.com/marler8997/zin#d3e230690f09debdb99dffe4586ad19f9dfb4716", + .hash = "zin-0.0.0-W7QDx6kKAwCVg-wWMO4FdpvZMH66NJpc9wFDdxp5c8E2", + }, }, .paths = .{ "LICENSE", diff --git a/src/c.zig b/src/c.zig index 3d7d3c6..a3cf37b 100644 --- a/src/c.zig +++ b/src/c.zig @@ -7,6 +7,8 @@ //! file has the fix applied manually, I'll delete this file and upstream a real patch to translate //! C soon. //! +//! Also replaced a number of string literals with the matching literals coerced to `[*c]const u8`. +//! //! Source generated by: //! ``` //! const c = @cImport({ @@ -16,7 +18,6 @@ //! @cInclude("spa/debug/format.h"); //! }); //! - pub const __builtin_bswap16 = @import("std").zig.c_builtins.__builtin_bswap16; pub const __builtin_bswap32 = @import("std").zig.c_builtins.__builtin_bswap32; pub const __builtin_bswap64 = @import("std").zig.c_builtins.__builtin_bswap64; @@ -8551,7 +8552,7 @@ pub fn spa_pod_parser_init_pod_body(arg_parser: [*c]struct_spa_pod_parser, arg_p _ = &pod; var body = arg_body; _ = &body; - spa_pod_parser_init(parser, @as(?*const anyopaque, @ptrCast(@as([*c]const struct_spa_pod, @ptrFromInt(@as(usize, @intCast(@intFromPtr(body))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(-%@sizeOf(struct_spa_pod))))))))), @as(u32, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) +% @sizeOf(struct_spa_pod)))))); + spa_pod_parser_init(parser, @as(?*const anyopaque, @ptrCast(@as([*c]const struct_spa_pod, @ptrFromInt(@as(usize, @intCast(@intFromPtr(body))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(-%@as(usize, @sizeOf(struct_spa_pod)))))))))), @as(u32, @bitCast(@as(c_uint, @truncate(@as(c_ulong, @bitCast(@as(c_ulong, pod.*.size))) +% @sizeOf(struct_spa_pod)))))); } pub fn spa_pod_parser_init_from_data(arg_parser: [*c]struct_spa_pod_parser, arg_data: ?*const anyopaque, arg_maxsize: u32, arg_offset: u32, arg_size: u32) callconv(.c) void { var parser = arg_parser; @@ -10081,19 +10082,19 @@ pub const struct_spa_pod_builder_callbacks = extern struct { version: u32 = @import("std").mem.zeroes(u32), overflow: ?*const fn (?*anyopaque, u32) callconv(.c) c_int = @import("std").mem.zeroes(?*const fn (?*anyopaque, u32) callconv(.c) c_int), }; -pub fn spa_pod_builder_get_state(arg_builder: [*c]struct_spa_pod_builder, arg_state: [*c]struct_spa_pod_builder_state) callconv(.c) void { +pub export fn spa_pod_builder_get_state(arg_builder: [*c]struct_spa_pod_builder, arg_state: [*c]struct_spa_pod_builder_state) void { var builder = arg_builder; _ = &builder; var state = arg_state; _ = &state; state.* = builder.*.state; } -pub fn spa_pod_builder_corrupted(arg_builder: [*c]const struct_spa_pod_builder) callconv(.c) bool { +pub export fn spa_pod_builder_corrupted(arg_builder: [*c]const struct_spa_pod_builder) bool { var builder = arg_builder; _ = &builder; return builder.*.state.offset > builder.*.size; } -pub fn spa_pod_builder_set_callbacks(arg_builder: [*c]struct_spa_pod_builder, arg_callbacks: [*c]const struct_spa_pod_builder_callbacks, arg_data: ?*anyopaque) callconv(.c) void { +pub export fn spa_pod_builder_set_callbacks(arg_builder: [*c]struct_spa_pod_builder, arg_callbacks: [*c]const struct_spa_pod_builder_callbacks, arg_data: ?*anyopaque) void { var builder = arg_builder; _ = &builder; var callbacks = arg_callbacks; @@ -10105,7 +10106,7 @@ pub fn spa_pod_builder_set_callbacks(arg_builder: [*c]struct_spa_pod_builder, ar .data = data, }; } -pub fn spa_pod_builder_reset(arg_builder: [*c]struct_spa_pod_builder, arg_state: [*c]struct_spa_pod_builder_state) callconv(.c) void { +pub export fn spa_pod_builder_reset(arg_builder: [*c]struct_spa_pod_builder, arg_state: [*c]struct_spa_pod_builder_state) void { var builder = arg_builder; _ = &builder; var state = arg_state; @@ -10128,7 +10129,7 @@ pub fn spa_pod_builder_reset(arg_builder: [*c]struct_spa_pod_builder, arg_state: } } } -pub fn spa_pod_builder_init(arg_builder: [*c]struct_spa_pod_builder, arg_data: ?*anyopaque, arg_size: u32) callconv(.c) void { +pub export fn spa_pod_builder_init(arg_builder: [*c]struct_spa_pod_builder, arg_data: ?*anyopaque, arg_size: u32) void { var builder = arg_builder; _ = &builder; var data = arg_data; @@ -10150,7 +10151,7 @@ pub fn spa_pod_builder_init(arg_builder: [*c]struct_spa_pod_builder, arg_data: ? }, }; } -pub fn spa_pod_builder_deref_fallback(arg_builder: [*c]struct_spa_pod_builder, arg_offset: u32, arg_fallback: [*c]struct_spa_pod) callconv(.c) [*c]struct_spa_pod { +pub export fn spa_pod_builder_deref_fallback(arg_builder: [*c]struct_spa_pod_builder, arg_offset: u32, arg_fallback: [*c]struct_spa_pod) [*c]struct_spa_pod { var builder = arg_builder; _ = &builder; var offset = arg_offset; @@ -10166,14 +10167,14 @@ pub fn spa_pod_builder_deref_fallback(arg_builder: [*c]struct_spa_pod_builder, a } return fallback; } -pub fn spa_pod_builder_deref(arg_builder: [*c]struct_spa_pod_builder, arg_offset: u32) callconv(.c) [*c]struct_spa_pod { +pub export fn spa_pod_builder_deref(arg_builder: [*c]struct_spa_pod_builder, arg_offset: u32) [*c]struct_spa_pod { var builder = arg_builder; _ = &builder; var offset = arg_offset; _ = &offset; return spa_pod_builder_deref_fallback(builder, offset, null); } -pub fn spa_pod_builder_frame(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame) callconv(.c) [*c]struct_spa_pod { +pub export fn spa_pod_builder_frame(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame) [*c]struct_spa_pod { var builder = arg_builder; _ = &builder; var frame = arg_frame; @@ -10181,7 +10182,7 @@ pub fn spa_pod_builder_frame(arg_builder: [*c]struct_spa_pod_builder, arg_frame: if ((@as(u64, @bitCast(@as(c_ulong, frame.*.offset))) +% (@as(u64, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))) +% @as(u64, @bitCast(@as(c_ulong, (&frame.*.pod).*.size))))) <= @as(u64, @bitCast(@as(c_ulong, builder.*.size)))) return @as([*c]struct_spa_pod, @ptrFromInt(@as(usize, @intCast(@intFromPtr(builder.*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, frame.*.offset))))))); return null; } -pub fn spa_pod_builder_push(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame, arg_pod: [*c]const struct_spa_pod, arg_offset: u32) callconv(.c) void { +pub export fn spa_pod_builder_push(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame, arg_pod: [*c]const struct_spa_pod, arg_offset: u32) void { var builder = arg_builder; _ = &builder; var frame = arg_frame; @@ -10199,7 +10200,7 @@ pub fn spa_pod_builder_push(arg_builder: [*c]struct_spa_pod_builder, arg_frame: builder.*.state.flags = @as(u32, @bitCast((@as(c_int, 1) << @intCast(1)) | (@as(c_int, 1) << @intCast(0)))); } } -pub fn spa_pod_builder_raw(arg_builder: [*c]struct_spa_pod_builder, arg_data: ?*const anyopaque, arg_size: u32) callconv(.c) c_int { +pub export fn spa_pod_builder_raw(arg_builder: [*c]struct_spa_pod_builder, arg_data: ?*const anyopaque, arg_size: u32) c_int { var builder = arg_builder; _ = &builder; var data = arg_data; @@ -10248,7 +10249,7 @@ pub fn spa_pod_builder_raw(arg_builder: [*c]struct_spa_pod_builder, arg_data: ?* } return res; } -pub fn spa_pod_builder_remove(arg_builder: [*c]struct_spa_pod_builder, arg_size: u32) callconv(.c) void { +pub export fn spa_pod_builder_remove(arg_builder: [*c]struct_spa_pod_builder, arg_size: u32) void { var builder = arg_builder; _ = &builder; var size = arg_size; @@ -10275,7 +10276,7 @@ pub fn spa_pod_builder_remove(arg_builder: [*c]struct_spa_pod_builder, arg_size: } } } -pub fn spa_pod_builder_pad(arg_builder: [*c]struct_spa_pod_builder, arg_size: u32) callconv(.c) c_int { +pub export fn spa_pod_builder_pad(arg_builder: [*c]struct_spa_pod_builder, arg_size: u32) c_int { var builder = arg_builder; _ = &builder; var size = arg_size; @@ -10286,7 +10287,7 @@ pub fn spa_pod_builder_pad(arg_builder: [*c]struct_spa_pod_builder, arg_size: u3 size = (((size -% @as(u32, @bitCast(@as(c_int, 1)))) | @as(@TypeOf(size), @bitCast(@as(c_int, 8) - @as(c_int, 1)))) +% @as(u32, @bitCast(@as(c_int, 1)))) -% size; return if (size != 0) spa_pod_builder_raw(builder, @as(?*const anyopaque, @ptrCast(&zeroes)), size) else @as(c_int, 0); } -pub fn spa_pod_builder_raw_padded(arg_builder: [*c]struct_spa_pod_builder, arg_data: ?*const anyopaque, arg_size: u32) callconv(.c) c_int { +pub export fn spa_pod_builder_raw_padded(arg_builder: [*c]struct_spa_pod_builder, arg_data: ?*const anyopaque, arg_size: u32) c_int { var builder = arg_builder; _ = &builder; var data = arg_data; @@ -10306,7 +10307,7 @@ pub fn spa_pod_builder_raw_padded(arg_builder: [*c]struct_spa_pod_builder, arg_d } return res; } -pub fn spa_pod_builder_pop(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame) callconv(.c) ?*anyopaque { +pub export fn spa_pod_builder_pop(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame) ?*anyopaque { var builder = arg_builder; _ = &builder; var frame = arg_frame; @@ -10334,7 +10335,7 @@ pub fn spa_pod_builder_pop(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [ return @as(?*anyopaque, @ptrCast(pod)); } // .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:27:50: warning: ignoring StaticAssert declaration -pub fn spa_pod_builder_primitive_body(arg_builder: [*c]struct_spa_pod_builder, arg_p: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_body_size: u32, arg_suffix: [*c]const u8, arg_suffix_size: u32) callconv(.c) c_int { +pub export fn spa_pod_builder_primitive_body(arg_builder: [*c]struct_spa_pod_builder, arg_p: [*c]const struct_spa_pod, arg_body: ?*const anyopaque, arg_body_size: u32, arg_suffix: [*c]const u8, arg_suffix_size: u32) c_int { var builder = arg_builder; _ = &builder; var p = arg_p; @@ -10386,14 +10387,14 @@ pub fn spa_pod_builder_primitive_body(arg_builder: [*c]struct_spa_pod_builder, a } return res; } -pub fn spa_pod_builder_primitive(arg_builder: [*c]struct_spa_pod_builder, arg_p: [*c]const struct_spa_pod) callconv(.c) c_int { +pub export fn spa_pod_builder_primitive(arg_builder: [*c]struct_spa_pod_builder, arg_p: [*c]const struct_spa_pod) c_int { var builder = arg_builder; _ = &builder; var p = arg_p; _ = &p; return spa_pod_builder_primitive_body(builder, p, @as(?*const anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(p))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(usize, @sizeOf(struct_spa_pod)))))))), p.*.size, null, @as(u32, @bitCast(@as(c_int, 0)))); } -pub fn spa_pod_builder_none(arg_builder: [*c]struct_spa_pod_builder) callconv(.c) c_int { +pub export fn spa_pod_builder_none(arg_builder: [*c]struct_spa_pod_builder) c_int { var builder = arg_builder; _ = &builder; const p: struct_spa_pod = struct_spa_pod{ @@ -10404,7 +10405,7 @@ pub fn spa_pod_builder_none(arg_builder: [*c]struct_spa_pod_builder) callconv(.c return spa_pod_builder_primitive(builder, &p); } // .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:27:50: warning: ignoring StaticAssert declaration -pub fn spa_pod_builder_child(arg_builder: [*c]struct_spa_pod_builder, arg_size: u32, arg_type: u32) callconv(.c) c_int { +pub export fn spa_pod_builder_child(arg_builder: [*c]struct_spa_pod_builder, arg_size: u32, arg_type: u32) c_int { var builder = arg_builder; _ = &builder; var size = arg_size; @@ -10425,7 +10426,7 @@ pub fn spa_pod_builder_child(arg_builder: [*c]struct_spa_pod_builder, arg_size: } return spa_pod_builder_raw(builder, @as(?*const anyopaque, @ptrCast(&p)), @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_spa_pod)))))); } -pub fn spa_pod_builder_bool(arg_builder: [*c]struct_spa_pod_builder, arg_val: bool) callconv(.c) c_int { +pub export fn spa_pod_builder_bool(arg_builder: [*c]struct_spa_pod_builder, arg_val: bool) c_int { var builder = arg_builder; _ = &builder; var val = arg_val; @@ -10441,7 +10442,7 @@ pub fn spa_pod_builder_bool(arg_builder: [*c]struct_spa_pod_builder, arg_val: bo _ = &p; return spa_pod_builder_primitive(builder, &p.pod); } -pub fn spa_pod_builder_id(arg_builder: [*c]struct_spa_pod_builder, arg_val: u32) callconv(.c) c_int { +pub export fn spa_pod_builder_id(arg_builder: [*c]struct_spa_pod_builder, arg_val: u32) c_int { var builder = arg_builder; _ = &builder; var val = arg_val; @@ -10457,7 +10458,7 @@ pub fn spa_pod_builder_id(arg_builder: [*c]struct_spa_pod_builder, arg_val: u32) _ = &p; return spa_pod_builder_primitive(builder, &p.pod); } -pub fn spa_pod_builder_int(arg_builder: [*c]struct_spa_pod_builder, arg_val: i32) callconv(.c) c_int { +pub export fn spa_pod_builder_int(arg_builder: [*c]struct_spa_pod_builder, arg_val: i32) c_int { var builder = arg_builder; _ = &builder; var val = arg_val; @@ -10473,7 +10474,7 @@ pub fn spa_pod_builder_int(arg_builder: [*c]struct_spa_pod_builder, arg_val: i32 _ = &p; return spa_pod_builder_primitive(builder, &p.pod); } -pub fn spa_pod_builder_long(arg_builder: [*c]struct_spa_pod_builder, arg_val: i64) callconv(.c) c_int { +pub export fn spa_pod_builder_long(arg_builder: [*c]struct_spa_pod_builder, arg_val: i64) c_int { var builder = arg_builder; _ = &builder; var val = arg_val; @@ -10488,7 +10489,7 @@ pub fn spa_pod_builder_long(arg_builder: [*c]struct_spa_pod_builder, arg_val: i6 _ = &p; return spa_pod_builder_primitive(builder, &p.pod); } -pub fn spa_pod_builder_float(arg_builder: [*c]struct_spa_pod_builder, arg_val: f32) callconv(.c) c_int { +pub export fn spa_pod_builder_float(arg_builder: [*c]struct_spa_pod_builder, arg_val: f32) c_int { var builder = arg_builder; _ = &builder; var val = arg_val; @@ -10504,7 +10505,7 @@ pub fn spa_pod_builder_float(arg_builder: [*c]struct_spa_pod_builder, arg_val: f _ = &p; return spa_pod_builder_primitive(builder, &p.pod); } -pub fn spa_pod_builder_double(arg_builder: [*c]struct_spa_pod_builder, arg_val: f64) callconv(.c) c_int { +pub export fn spa_pod_builder_double(arg_builder: [*c]struct_spa_pod_builder, arg_val: f64) c_int { var builder = arg_builder; _ = &builder; var val = arg_val; @@ -10519,7 +10520,7 @@ pub fn spa_pod_builder_double(arg_builder: [*c]struct_spa_pod_builder, arg_val: _ = &p; return spa_pod_builder_primitive(builder, &p.pod); } -pub fn spa_pod_builder_write_string(arg_builder: [*c]struct_spa_pod_builder, arg_str: [*c]const u8, arg_len: u32) callconv(.c) c_int { +pub export fn spa_pod_builder_write_string(arg_builder: [*c]struct_spa_pod_builder, arg_str: [*c]const u8, arg_len: u32) c_int { var builder = arg_builder; _ = &builder; var str = arg_str; @@ -10547,7 +10548,7 @@ pub fn spa_pod_builder_write_string(arg_builder: [*c]struct_spa_pod_builder, arg } return res; } -pub fn spa_pod_builder_string_len(arg_builder: [*c]struct_spa_pod_builder, arg_str: [*c]const u8, arg_len: u32) callconv(.c) c_int { +pub export fn spa_pod_builder_string_len(arg_builder: [*c]struct_spa_pod_builder, arg_str: [*c]const u8, arg_len: u32) c_int { var builder = arg_builder; _ = &builder; var str = arg_str; @@ -10563,7 +10564,7 @@ pub fn spa_pod_builder_string_len(arg_builder: [*c]struct_spa_pod_builder, arg_s _ = &p; return spa_pod_builder_primitive_body(builder, &p.pod, @as(?*const anyopaque, @ptrCast(str)), len, "", @as(u32, @bitCast(@as(c_int, 1)))); } -pub fn spa_pod_builder_string(arg_builder: [*c]struct_spa_pod_builder, arg_str: [*c]const u8) callconv(.c) c_int { +pub export fn spa_pod_builder_string(arg_builder: [*c]struct_spa_pod_builder, arg_str: [*c]const u8) c_int { var builder = arg_builder; _ = &builder; var str = arg_str; @@ -10572,7 +10573,7 @@ pub fn spa_pod_builder_string(arg_builder: [*c]struct_spa_pod_builder, arg_str: _ = &len; return spa_pod_builder_string_len(builder, if (str != null) str else "", len); } -pub fn spa_pod_builder_bytes(arg_builder: [*c]struct_spa_pod_builder, arg_bytes: ?*const anyopaque, arg_len: u32) callconv(.c) c_int { +pub export fn spa_pod_builder_bytes(arg_builder: [*c]struct_spa_pod_builder, arg_bytes: ?*const anyopaque, arg_len: u32) c_int { var builder = arg_builder; _ = &builder; var bytes = arg_bytes; @@ -10588,7 +10589,7 @@ pub fn spa_pod_builder_bytes(arg_builder: [*c]struct_spa_pod_builder, arg_bytes: _ = &p; return spa_pod_builder_primitive_body(builder, &p.pod, bytes, len, null, @as(u32, @bitCast(@as(c_int, 0)))); } -pub fn spa_pod_builder_reserve_bytes(arg_builder: [*c]struct_spa_pod_builder, arg_len: u32) callconv(.c) ?*anyopaque { +pub export fn spa_pod_builder_reserve_bytes(arg_builder: [*c]struct_spa_pod_builder, arg_len: u32) ?*anyopaque { var builder = arg_builder; _ = &builder; var len = arg_len; @@ -10598,7 +10599,7 @@ pub fn spa_pod_builder_reserve_bytes(arg_builder: [*c]struct_spa_pod_builder, ar if (spa_pod_builder_bytes(builder, null, len) < @as(c_int, 0)) return @as(?*anyopaque, @ptrFromInt(@as(c_int, 0))); return @as(?*anyopaque, @ptrFromInt(@as(usize, @intCast(@intFromPtr(builder.*.data))) +% @as(usize, @bitCast(@as(ptrdiff_t, @bitCast(@as(c_ulong, @bitCast(@as(c_ulong, offset))) +% @sizeOf(struct_spa_pod))))))); } -pub fn spa_pod_builder_pointer(arg_builder: [*c]struct_spa_pod_builder, arg_type: u32, arg_val: ?*const anyopaque) callconv(.c) c_int { +pub export fn spa_pod_builder_pointer(arg_builder: [*c]struct_spa_pod_builder, arg_type: u32, arg_val: ?*const anyopaque) c_int { var builder = arg_builder; _ = &builder; var @"type" = arg_type; @@ -10619,7 +10620,7 @@ pub fn spa_pod_builder_pointer(arg_builder: [*c]struct_spa_pod_builder, arg_type _ = &p; return spa_pod_builder_primitive(builder, &p.pod); } -pub fn spa_pod_builder_fd(arg_builder: [*c]struct_spa_pod_builder, arg_fd: i64) callconv(.c) c_int { +pub export fn spa_pod_builder_fd(arg_builder: [*c]struct_spa_pod_builder, arg_fd: i64) c_int { var builder = arg_builder; _ = &builder; var fd = arg_fd; @@ -10634,7 +10635,7 @@ pub fn spa_pod_builder_fd(arg_builder: [*c]struct_spa_pod_builder, arg_fd: i64) _ = &p; return spa_pod_builder_primitive(builder, &p.pod); } -pub fn spa_pod_builder_rectangle(arg_builder: [*c]struct_spa_pod_builder, arg_width: u32, arg_height: u32) callconv(.c) c_int { +pub export fn spa_pod_builder_rectangle(arg_builder: [*c]struct_spa_pod_builder, arg_width: u32, arg_height: u32) c_int { var builder = arg_builder; _ = &builder; var width = arg_width; @@ -10654,7 +10655,7 @@ pub fn spa_pod_builder_rectangle(arg_builder: [*c]struct_spa_pod_builder, arg_wi _ = &p; return spa_pod_builder_primitive(builder, &p.pod); } -pub fn spa_pod_builder_fraction(arg_builder: [*c]struct_spa_pod_builder, arg_num: u32, arg_denom: u32) callconv(.c) c_int { +pub export fn spa_pod_builder_fraction(arg_builder: [*c]struct_spa_pod_builder, arg_num: u32, arg_denom: u32) c_int { var builder = arg_builder; _ = &builder; var num = arg_num; @@ -10674,7 +10675,7 @@ pub fn spa_pod_builder_fraction(arg_builder: [*c]struct_spa_pod_builder, arg_num _ = &p; return spa_pod_builder_primitive(builder, &p.pod); } -pub fn spa_pod_builder_push_array(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame) callconv(.c) c_int { +pub export fn spa_pod_builder_push_array(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame) c_int { var builder = arg_builder; _ = &builder; var frame = arg_frame; @@ -10699,7 +10700,7 @@ pub fn spa_pod_builder_push_array(arg_builder: [*c]struct_spa_pod_builder, arg_f spa_pod_builder_push(builder, frame, &p.pod, offset); return res; } -pub fn spa_pod_builder_array(arg_builder: [*c]struct_spa_pod_builder, arg_child_size: u32, arg_child_type: u32, arg_n_elems: u32, arg_elems: ?*const anyopaque) callconv(.c) c_int { +pub export fn spa_pod_builder_array(arg_builder: [*c]struct_spa_pod_builder, arg_child_size: u32, arg_child_type: u32, arg_n_elems: u32, arg_elems: ?*const anyopaque) c_int { var builder = arg_builder; _ = &builder; var child_size = arg_child_size; @@ -10725,7 +10726,7 @@ pub fn spa_pod_builder_array(arg_builder: [*c]struct_spa_pod_builder, arg_child_ _ = &p; return spa_pod_builder_primitive_body(builder, &p.pod, elems, n_elems *% child_size, null, @as(u32, @bitCast(@as(c_int, 0)))); } -pub fn spa_pod_builder_push_choice(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame, arg_type: u32, arg_flags: u32) callconv(.c) c_int { +pub export fn spa_pod_builder_push_choice(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame, arg_type: u32, arg_flags: u32) c_int { var builder = arg_builder; _ = &builder; var frame = arg_frame; @@ -10756,7 +10757,7 @@ pub fn spa_pod_builder_push_choice(arg_builder: [*c]struct_spa_pod_builder, arg_ spa_pod_builder_push(builder, frame, &p.pod, offset); return res; } -pub fn spa_pod_builder_push_struct(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame) callconv(.c) c_int { +pub export fn spa_pod_builder_push_struct(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame) c_int { var builder = arg_builder; _ = &builder; var frame = arg_frame; @@ -10775,7 +10776,7 @@ pub fn spa_pod_builder_push_struct(arg_builder: [*c]struct_spa_pod_builder, arg_ spa_pod_builder_push(builder, frame, &p.pod, offset); return res; } -pub fn spa_pod_builder_push_object(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame, arg_type: u32, arg_id: u32) callconv(.c) c_int { +pub export fn spa_pod_builder_push_object(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame, arg_type: u32, arg_id: u32) c_int { var builder = arg_builder; _ = &builder; var frame = arg_frame; @@ -10802,7 +10803,7 @@ pub fn spa_pod_builder_push_object(arg_builder: [*c]struct_spa_pod_builder, arg_ spa_pod_builder_push(builder, frame, &p.pod, offset); return res; } -pub fn spa_pod_builder_prop(arg_builder: [*c]struct_spa_pod_builder, arg_key: u32, arg_flags: u32) callconv(.c) c_int { +pub export fn spa_pod_builder_prop(arg_builder: [*c]struct_spa_pod_builder, arg_key: u32, arg_flags: u32) c_int { var builder = arg_builder; _ = &builder; var key = arg_key; @@ -10821,7 +10822,7 @@ pub fn spa_pod_builder_prop(arg_builder: [*c]struct_spa_pod_builder, arg_key: u3 _ = &p; return spa_pod_builder_raw(builder, @as(?*const anyopaque, @ptrCast(&p)), @as(u32, @bitCast(@as(c_uint, @truncate(@sizeOf(struct_unnamed_38)))))); } -pub fn spa_pod_builder_push_sequence(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame, arg_unit: u32) callconv(.c) c_int { +pub export fn spa_pod_builder_push_sequence(arg_builder: [*c]struct_spa_pod_builder, arg_frame: [*c]struct_spa_pod_frame, arg_unit: u32) c_int { var builder = arg_builder; _ = &builder; var frame = arg_frame; @@ -10846,7 +10847,7 @@ pub fn spa_pod_builder_push_sequence(arg_builder: [*c]struct_spa_pod_builder, ar spa_pod_builder_push(builder, frame, &p.pod, offset); return res; } -pub fn spa_pod_builder_control(arg_builder: [*c]struct_spa_pod_builder, arg_offset: u32, arg_type: u32) callconv(.c) c_int { +pub export fn spa_pod_builder_control(arg_builder: [*c]struct_spa_pod_builder, arg_offset: u32, arg_type: u32) c_int { var builder = arg_builder; _ = &builder; var offset = arg_offset; @@ -10868,8 +10869,8 @@ pub fn spa_pod_builder_control(arg_builder: [*c]struct_spa_pod_builder, arg_offs // .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/utils/defs.h:73:27: warning: TODO implement translation of stmt class AttributedStmtClass // .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:489:30: warning: unable to translate function, demoted to extern -pub extern fn spa_choice_from_id_flags(arg_id: u8, arg_flags: [*c]u32) callconv(.c) u32; -pub fn spa_choice_from_id(arg_id: u8) callconv(.c) u32 { +pub extern fn spa_choice_from_id_flags(arg_id: u8, arg_flags: [*c]u32) u32; +pub export fn spa_choice_from_id(arg_id: u8) u32 { var id = arg_id; _ = &id; var flags: u32 = 0; @@ -10879,10 +10880,10 @@ pub fn spa_choice_from_id(arg_id: u8) callconv(.c) u32 { // /home/mason/.cache/zig/p/N-V-__8AAN5NhBR0oTsvnwjPdeNiiDLtEsfXRHd1fv-R3TOv/lib/include/__stdarg_va_arg.h:20:26: warning: unsupported stmt class VAArgExprClass // .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:621:1: warning: unable to translate function, demoted to extern -pub extern fn spa_pod_builder_addv(arg_builder: [*c]struct_spa_pod_builder, arg_args: [*c]struct___va_list_tag_26) callconv(.c) c_int; +pub extern fn spa_pod_builder_addv(arg_builder: [*c]struct_spa_pod_builder, arg_args: [*c]struct___va_list_tag_26) c_int; // .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/builder.h:685:25: warning: TODO unable to translate variadic function, demoted to extern pub extern fn spa_pod_builder_add(builder: [*c]struct_spa_pod_builder, ...) c_int; -pub fn spa_pod_copy(arg_pod: [*c]const struct_spa_pod) callconv(.c) [*c]struct_spa_pod { +pub export fn spa_pod_copy(arg_pod: [*c]const struct_spa_pod) [*c]struct_spa_pod { var pod = arg_pod; _ = &pod; var size: usize = undefined; @@ -12693,7 +12694,7 @@ pub fn spa_type_audio_format_from_short_name(arg_name: [*c]const u8) callconv(.c pub fn spa_type_audio_format_to_short_name(arg_type: u32) callconv(.c) [*c]const u8 { var @"type" = arg_type; _ = &@"type"; - return spa_type_to_short_name(@"type", @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_format[@as(usize, @intCast(0))]))), "UNKNOWN"); + return spa_type_to_short_name(@"type", @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_format[@as(usize, @intCast(0))]))), @as([*c]const u8, "UNKNOWN")); } pub const spa_type_audio_flags: [3]struct_spa_type_info = [3]struct_spa_type_info{ struct_spa_type_info{ @@ -13456,7 +13457,7 @@ pub fn spa_type_audio_iec958_codec_from_short_name(arg_name: [*c]const u8) callc pub fn spa_type_audio_iec958_codec_to_short_name(arg_type: u32) callconv(.c) [*c]const u8 { var @"type" = arg_type; _ = &@"type"; - return spa_type_to_short_name(@"type", @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_iec958_codec[@as(usize, @intCast(0))]))), "UNKNOWN"); + return spa_type_to_short_name(@"type", @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_audio_iec958_codec[@as(usize, @intCast(0))]))), @as([*c]const u8, "UNKNOWN")); } pub const SPA_AUDIO_MP3_CHANNEL_MODE_UNKNOWN: c_int = 0; pub const SPA_AUDIO_MP3_CHANNEL_MODE_MONO: c_int = 1; @@ -15298,7 +15299,7 @@ pub fn spa_type_video_format_from_short_name(arg_name: [*c]const u8) callconv(.c pub fn spa_type_video_format_to_short_name(arg_type: u32) callconv(.c) [*c]const u8 { var @"type" = arg_type; _ = &@"type"; - return spa_type_to_short_name(@"type", @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_video_format[@as(usize, @intCast(0))]))), "UNKNOWN"); + return spa_type_to_short_name(@"type", @as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_video_format[@as(usize, @intCast(0))]))), @as([*c]const u8, "UNKNOWN")); } pub const spa_type_video_flags: [5]struct_spa_type_info = [5]struct_spa_type_info{ struct_spa_type_info{ @@ -16780,7 +16781,7 @@ pub fn spa_debug_strbuf_format_value(arg_buffer: [*c]struct_spa_strbuf, arg_info while (true) { switch (@"type") { @as(u32, @bitCast(@as(c_int, 2))) => { - _ = spa_strbuf_append(buffer, "%s", if (@as([*c]i32, @ptrCast(@alignCast(body))).* != 0) "true" else "false"); + _ = spa_strbuf_append(buffer, "%s", if (@as([*c]i32, @ptrCast(@alignCast(body))).* != 0) @as([*c]const u8, "true") else @as([*c]const u8, "false")); break; }, @as(u32, @bitCast(@as(c_int, 3))) => { @@ -16926,7 +16927,7 @@ pub fn spa_debugc_format(arg_ctx: [*c]struct_spa_debug_context, arg_indent: c_in if (spa_format_parse(format, &mtype, &mstype) < @as(c_int, 0)) return -@as(c_int, 22); media_type = spa_debug_type_find_name(@as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_media_type[@as(usize, @intCast(0))]))), mtype); media_subtype = spa_debug_type_find_name(@as([*c]const struct_spa_type_info, @ptrCast(@alignCast(&spa_type_media_subtype[@as(usize, @intCast(0))]))), mstype); - if (ctx != null) _ = ctx.*.log.?(ctx, "%*s %s/%s", indent, "", if (media_type != null) spa_debug_type_short_name(media_type) else "unknown", if (media_subtype != null) spa_debug_type_short_name(media_subtype) else "unknown") else _ = printf("%*s %s/%s\n", indent, "", if (media_type != null) spa_debug_type_short_name(media_type) else "unknown", if (media_subtype != null) spa_debug_type_short_name(media_subtype) else "unknown"); + if (ctx != null) _ = ctx.*.log.?(ctx, "%*s %s/%s", indent, "", if (media_type != null) spa_debug_type_short_name(media_type) else @as([*c]const u8, "unknown"), if (media_subtype != null) spa_debug_type_short_name(media_subtype) else @as([*c]const u8, "unknown")) else _ = printf("%*s %s/%s\n", indent, "", if (media_type != null) spa_debug_type_short_name(media_type) else @as([*c]const u8, "unknown"), if (media_subtype != null) spa_debug_type_short_name(media_subtype) else @as([*c]const u8, "unknown")); { prop = spa_pod_prop_first(&@as([*c]struct_spa_pod_object, @ptrCast(@constCast(@volatileCast(format)))).*.body); while (spa_pod_prop_is_inside(&@as([*c]struct_spa_pod_object, @ptrCast(@constCast(@volatileCast(format)))).*.body, @as([*c]struct_spa_pod, @ptrCast(@alignCast(@as([*c]struct_spa_pod_object, @ptrCast(@constCast(@volatileCast(format))))))).*.size, prop)) : (prop = spa_pod_prop_next(prop)) { @@ -16961,7 +16962,7 @@ pub fn spa_debugc_format(arg_ctx: [*c]struct_spa_debug_context, arg_indent: c_in ti = spa_debug_type_find(info, prop.*.key); key = if (ti != null) ti.*.name else null; spa_strbuf_init(&buf, @as([*c]u8, @ptrCast(@alignCast(&buffer[@as(usize, @intCast(0))]))), @sizeOf([1024]u8)); - _ = spa_strbuf_append(&buf, "%*s %16s : (%s) ", indent, "", if (key != null) spa_debug_type_short_name(key) else "unknown", spa_debug_type_short_name(spa_types[@"type"].name)); + _ = spa_strbuf_append(&buf, "%*s %16s : (%s) ", indent, "", if (key != null) spa_debug_type_short_name(key) else @as([*c]const u8, "unknown"), spa_debug_type_short_name(spa_types[@"type"].name)); if (choice == @as(u32, @bitCast(SPA_CHOICE_None))) { _ = spa_debug_strbuf_format_value(&buf, if (ti != null) ti.*.values else null, @"type", vals, size); } else { @@ -17500,6 +17501,7 @@ pub const __STDC_EMBED_FOUND__ = @as(c_int, 1); pub const __STDC_EMBED_EMPTY__ = @as(c_int, 2); pub const __GLIBC_MINOR__ = @as(c_int, 39); pub const __GCC_HAVE_DWARF2_CFI_ASM = @as(c_int, 1); +pub const SPA_API_POD_BUILDER = ""; pub const SPA_UTILS_DEFS_H = ""; pub const __CLANG_INTTYPES_H = ""; pub const _INTTYPES_H = @as(c_int, 1); @@ -21823,7 +21825,6 @@ pub inline fn SPA_POD_SEQUENCE_FOREACH(seq: anytype, iter: anytype) @TypeOf(SPA_ pub const spa_pod_copy_array = @compileError("unable to translate C expr: expected ')' instead got '['"); // .zig-cache/o/02bffcaf992888ed133e34d5004035bf/spa/pod/iter.h:219:9 pub const SPA_POD_BUILDER_H = ""; -pub const SPA_API_POD_BUILDER = SPA_API_IMPL; pub const SPA_POD_BUILDER_FLAG_BODY = @as(c_int, 1) << @as(c_int, 0); pub const SPA_POD_BUILDER_FLAG_FIRST = @as(c_int, 1) << @as(c_int, 1); pub const SPA_VERSION_POD_BUILDER_CALLBACKS = @as(c_int, 0); diff --git a/src/screen_play.zig b/src/screen_play.zig new file mode 100644 index 0000000..4a6ff51 --- /dev/null +++ b/src/screen_play.zig @@ -0,0 +1,842 @@ +const std = @import("std"); +const log = std.log; + +// const builtin = @import("builtin"); +// const std = @import("std"); +// const zin = @import("zin"); +// const win32 = zin.platform.win32; + +// pub const zin_config: zin.Config = .{ +// .StaticWindowId = StaticWindowId, +// }; + +// const StaticWindowId = enum { +// main, + +// pub fn getConfig(self: StaticWindowId) zin.WindowConfigData { +// return switch (self) { +// .main => .{ +// .window_size_events = true, +// .key_events = false, +// .mouse_events = false, +// .timers = .one, +// .background = .{ .r = 49, .g = 49, .b = 49 }, +// .dynamic_background = false, +// .win32 = .{ .render = .{ .gdi = .{} } }, +// .x11 = .{ .render_kind = .double_buffered }, +// }, +// }; +// } +// }; + +// const global = struct { +// // var class_extra: ?zin.WindowClass = null; +// var last_animation: ?std.time.Instant = null; +// var text_position: f32 = 0; +// var mouse_position: ?zin.XY = null; +// }; + +// pub fn main() !void { +// try zin.processInit(.{}); +// { +// var err: zin.X11ConnectError = undefined; +// zin.x11Connect(&err) catch std.debug.panic("X11 connect failed: {f}", .{err}); +// } +// defer zin.x11Disconnect(); + +// zin.staticWindow(.main).registerClass(.{ +// .callback = callback, +// .win32_name = zin.L("Screen Play"), +// .macos_view = "Screen Play", +// }, .{ +// .win32_icon_large = .none, +// .win32_icon_small = .none, +// }); +// defer zin.staticWindow(.main).unregisterClass(); + +// try zin.staticWindow(.main).create(.{ +// .title = "Screen Play", +// .size = .{ .client_points = .{ .x = 300, .y = 200 } }, +// .pos = null, +// }); +// defer zin.staticWindow(.main).destroy(); +// zin.staticWindow(.main).show(); +// zin.staticWindow(.main).startTimer({}, 14); + +// try zin.mainLoop(); +// } + +// fn callback(cb: zin.Callback(.{ .static = .main })) void { +// switch (cb) { +// .close => zin.quitMainLoop(), +// .draw => |d| { +// zin.staticWindow(.main).invalidate(); +// { +// const now = std.time.Instant.now() catch @panic("?"); +// const elapsed_ns = if (global.last_animation) |l| now.since(l) else 0; +// global.last_animation = now; + +// const speed: f32 = 0.0000000001; +// global.text_position = @mod(global.text_position + speed * @as(f32, @floatFromInt(elapsed_ns)), 1.0); +// } + +// const size = zin.staticWindow(.main).getClientSize(); +// d.clear(); +// const animate: zin.XY = .{ +// .x = @intFromFloat(@round(@as(f32, @floatFromInt(size.x)) * global.text_position)), +// .y = @intFromFloat(@round(@as(f32, @floatFromInt(size.y)) * global.text_position)), +// }; +// const dpi_scale = d.getDpiScale(); + +// // currenly only supported on windows +// if (zin.platform_kind == .win32 or zin.platform_kind == .x11) { +// var pentagon = [5]zin.PolygonPoint{ +// .xy(zin.scale(i32, 200, dpi_scale.x), zin.scale(i32, 127, dpi_scale.y)), // top +// .xy(zin.scale(i32, 232, dpi_scale.x), zin.scale(i32, 150, dpi_scale.y)), // top right +// .xy(zin.scale(i32, 220, dpi_scale.x), zin.scale(i32, 187, dpi_scale.y)), // bottom right +// .xy(zin.scale(i32, 180, dpi_scale.x), zin.scale(i32, 187, dpi_scale.y)), // bottom left +// .xy(zin.scale(i32, 168, dpi_scale.x), zin.scale(i32, 150, dpi_scale.y)), // top left +// }; +// d.polygon(&pentagon, .blue); +// } + +// const rect_size = zin.scale(i32, 10, dpi_scale.x); +// d.rect(.ltwh(animate.x, size.y - animate.y, rect_size, rect_size), .red); +// const margin_left = zin.scale(i32, 10, dpi_scale.x); +// const top = zin.scale(i32, 50, dpi_scale.y); +// d.text("Press 'n' to create a new window.", margin_left, top, .white); +// d.text("Weeee!!!", animate.x, animate.y, .white); +// if (global.mouse_position) |p| { +// d.text("Mouse", p.x, p.y, .white); +// } +// }, +// .timer => zin.staticWindow(.main).invalidate(), +// else => {}, +// } +// } + +const c = @import("c.zig"); +// const c = @cImport({ +// @cInclude("spa/utils/defs.h"); +// @cInclude("pipewire/pipewire.h"); +// @cInclude("spa/param/video/format-utils.h"); +// @cInclude("spa/debug/format.h"); +// }); + +// XXX: ... +// #include +// #include +// #include + +// #include +// #include +// #include +// #include +// #include +// #include + +// #include + +// XXX: use rate +const width = 1920; +const height = 1080; +const rate = 30; + +// #define MAX_BUFFERS 64 + +// #include "sdl.h" + +// struct pixel { +// float r, g, b, a; +// }; + +const Data = struct { + // path: []const u8, + + // SDL_Renderer *renderer; + // SDL_Window *window; + // SDL_Texture *texture; + // SDL_Texture *cursor; + + loop: *c.pw_main_loop, + + // stream: *c.pw_stream, + // stream_listener: *c.spa_hook, + + // position: *c.spa_io_position, + + // format: c.spa_video_info, + // stride: i32, + // size: c.spa_rectangle, + + // counter: c_int, // XXX: type? + // rect: c.SDL_FRect, + // cursor_rect: c.SDL_FRect, + // is_yuv: bool, +}; + +// static void handle_events(struct data *data) +// { +// // SDL_Event event; +// // while (SDL_PollEvent(&event)) { +// // switch (event.type) { +// // case SDL_EVENT_QUIT: +// // pw_main_loop_quit(data->loop); +// // break; +// // } +// // } +// } + +// /* our data processing function is in general: +// * +// * struct pw_buffer *b; +// * b = pw_stream_dequeue_buffer(stream); +// * +// * .. do stuff with buffer ... +// * +// * pw_stream_queue_buffer(stream, b); +// */ +fn onProcess(data: ?*anyopaque) callconv(.c) void { + _ = data; + // struct data *data = _data; + // struct pw_stream *stream = data->stream; + // struct pw_buffer *b; + // struct spa_buffer *buf; + // void *sdata, *ddata; + // int sstride, dstride, ostride; + // struct spa_meta_region *mc; + // struct spa_meta_cursor *mcs; + // struct spa_meta_header *h; + // uint32_t i, j; + // uint8_t *src, *dst; + // bool render_cursor = false; + + // b = NULL; + // while (true) { + // struct pw_buffer *t; + // if ((t = pw_stream_dequeue_buffer(stream)) == NULL) + // break; + // if (b) + // pw_stream_queue_buffer(stream, b); + // b = t; + // } + // if (b == NULL) { + // pw_log_warn("out of buffers: %m"); + // return; + // } + + // buf = b->buffer; + + // pw_log_trace("new buffer %p", buf); + + // handle_events(data); + + // if ((sdata = buf->datas[0].data) == NULL) + // goto done; + + // if ((h = spa_buffer_find_meta_data(buf, SPA_META_Header, sizeof(*h)))) { + // uint64_t now = pw_stream_get_nsec(stream); + // pw_log_debug("now:%"PRIu64" pts:%"PRIu64" diff:%"PRIi64, + // now, h->pts, now - h->pts); + // } + + // /* get the videocrop metadata if any */ + // if ((mc = spa_buffer_find_meta_data(buf, SPA_META_VideoCrop, sizeof(*mc))) && + // spa_meta_region_is_valid(mc)) { + // data->rect.x = mc->region.position.x; + // data->rect.y = mc->region.position.y; + // data->rect.w = mc->region.size.width; + // data->rect.h = mc->region.size.height; + // } + // /* get cursor metadata */ + // if ((mcs = spa_buffer_find_meta_data(buf, SPA_META_Cursor, sizeof(*mcs))) && + // spa_meta_cursor_is_valid(mcs)) { + // struct spa_meta_bitmap *mb; + // void *cdata; + // int cstride; + + // data->cursor_rect.x = mcs->position.x; + // data->cursor_rect.y = mcs->position.y; + + // mb = SPA_PTROFF(mcs, mcs->bitmap_offset, struct spa_meta_bitmap); + // data->cursor_rect.w = mb->size.width; + // data->cursor_rect.h = mb->size.height; + + // // if (data->cursor == NULL) { + // // data->cursor = SDL_CreateTexture(data->renderer, + // // id_to_sdl_format(mb->format), + // // SDL_TEXTUREACCESS_STREAMING, + // // mb->size.width, mb->size.height); + // // SDL_SetTextureBlendMode(data->cursor, SDL_BLENDMODE_BLEND); + // // } + + // // if (!SDL_LockTexture(data->cursor, NULL, &cdata, &cstride)) { + // // fprintf(stderr, "Couldn't lock cursor texture: %s\n", SDL_GetError()); + // // goto done; + // // } + + // /* copy the cursor bitmap into the texture */ + // src = SPA_PTROFF(mb, mb->offset, uint8_t); + // dst = cdata; + // ostride = SPA_MIN(cstride, mb->stride); + + // for (i = 0; i < mb->size.height; i++) { + // memcpy(dst, src, ostride); + // dst += cstride; + // src += mb->stride; + // } + // // SDL_UnlockTexture(data->cursor); + + // render_cursor = true; + // } + + // /* copy video image in texture */ + // if (data->is_yuv) { + // void *datas[4]; + // sstride = data->stride; + // if (buf->n_datas == 1) { + // // SDL_UpdateTexture(data->texture, NULL, + // // sdata, sstride); + // } else { + // datas[0] = sdata; + // datas[1] = buf->datas[1].data; + // datas[2] = buf->datas[2].data; + // // SDL_UpdateYUVTexture(data->texture, NULL, + // // datas[0], sstride, + // // datas[1], sstride / 2, + // // datas[2], sstride / 2); + // } + // } + // else { + // // if (!SDL_LockTexture(data->texture, NULL, &ddata, &dstride)) { + // // fprintf(stderr, "Couldn't lock texture: %s\n", SDL_GetError()); + // // } + + // sstride = buf->datas[0].chunk->stride; + // if (sstride == 0) + // sstride = buf->datas[0].chunk->size / data->size.height; + // ostride = SPA_MIN(sstride, dstride); + + // src = sdata; + // dst = ddata; + + // if (data->format.media_subtype == SPA_MEDIA_SUBTYPE_dsp) { + // for (i = 0; i < data->size.height; i++) { + // struct pixel *p = (struct pixel *) src; + // for (j = 0; j < data->size.width; j++) { + // dst[j * 4 + 0] = SPA_CLAMP((uint8_t)(p[j].r * 255.0f), 0u, 255u); + // dst[j * 4 + 1] = SPA_CLAMP((uint8_t)(p[j].g * 255.0f), 0u, 255u); + // dst[j * 4 + 2] = SPA_CLAMP((uint8_t)(p[j].b * 255.0f), 0u, 255u); + // dst[j * 4 + 3] = SPA_CLAMP((uint8_t)(p[j].a * 255.0f), 0u, 255u); + // } + // src += sstride; + // dst += dstride; + // } + // } else { + // for (i = 0; i < data->size.height; i++) { + // memcpy(dst, src, ostride); + // src += sstride; + // dst += dstride; + // } + // } + // // SDL_UnlockTexture(data->texture); + // } + + // // SDL_RenderClear(data->renderer); + // // /* now render the video and then the cursor if any */ + // // SDL_RenderTexture(data->renderer, data->texture, &data->rect, NULL); + // // if (render_cursor) { + // // SDL_RenderTexture(data->renderer, data->cursor, NULL, &data->cursor_rect); + // // } + // // SDL_RenderPresent(data->renderer); + + // done: + // pw_stream_queue_buffer(stream, b); +} + +fn onStreamStateChanged( + data: ?*anyopaque, + old: c.pw_stream_state, + state: c.pw_stream_state, + err: [*c]const u8, +) callconv(.c) void { + _ = data; + _ = old; + _ = state; + _ = err; + // XXX: ... + // struct data *data = _data; + // fprintf(stderr, "stream state: \"%s\"\n", pw_stream_state_as_string(state)); + // switch (state) { + // case PW_STREAM_STATE_UNCONNECTED: + // pw_main_loop_quit(data->loop); + // break; + // case PW_STREAM_STATE_PAUSED: + // /* because we started inactive, activate ourselves now */ + // pw_stream_set_active(data->stream, true); + // break; + // default: + // break; + // } +} + +fn onStreamIoChanged(data: ?*anyopaque, id: u32, area: ?*anyopaque, size: u32) callconv(.c) void { + _ = data; + _ = id; + _ = area; + _ = size; + // XXX: ... + // struct data *data = _data; + + // switch (id) { + // case SPA_IO_Position: + // data->position = area; + // break; + // } +} + +// /* Be notified when the stream param changes. We're only looking at the +// * format changes. +// * +// * We are now supposed to call pw_stream_finish_format() with success or +// * failure, depending on if we can support the format. Because we gave +// * a list of supported formats, this should be ok. +// * +// * As part of pw_stream_finish_format() we can provide parameters that +// * will control the buffer memory allocation. This includes the metadata +// * that we would like on our buffer, the size, alignment, etc. +// */ +fn onStreamParamChanged(data: ?*anyopaque, id: u32, param: [*c]const c.spa_pod) callconv(.c) void { + _ = data; + _ = id; + _ = param; + // struct data *data = _data; + // struct pw_stream *stream = data->stream; + // uint8_t params_buffer[1024]; + // struct spa_pod_builder b = SPA_POD_BUILDER_INIT(params_buffer, sizeof(params_buffer)); + // const struct spa_pod *params[5]; + // uint32_t n_params = 0; + // Uint32 sdl_format; + // void *d; + // int32_t mult, size, blocks; + + // if (param != NULL && id == SPA_PARAM_Tag) { + // spa_debug_pod(0, NULL, param); + // return; + // } + // if (param != NULL && id == SPA_PARAM_Latency) { + // struct spa_latency_info info; + // if (spa_latency_parse(param, &info) >= 0) + // fprintf(stderr, "got latency: %"PRIu64"\n", (info.min_ns + info.max_ns) / 2); + // return; + // } + // /* NULL means to clear the format */ + // if (param == NULL || id != SPA_PARAM_Format) + // return; + + // fprintf(stderr, "got format:\n"); + // spa_debug_format(2, NULL, param); + + // if (spa_format_parse(param, &data->format.media_type, &data->format.media_subtype) < 0) + // return; + + // if (data->format.media_type != SPA_MEDIA_TYPE_video) + // return; + + // switch (data->format.media_subtype) { + // case SPA_MEDIA_SUBTYPE_raw: + // /* call a helper function to parse the format for us. */ + // spa_format_video_raw_parse(param, &data->format.info.raw); + // sdl_format = id_to_sdl_format(data->format.info.raw.format); + // data->size = SPA_RECTANGLE(data->format.info.raw.size.width, + // data->format.info.raw.size.height); + // mult = 1; + // break; + // case SPA_MEDIA_SUBTYPE_dsp: + // spa_format_video_dsp_parse(param, &data->format.info.dsp); + // if (data->format.info.dsp.format != SPA_VIDEO_FORMAT_DSP_F32) + // return; + // sdl_format = SDL_PIXELFORMAT_RGBA32; + // data->size = SPA_RECTANGLE(data->position->video.size.width, + // data->position->video.size.height); + // mult = 4; + // break; + // default: + // sdl_format = SDL_PIXELFORMAT_UNKNOWN; + // break; + // } + + // if (sdl_format == SDL_PIXELFORMAT_UNKNOWN) { + // pw_stream_set_error(stream, -EINVAL, "unknown pixel format"); + // return; + // } + // if (data->size.width == 0 || data->size.height == 0) { + // pw_stream_set_error(stream, -EINVAL, "invalid size"); + // return; + // } + + // data->texture = SDL_CreateTexture(data->renderer, + // sdl_format, + // SDL_TEXTUREACCESS_STREAMING, + // data->size.width, + // data->size.height); + // switch(sdl_format) { + // case SDL_PIXELFORMAT_YV12: + // case SDL_PIXELFORMAT_IYUV: + // data->stride = data->size.width; + // size = (data->stride * data->size.height) * 3 / 2; + // data->is_yuv = true; + // blocks = 3; + // break; + // case SDL_PIXELFORMAT_YUY2: + // data->is_yuv = true; + // data->stride = data->size.width * 2; + // size = (data->stride * data->size.height); + // blocks = 1; + // break; + // default: + // if (!SDL_LockTexture(data->texture, NULL, &d, &data->stride)) { + // fprintf(stderr, "Couldn't lock texture: %s\n", SDL_GetError()); + // data->stride = data->size.width * 2; + // } else + // SDL_UnlockTexture(data->texture); + // size = data->stride * data->size.height; + // blocks = 1; + // break; + // } + + // data->rect.x = 0; + // data->rect.y = 0; + // data->rect.w = data->size.width; + // data->rect.h = data->size.height; + + // /* a SPA_TYPE_OBJECT_ParamBuffers object defines the acceptable size, + // * number, stride etc of the buffers */ + // params[n_params++] = spa_pod_builder_add_object(&b, + // SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers, + // SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(8, 2, MAX_BUFFERS), + // SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(blocks), + // SPA_PARAM_BUFFERS_size, SPA_POD_Int(size * mult), + // SPA_PARAM_BUFFERS_stride, SPA_POD_Int(data->stride * mult), + // SPA_PARAM_BUFFERS_dataType, SPA_POD_CHOICE_FLAGS_Int((1<loop); +// } + +// XXX: document where this is adapted from if we keep the comments and such, probalby jsut don't keep them? +pub fn main() void { + // struct data data = { 0, }; + var buffer: [1024]u8 = undefined; + var b: c.spa_pod_builder = .{ + .data = &buffer, + .size = buffer.len, + ._padding = 0, + .state = .{ .offset = 0, .flags = 0, .frame = null }, + .callbacks = .{ .funcs = null, .data = null }, + }; + // struct pw_properties *props; + // int res, n_params; + + c.pw_init(0, null); + defer c.pw_deinit(); + + // /* create a main loop */ + // Create a main loop + // XXX: ...add to data + const loop = c.pw_main_loop_new(null).?; + + // create a simple stream, the simple stream manages to core and remote + // objects for you if you don't need to deal with them + // + // If you plan to autoconnect your stream, you need to provide at least + // media, category and role properties + // + // Pass your events and a user_data pointer as the last arguments. This + // will inform you about the stream state. The most important event + // you need to listen to is the process event where you need to consume + // the data provided to you. + // + const props = c.pw_properties_new( + c.PW_KEY_MEDIA_TYPE, + "Video", + c.PW_KEY_MEDIA_CATEGORY, + "Capture", + c.PW_KEY_MEDIA_ROLE, + "Camera", + @as(?*anyopaque, null), + ); + // XXX: need this? + // data.path = argc > 1 ? argv[1] : NULL; + // if (data.path) + // pw_properties_set(props, PW_KEY_TARGET_OBJECT, data.path); + + // XXX: add to data? + // XXX: make var if modified? + var data: Data = .{ + .loop = loop, + }; + const stream = c.pw_stream_new_simple( + c.pw_main_loop_get_loop(data.loop), + "video-play", + props, + &.{ + .version = c.PW_VERSION_STREAM_EVENTS, + .state_changed = &onStreamStateChanged, + .io_changed = &onStreamIoChanged, + .param_changed = &onStreamParamChanged, + .process = &onProcess, + }, + &data, + ); + _ = stream; + + // // if (!SDL_Init(SDL_INIT_VIDEO)) { + // // fprintf(stderr, "can't initialize SDL: %s\n", SDL_GetError()); + // // return -1; + // // } + + // // if (!SDL_CreateWindowAndRenderer("Demo", WIDTH, HEIGHT, SDL_WINDOW_RESIZABLE, &data.window, &data.renderer)) { + // // fprintf(stderr, "can't create window: %s\n", SDL_GetError()); + // // return -1; + // // } + + // /* build the extra parameters to connect with. To connect, we can provide + // * a list of supported formats. We use a builder that writes the param + // * object to the stack. */ + var params: [3]?*c.spa_pod = undefined; // XXX: nullable or not? + const n_params = buildFormat(&data, &b, ¶ms); + _ = n_params; + + // { + // struct spa_pod_frame f; + // struct spa_dict_item items[1]; + // /* send a tag, input tags travel upstream */ + // spa_tag_build_start(&b, &f, SPA_PARAM_Tag, SPA_DIRECTION_INPUT); + // items[0] = SPA_DICT_ITEM_INIT("my-tag-other-key", "my-special-other-tag-value"); + // spa_tag_build_add_dict(&b, &SPA_DICT_INIT(items, 1)); + // params[n_params++] = spa_tag_build_end(&b, &f); + // } + + // /* now connect the stream, we need a direction (input/output), + // * an optional target node to connect to, some flags and parameters + // */ + // if ((res = pw_stream_connect(data.stream, + // PW_DIRECTION_INPUT, + // PW_ID_ANY, + // PW_STREAM_FLAG_AUTOCONNECT | /* try to automatically connect this stream */ + // PW_STREAM_FLAG_INACTIVE | /* we will activate ourselves */ + // PW_STREAM_FLAG_MAP_BUFFERS, /* mmap the buffer data for us */ + // params, n_params)) /* extra parameters, see above */ < 0) { + // fprintf(stderr, "can't connect: %s\n", spa_strerror(res)); + // return -1; + // } + + // /* do things until we quit the mainloop */ + // pw_main_loop_run(data.loop); + + // pw_stream_destroy(data.stream); + // pw_main_loop_destroy(data.loop); + + // // SDL_DestroyTexture(data.texture); + // // if (data.cursor) + // // SDL_DestroyTexture(data.cursor); + // // SDL_DestroyRenderer(data.renderer); + // // SDL_DestroyWindow(data.window); +} + +// XXX: sdl... +// XXX: ... + +// /* PipeWire */ +// /* SPDX-FileCopyrightText: Copyright © 2018 Wim Taymans */ +// /* SPDX-License-Identifier: MIT */ + +// /* +// [title] +// SDL2 video format conversions +// [title] +// */ + +// #include + +// #include +// #include +// #include +// #include + +const VideoFormat = struct { + format: u32, + id: u32, +}; +const sdl_video_formats = [_]VideoFormat{ + .{ c.SDL_PIXELFORMAT_UNKNOWN, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_INDEX1LSB, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_UNKNOWN, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_INDEX1LSB, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_INDEX1MSB, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_INDEX4LSB, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_INDEX4MSB, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_INDEX8, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_RGB332, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_XRGB4444, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_XRGB1555, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_XBGR1555, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_ARGB4444, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_RGBA4444, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_ABGR4444, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_BGRA4444, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_ARGB1555, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_RGBA5551, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_ABGR1555, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_BGRA5551, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_RGB565, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_BGR565, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_RGB24, c.SPA_VIDEO_FORMAT_BGR }, + .{ c.SDL_PIXELFORMAT_XRGB8888, c.SPA_VIDEO_FORMAT_BGR }, + .{ c.SDL_PIXELFORMAT_RGBX8888, c.SPA_VIDEO_FORMAT_xBGR }, + .{ c.SDL_PIXELFORMAT_BGR24, c.SPA_VIDEO_FORMAT_RGB }, + .{ c.SDL_PIXELFORMAT_XBGR8888, c.SPA_VIDEO_FORMAT_RGB }, + .{ c.SDL_PIXELFORMAT_BGRX8888, c.SPA_VIDEO_FORMAT_xRGB }, + .{ c.SDL_PIXELFORMAT_ARGB2101010, c.SPA_VIDEO_FORMAT_UNKNOWN }, + .{ c.SDL_PIXELFORMAT_RGBA8888, c.SPA_VIDEO_FORMAT_ABGR }, + .{ c.SDL_PIXELFORMAT_ARGB8888, c.SPA_VIDEO_FORMAT_BGRA }, + .{ c.SDL_PIXELFORMAT_BGRA8888, c.SPA_VIDEO_FORMAT_ARGB }, + .{ c.SDL_PIXELFORMAT_ABGR8888, c.SPA_VIDEO_FORMAT_RGBA }, + .{ c.SDL_PIXELFORMAT_YV12, c.SPA_VIDEO_FORMAT_YV12 }, + .{ c.SDL_PIXELFORMAT_IYUV, c.SPA_VIDEO_FORMAT_I420 }, + .{ c.SDL_PIXELFORMAT_YUY2, c.SPA_VIDEO_FORMAT_YUY2 }, + .{ c.SDL_PIXELFORMAT_UYVY, c.SPA_VIDEO_FORMAT_UYVY }, + .{ c.SDL_PIXELFORMAT_YVYU, c.SPA_VIDEO_FORMAT_YVYU }, + .{ c.SDL_PIXELFORMAT_NV12, c.SPA_VIDEO_FORMAT_NV12 }, + .{ c.SDL_PIXELFORMAT_NV21, c.SPA_VIDEO_FORMAT_NV21 }, +}; + +fn sdlBuildFormats( + // renderer: *c.SDL_Renderer, + b: *c.spa_pod_builder, +) ?*c.spa_pod { + // // uint32_t i, c; + var f: [2]c.spa_pod_frame = undefined; + // XXX: results ignored? + _ = c.spa_pod_builder_push_object(b, &f[0], c.SPA_TYPE_OBJECT_Format, c.SPA_PARAM_EnumFormat); + _ = c.spa_pod_builder_prop(b, c.SPA_FORMAT_mediaType, 0); + _ = c.spa_pod_builder_id(b, c.SPA_MEDIA_TYPE_video); + _ = c.spa_pod_builder_prop(b, c.SPA_FORMAT_mediaSubtype, 0); + _ = c.spa_pod_builder_id(b, c.SPA_MEDIA_SUBTYPE_raw); + + _ = c.spa_pod_builder_prop(b, c.SPA_FORMAT_VIDEO_format, 0); + _ = c.spa_pod_builder_push_choice(b, &f[1], c.SPA_CHOICE_Enum, 0); + + // // const props: c.SDL_PropertiesID = c.SDL_GetRendererProperties(renderer); + + // // const SDL_PixelFormat *texture_formats = nullptr; + // // SDL_GetPointerProperty( + // // props, + // // SDL_PROP_RENDERER_TEXTURE_FORMATS_POINTER, + // // NULL + // // ); + + // c.SPA_FOR_EACH_ELEMENT_VAR(sdl_video_formats, f) { + // var id: u32 = f.id; + // if (id != c.SPA_VIDEO_FORMAT_UNKNOWN) + // c.spa_pod_builder_id(b, id); + // } + + // XXX: hack: just picked a format for now + _ = c.spa_pod_builder_id(b, c.SPA_VIDEO_FORMAT_BGR); + + _ = c.spa_pod_builder_id(b, c.SPA_VIDEO_FORMAT_RGBA_F32); + _ = c.spa_pod_builder_pop(b, &f[1]); + // add size and framerate ranges + const max_texture_size: u64 = 4096; + _ = c.spa_pod_builder_add( + b, + c.SPA_FORMAT_VIDEO_size, + c.SPA_POD_CHOICE_RANGE_Rectangle( + &c.SPA_RECTANGLE(width, height), + &c.SPA_RECTANGLE(1, 1), + &c.SPA_RECTANGLE(max_texture_size, max_texture_size), + ), + c.SPA_FORMAT_VIDEO_framerate, + c.SPA_POD_CHOICE_RANGE_Fraction( + &c.SPA_FRACTION(rate, 1), + &c.SPA_FRACTION(0, 1), + &c.SPA_FRACTION(30, 1), + ), + @as(c_int, 0), + ); + return @ptrCast(@alignCast(c.spa_pod_builder_pop(b, &f[0]))); +}